Running Agents

import { Agent, run } from "@usestratus/sdk/core";
import { AzureResponsesModel } from "@usestratus/sdk";

const model = new AzureResponsesModel({
  endpoint: process.env.AZURE_ENDPOINT!,
  apiKey: process.env.AZURE_API_KEY!,
  deployment: "gpt-5.2",
});

const agent = new Agent({
  name: "assistant",
  model,
  instructions: "You are a helpful assistant.",
});

const result = await run(agent, "What is the capital of France?"); 

console.log(result.output);       // "The capital of France is Paris."
console.log(result.messages);     // Full message history (system, user, assistant, tool)
console.log(result.lastAgent);    // The agent that produced the final response
console.log(result.usage);        // { promptTokens, completionTokens, totalTokens }
console.log(result.finishReason); // "stop"
console.log(result.finalOutput);  // undefined (no outputType set)

const result1 = await run(agent1, "Research this topic");
const result2 = await run(agent2, result1.toInputList()); 

import { Agent, stream } from "@usestratus/sdk/core";

const agent = new Agent({
  name: "writer",
  model,
  instructions: "You are a creative writer.",
});

const { stream: s, result } = stream(agent, "Write a haiku about TypeScript"); 

for await (const event of s) { 
  if (event.type === "content_delta") {
    process.stdout.write(event.content);
  }
}

const finalResult = await result; 
console.log(finalResult.output);
console.log(finalResult.usage);

import { prompt } from "@usestratus/sdk/core";

const result = await prompt("What is 2 + 2?", { 
  model,
  instructions: "You are a math tutor.",
  tools: [calculator],
});

console.log(result.output); // "4"

await run(agent, input, {
  toolErrorFormatter: (toolName, error) => { 
    return `Tool "${toolName}" failed: ${error instanceof Error ? error.message : String(error)}`;
  },
});

await run(agent, input, {
  callModelInputFilter: ({ agent, request, context }) => { 
    console.log(`Sending ${request.messages.length} messages to ${agent.name}`);
    return request; // Return modified or original request
  },
});

await run(agent, input, {
  maxTurns: 3,
  errorHandlers: {
    maxTurns: ({ agent, messages, context, maxTurns }) => { 
      return new RunResult({
        output: "I need more time to complete this task.",
        messages,
        usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
        lastAgent: agent,
      });
    },
  },
});

const agent = new Agent({
  name: "assistant",
  model,
  tools: [getWeather],
  modelSettings: { toolChoice: "required" },
});

await run(agent, "What's the weather?", {
  resetToolChoice: true, 
});

// Only allow MCP GitHub tools
await run(agent, "Search for issues", {
  allowedTools: ["mcp__github__*"], 
});

// Allow specific tools by name
await run(agent, "Get weather and calculate", {
  allowedTools: ["get_weather", "calculate"], 
});

// Empty array = no tools (agent responds with text only)
await run(agent, "Hello", {
  allowedTools: [], 
});

import type { CanUseTool } from "@usestratus/sdk/core";

const canUseTool: CanUseTool = async (toolName, input, context) => {
  // Ask the user for permission
  const approved = await promptUser(`Allow ${toolName}?`);

  if (!approved) {
    return { behavior: "deny", message: "User rejected this action" }; 
  }

  return { behavior: "allow" }; 
};

await run(agent, "Delete the file", { canUseTool });

const canUseTool: CanUseTool = async (toolName, input) => ({
  behavior: "allow",
  updatedInput: { ...input, safe_mode: true }, 
});

const { stream: s, result, interrupt } = stream(agent, "Do a complex task", { 
  maxTurns: 20,
});

for await (const event of s) {
  if (event.type === "done") {
    if (shouldStop()) {
      interrupt(); 
    }
  }
}

const r = await result; // Resolves normally with partial result
console.log(r.numTurns); // Number of turns completed before interrupt