Reducing Latency

import { Agent, stream } from "stratus-sdk/core";
import { AzureResponsesModel } from "stratus-sdk";

const model = new AzureResponsesModel({ deployment: "gpt-5.2" });
const agent = new Agent({ name: "assistant", model });

// First token appears in ~200ms, response builds incrementally
const { stream: s, result } = stream(agent, "Explain how TCP works"); 

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

const finalResult = await result;
console.log(`\n\nTokens: ${finalResult.usage.totalTokens}`);

import { AzureResponsesModel } from "stratus-sdk";

// Fast model for simple routing, classification, and extraction
const fastModel = new AzureResponsesModel({ deployment: "gpt-4.1-mini" }); 

// Full model for complex reasoning and multi-step planning
const fullModel = new AzureResponsesModel({ deployment: "gpt-5.2" }); 

import { Agent } from "stratus-sdk/core";

// Router: classifies intent - fast model is fine
const router = new Agent({
  name: "router",
  model: fastModel, 
  instructions: "Classify the user's intent as one of: billing, technical, account, other.",
  outputType: z.object({ intent: z.enum(["billing", "technical", "account", "other"]) }),
});

// Researcher: synthesizes complex answers - needs the full model
const researcher = new Agent({
  name: "researcher",
  model: fullModel, 
  instructions: "You are a research assistant. Use tools to find information and provide detailed answers.",
  tools: [searchDocs, queryDatabase],
});

// Concise: ~30 tokens, same accuracy
const agent = new Agent({
  name: "classifier",
  model,
  instructions: "Classify the ticket into: billing, technical, account, or other.", 
});

import { Agent } from "stratus-sdk/core";

const summarizer = new Agent({
  name: "summarizer",
  model,
  instructions: "Summarize the input in 2-3 sentences.",
  modelSettings: {
    maxTokens: 150, 
  },
});

const extractor = new Agent({
  name: "extractor",
  model,
  instructions: "Extract the person's name and email from the text.",
  outputType: z.object({
    name: z.string(),
    email: z.string().email(),
  }),
  modelSettings: {
    maxTokens: 100, // JSON output is always short
  },
});

// Good: model gets everything it needs in one call
const searchUsers = tool({
  name: "search_users",
  description: "Search users by name, returns full user records",
  parameters: z.object({ query: z.string() }),
  execute: async (ctx, { query }) => {
    const users = await ctx.db.users.search(query, { include: ["name", "email", "plan"] }); 
    return JSON.stringify(users);
  },
});

const agent = new Agent({
  name: "dashboard",
  model,
  tools: [getRevenue, getActiveUsers, getErrorRate],
  modelSettings: {
    parallelToolCalls: true, // default - tools run concurrently
  },
});

// "Show me today's metrics" → model calls all 3 tools in parallel
// One model call + one batch of tool executions instead of three sequential rounds

import { Agent, run, tool } from "stratus-sdk/core";
import { z } from "zod";

const fetchOrder = tool({
  name: "fetch_order",
  description: "Fetch an order by ID",
  parameters: z.object({ orderId: z.string() }),
  execute: async (ctx, { orderId }) => {
    const order = await ctx.db.orders.findById(orderId);
    return JSON.stringify(order);
  },
});

const orderFetcher = new Agent({
  name: "order_fetcher",
  model,
  instructions: "Fetch the order the user is asking about.",
  tools: [fetchOrder],
  toolUseBehavior: "stop_on_first_tool", 
});

const result = await run(orderFetcher, "Get order ORD-1234");
console.log(result.output); // Raw JSON from fetchOrder - no model summary

import { Agent } from "stratus-sdk/core";

const agent = new Agent({
  name: "support",
  model,
  instructions: longSystemPrompt, // 2000+ tokens of static instructions
  tools: [searchKnowledgeBase, createTicket, lookupAccount],
  modelSettings: {
    promptCacheKey: "support-agent-v1", 
  },
});

import { Agent, run, RunAbortedError } from "stratus-sdk/core";

const agent = new Agent({
  name: "researcher",
  model,
  tools: [searchDocs, queryDatabase],
});

try {
  const result = await run(agent, "Find all orders from last month", {
    signal: AbortSignal.timeout(10_000), // Hard 10-second deadline
  });
  console.log(result.output);
} catch (error) {
  if (error instanceof RunAbortedError) {
    console.log("Agent timed out - returning cached result");
    return getCachedResult(); // Fallback to cached data
  }
  throw error;
}

app.post("/chat", async (req, res) => {
  const ac = new AbortController();
  req.on("close", () => ac.abort());                       // Client disconnected
  const timeout = setTimeout(() => ac.abort(), 15_000);     // 15-second hard limit

  try {
    const { stream: s } = stream(agent, req.body.message, {
      signal: ac.signal,
    });
    // ... stream events to response
  } finally {
    clearTimeout(timeout);
  }
});

import { withTrace, run, Agent, tool } from "stratus-sdk/core";
import { z } from "zod";

const agent = new Agent({
  name: "researcher",
  model,
  tools: [searchDocs, queryDatabase],
});

const { result, trace } = await withTrace("research_query", async () => { 
  return run(agent, "What were last quarter's top-selling products?");
});

// Break down time by span type
const modelSpans = trace.spans.filter(s => s.type === "model_call"); 
const toolSpans = trace.spans.filter(s => s.type === "tool_execution"); 

const modelTime = modelSpans.reduce((sum, s) => sum + s.duration, 0);
const toolTime = toolSpans.reduce((sum, s) => sum + s.duration, 0);

console.log(`Total: ${trace.duration}ms`);
console.log(`Model calls: ${modelSpans.length} (${modelTime}ms)`); 
console.log(`Tool executions: ${toolSpans.length} (${toolTime}ms)`); 
console.log(`Overhead: ${trace.duration! - modelTime - toolTime}ms`);