agent-lattice 0.9.13 → 0.9.15

package/README.md

@@ -56,6 +56,28 @@ Pass `{ stream: false }` to disable model streaming for a query:
 const result = await agent.prompt("Say hello", { stream: false });
 ```
 
+Pass `outputFormat` when you want the model to produce JSON matching a schema:
+
+```ts
+const jsonResult = await agent.prompt("Return JSON only.", {
+  outputFormat: "json",
+});
+
+const result = await agent.prompt("Return the answer to 2 + 2.", {
+  outputFormat: {
+    type: "json_schema",
+    schema: {
+      type: "object",
+      properties: {
+        answer: { type: "number" },
+      },
+      required: ["answer"],
+      additionalProperties: false,
+    },
+  },
+});
+```
+
 ## Multimodal Input
 
 Pass Anthropic-compatible content blocks for image or document prompts:
@@ -227,6 +249,53 @@ const result = await agent.prompt("What is 2+2?");
 console.log(result.result);
 ```
 
+## Business Context For Tools
+
+Pass host application data through `context`. The SDK gives that context to
+tool handlers, but does not automatically put it into the model transcript. The
+model sees the data only if a tool returns it.
+
+```ts
+import { createBareAgent, tool } from "agent-lattice";
+import { z } from "zod/v4";
+
+type QcContext = {
+  patientRecordId: string;
+  scoringStandardId: string;
+};
+
+const readPatientRecordInput = z.object({});
+const qcTool = tool<QcContext>();
+
+const readPatientRecord = qcTool(
+  "read_patient_record",
+  "Read the current patient record",
+  readPatientRecordInput,
+  async (_input, { context }) => {
+    return {
+      content: JSON.stringify({
+        patientRecordId: context?.patientRecordId,
+        scoringStandardId: context?.scoringStandardId,
+      }),
+    };
+  },
+);
+
+const agent = createBareAgent<QcContext>({
+  apiKey: process.env.DEEPSEEK_API_KEY,
+  baseURL: "https://api.deepseek.com/anthropic",
+  model: "deepseek-v4-flash",
+  tools: [readPatientRecord],
+});
+
+const result = await agent.prompt("Review the current patient record.", {
+  context: {
+    patientRecordId: "ocr_123",
+    scoringStandardId: "tumor-treatment-process-v1",
+  },
+});
+```
+
 ## Permission Callback
 
 ```ts
@@ -361,7 +430,7 @@ const mcp = await connectMCPStreamableHTTPServer("https://mcp.example.com/mcp",
 `Agent` and `Team` satisfy the same `AgentLike` shape:
 
 ```ts
-type AgentLike = {
+type AgentLike<TContext = unknown> = {
   query(prompt, options?): AsyncGenerator<SDKMessage | TeamRunnerMessage>;
   prompt(prompt, options?): Promise<SDKResultMessage>;
 };

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import type { DocumentBlockParam, ImageBlockParam, TextBlockParam } from "@anthropic-ai/sdk/resources/messages.mjs";
+import type { BetaJSONOutputFormat } from "@anthropic-ai/sdk/resources/beta/messages/messages.mjs";
 import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
 import { type StdioServerParameters } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { type StreamableHTTPClientTransportOptions } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
@@ -21,9 +22,9 @@ export type ToolResultBlock = {
 };
 export type ContentBlock = TextBlock | ImageBlock | DocumentBlock | ToolUseBlock | ToolResultBlock;
 export type AgentLikeEvent = SDKMessage | TeamRunnerMessage;
-export type AgentLike = {
-    query(prompt: string | ContentBlock[], options?: QueryOptions): AsyncGenerator<AgentLikeEvent>;
-    prompt(prompt: string | ContentBlock[], options?: QueryOptions): Promise<SDKResultMessage>;
+export type AgentLike<TContext = unknown> = {
+    query(prompt: string | ContentBlock[], options?: QueryOptions<TContext>): AsyncGenerator<AgentLikeEvent>;
+    prompt(prompt: string | ContentBlock[], options?: QueryOptions<TContext>): Promise<SDKResultMessage>;
 };
 export type DelegateWaitMode = "result" | "accepted";
 export type AgentRuntimeSource = {
@@ -36,7 +37,7 @@ export type AgentRuntimeSource = {
 export type AgentRuntimeDelegateInput = {
     name: string;
     description?: string;
-    agent: AgentLike;
+    agent: AgentLike<any>;
     task: string;
     wait?: DelegateWaitMode;
     targetMailboxId?: string;
@@ -149,6 +150,7 @@ export type ModelRequest = {
     messages: ModelMessage[];
     tools: ModelToolDefinition[];
     stream: boolean;
+    outputFormat?: OutputFormat;
     onStreamEvent?: (event: Record<string, unknown>) => void;
     signal?: AbortSignal;
 };
@@ -158,19 +160,21 @@ export interface ModelClient {
 export type ToolResult = {
     content: string | ContentBlock[];
 };
-export type ToolHandler<TInput = unknown> = (input: TInput, context: {
+export type ToolExecutionContext<TContext = unknown> = {
     signal?: AbortSignal;
     toolUseId: string;
-    runtime?: AgentRuntimeContext;
+    context?: TContext;
+    agentRuntime?: AgentRuntimeContext;
     permissions?: RuntimePermissions;
-}) => Promise<ToolResult> | ToolResult;
-export type ToolDefinition<TInput = unknown> = {
+};
+export type ToolHandler<TInput = unknown, TContext = unknown> = (input: TInput, context: ToolExecutionContext<TContext>) => Promise<ToolResult> | ToolResult;
+export type ToolDefinition<TInput = unknown, TContext = unknown> = {
     name: string;
     description: string;
     inputSchema: unknown;
     jsonSchema: Record<string, unknown>;
     parse(input: unknown): TInput;
-    handler: ToolHandler<TInput>;
+    handler: ToolHandler<TInput, TContext>;
 };
 export type SkillDefinition = {
     name: string;
@@ -220,7 +224,7 @@ export type MCPStdioServerOptions = MCPToolsOptions & {
 };
 export type MCPStdioConnection = {
     client: MCPClient;
-    tools: Array<ToolDefinition<any>>;
+    tools: Array<ToolDefinition<any, any>>;
     close(): Promise<void>;
 };
 export type MCPStreamableHTTPServerOptions = MCPToolsOptions & {
@@ -242,7 +246,7 @@ export type TeamMemberDefinition = {
     name: string;
     role: TeamMemberRole;
     focus?: string;
-    agent: AgentLike;
+    agent: AgentLike<any>;
     mailboxId?: string;
 };
 export type TeamMemberInput = TeamMemberDefinition;
@@ -294,18 +298,18 @@ export type SQLiteMailboxOptions = {
 };
 export type TeamOptions = {
     name: string;
-    lead: Agent;
+    lead: Agent<any>;
     members: TeamMemberDefinition[];
     mailbox?: TeamMailbox;
     exposeLeadMailboxTools?: boolean;
 };
 export type Team = {
     name: string;
-    lead: Agent;
+    lead: Agent<any>;
     members: TeamMemberDefinition[];
     mailbox: TeamMailbox;
-    tools: Array<ToolDefinition<any>>;
-    memberTools: Record<string, Array<ToolDefinition<any>>>;
+    tools: Array<ToolDefinition<any, any>>;
+    memberTools: Record<string, Array<ToolDefinition<any, any>>>;
     send(from: string, to: string, content: string, options?: TeamSendOptions): Promise<TeamMessage>;
     drain(options?: TeamDrainOptions): Promise<TeamDrainResult>;
     query(prompt: string | ContentBlock[], options?: QueryOptions): AsyncGenerator<TeamRunnerMessage>;
@@ -323,13 +327,13 @@ export type TeamDrainResult = {
 };
 export type TeamRunnerOptions = {
     team?: Team;
-    root?: AgentLike;
+    root?: AgentLike<any>;
     mailbox?: TeamMailbox;
     source?: AgentRuntimeSource;
     maxDelegateDepth?: number;
 };
 export type TeamRunner = {
-    root: AgentLike;
+    root: AgentLike<any>;
     mailbox: TeamMailbox;
     query(prompt: string | ContentBlock[], options?: QueryOptions): AsyncGenerator<TeamRunnerMessage>;
     prompt(prompt: string | ContentBlock[], options?: QueryOptions): Promise<SDKResultMessage>;
@@ -350,7 +354,7 @@ export type AgentWorkspaceOptions = string | {
     allowedDirectories?: string[];
     bashTimeoutMs?: number;
 };
-export type AgentOptions = {
+export type AgentOptions<TContext = unknown> = {
     apiKey?: string;
     baseURL?: string;
     name?: string;
@@ -358,26 +362,29 @@ export type AgentOptions = {
     systemPrompt?: string;
     maxTokens?: number;
     maxTurns?: number;
-    tools?: Array<ToolDefinition<any>>;
+    tools?: Array<ToolDefinition<any, TContext>>;
     skills?: SkillDefinition[];
     workspace?: AgentWorkspaceOptions;
     permission?: (request: PermissionRequest) => Promise<PermissionDecision> | PermissionDecision;
     modelClient?: ModelClient;
     tracer?: ContextTracer;
 };
-export type BareAgentOptions = Omit<AgentOptions, "workspace">;
+export type BareAgentOptions<TContext = unknown> = Omit<AgentOptions<TContext>, "workspace">;
 export type AgentWorkspaceToolsOptions = {
     cwd?: string;
     allowedDirectories?: string[];
     bashTimeoutMs?: number;
 };
-export type QueryOptions = {
+export type QueryOptions<TContext = unknown> = {
     stream?: boolean;
+    outputFormat?: OutputFormat;
     signal?: AbortSignal;
-    runtime?: AgentRuntimeContext;
+    context?: TContext;
+    agentRuntime?: AgentRuntimeContext;
     permissions?: RuntimePermissions;
     tracer?: ContextTracer;
 };
+export type OutputFormat = "json" | BetaJSONOutputFormat;
 export type SDKSystemInitMessage = {
     type: "system";
     subtype: "init";
@@ -454,7 +461,8 @@ export declare class ToolPermissionDeniedError extends AgentSDKError {
     readonly denial: PermissionDenial;
     constructor(denial: PermissionDenial);
 }
-export declare function tool<TSchema>(name: string, description: string, inputSchema: TSchema, handler: ToolHandler<InferInput<TSchema>>): ToolDefinition<InferInput<TSchema>>;
+export declare function tool<TContext = unknown>(): <TSchema>(name: string, description: string, inputSchema: TSchema, handler: ToolHandler<InferInput<TSchema>, TContext>) => ToolDefinition<InferInput<TSchema>, TContext>;
+export declare function tool<TSchema, TContext = unknown>(name: string, description: string, inputSchema: TSchema, handler: ToolHandler<InferInput<TSchema>, TContext>): ToolDefinition<InferInput<TSchema>, TContext>;
 export type DelegateToolOptions = {
     wait?: DelegateWaitMode;
     targetMailboxId?: string;
@@ -484,13 +492,13 @@ export type AgentToolOptions = {
     description: string;
     targetMailboxId?: string;
 };
-export declare function agentTool(name: string, agent: AgentLike, options: AgentToolOptions): ToolDefinition<AgentToolInput>;
-export declare function delegateTool(name: string, description: string, agent: AgentLike, options?: DelegateToolOptions): ToolDefinition<{
+export declare function agentTool(name: string, agent: AgentLike<any>, options: AgentToolOptions): ToolDefinition<AgentToolInput>;
+export declare function delegateTool(name: string, description: string, agent: AgentLike<any>, options?: DelegateToolOptions): ToolDefinition<{
     task: string;
 }>;
-export declare function createAgent(options: AgentOptions): Agent;
-export declare function createBareAgent(options: BareAgentOptions): Agent;
-export declare function createBuiltinTools(options?: AgentWorkspaceToolsOptions): Array<ToolDefinition<any>>;
+export declare function createAgent<TContext = unknown>(options: AgentOptions<TContext>): Agent<TContext>;
+export declare function createBareAgent<TContext = unknown>(options: BareAgentOptions<TContext>): Agent<TContext>;
+export declare function createBuiltinTools(options?: AgentWorkspaceToolsOptions): Array<ToolDefinition<any, any>>;
 export declare function createJsonlContextTracer(options: JsonlContextTracerOptions): ContextTracer;
 export declare function createCompositeContextTracer(tracers: Array<ContextTracer | undefined | null>): ContextTracer;
 export declare function createLangSmithContextTracer(options: LangSmithContextTracerOptions): ContextTracer;
@@ -504,21 +512,23 @@ export declare function createMemoryMailbox(): TeamMailbox;
 export declare function createSQLiteMailbox(options: SQLiteMailboxOptions): TeamMailbox;
 export declare function createTeam(options: TeamOptions): Team;
 export declare function createTeamRunner(options: TeamRunnerOptions): TeamRunner;
-export declare function createAgentWorkspaceTools(options?: AgentWorkspaceToolsOptions): Array<ToolDefinition<any>>;
-export declare function query(params: AgentOptions & {
+export declare function createAgentWorkspaceTools(options?: AgentWorkspaceToolsOptions): Array<ToolDefinition<any, any>>;
+export declare function query<TContext = unknown>(params: AgentOptions<TContext> & {
     prompt: string;
     stream?: boolean;
+    outputFormat?: OutputFormat;
     signal?: AbortSignal;
+    context?: TContext;
 }): AsyncGenerator<SDKMessage>;
-export declare class Agent {
+export declare class Agent<TContext = unknown> {
     private readonly options;
     private readonly modelClient;
     private readonly messages;
     private readonly sessionId;
-    constructor(options: AgentOptions);
-    query(prompt: string | ContentBlock[], options?: QueryOptions): AsyncGenerator<SDKMessage>;
-    prompt(prompt: string | ContentBlock[], options?: QueryOptions): Promise<SDKResultMessage>;
-    addTools(tools: Array<ToolDefinition<any>>): void;
+    constructor(options: AgentOptions<TContext>);
+    query(prompt: string | ContentBlock[], options?: QueryOptions<TContext>): AsyncGenerator<SDKMessage>;
+    prompt(prompt: string | ContentBlock[], options?: QueryOptions<TContext>): Promise<SDKResultMessage>;
+    addTools(tools: Array<ToolDefinition<any, TContext>>): void;
     private initMessage;
     private resultMessage;
     private modelTools;