@townco/agent 0.1.52 → 0.1.54

package/dist/acp-server/adapter.d.ts

@@ -24,7 +24,23 @@ export declare class AgentAcpAdapter implements acp.Agent {
     private agentVersion;
     private agentDescription;
     private agentSuggestedPrompts;
+    private currentToolOverheadTokens;
+    private currentMcpOverheadTokens;
     constructor(agent: AgentRunner, connection: acp.AgentSideConnection, agentDir?: string, agentName?: string);
+    /**
+     * Extract tool metadata from the agent definition for exposing to clients.
+     * This provides basic info about available tools without loading them fully.
+     */
+    private getToolsMetadata;
+    /**
+     * Extract MCP metadata from the agent definition for exposing to clients.
+     */
+    private getMcpsMetadata;
+    /**
+     * Extract subagent metadata from the Task tool if present.
+     * This provides info about subagents configured via makeSubagentsTool.
+     */
+    private getSubagentsMetadata;
     /**
      * Helper to save session to disk
      * Call this after any modification to session.messages or session.context
@@ -36,10 +52,12 @@ export declare class AgentAcpAdapter implements acp.Agent {
     authenticate(_params: acp.AuthenticateRequest): Promise<acp.AuthenticateResponse | undefined>;
     setSessionMode(_params: acp.SetSessionModeRequest): Promise<acp.SetSessionModeResponse>;
     prompt(params: acp.PromptRequest): Promise<acp.PromptResponse>;
+    private _promptImpl;
     /**
      * Execute hooks if configured for this agent
      * Returns new context entries that should be appended to session.context
      */
     private executeHooksIfConfigured;
+    private _executeHooksImpl;
     cancel(params: acp.CancelNotification): Promise<void>;
 }

package/dist/acp-server/adapter.js

@@ -1,6 +1,8 @@
 import * as acp from "@agentclientprotocol/sdk";
+import { context, trace } from "@opentelemetry/api";
 import { createLogger } from "@townco/core";
 import { HookExecutor, loadHookCallback } from "../runner/hooks";
+import { telemetry } from "../telemetry/index.js";
 import { calculateContextSize, } from "../utils/context-size-calculator.js";
 import { countToolResultTokens } from "../utils/token-counter.js";
 import { SessionStorage, } from "./session-storage.js";
@@ -103,6 +105,8 @@ export class AgentAcpAdapter {
     agentVersion;
     agentDescription;
     agentSuggestedPrompts;
+    currentToolOverheadTokens = 0; // Track tool overhead for current turn
+    currentMcpOverheadTokens = 0; // Track MCP overhead for current turn
     constructor(agent, connection, agentDir, agentName) {
         this.connection = connection;
         this.sessions = new Map();
@@ -130,6 +134,82 @@ export class AgentAcpAdapter {
             sessionStoragePath: this.storage ? `${agentDir}/.sessions` : null,
         });
     }
+    /**
+     * Extract tool metadata from the agent definition for exposing to clients.
+     * This provides basic info about available tools without loading them fully.
+     */
+    getToolsMetadata() {
+        const tools = this.agent.definition.tools ?? [];
+        return tools.map((tool) => {
+            if (typeof tool === "string") {
+                // Built-in tool - return basic info
+                return { name: tool, description: `Built-in tool: ${tool}` };
+            }
+            else if (tool.type === "direct") {
+                return {
+                    name: tool.name,
+                    description: tool.description,
+                    ...(tool.prettyName ? { prettyName: tool.prettyName } : {}),
+                    ...(tool.icon ? { icon: tool.icon } : {}),
+                };
+            }
+            else if (tool.type === "filesystem") {
+                return {
+                    name: "filesystem",
+                    description: "File system access tools",
+                };
+            }
+            else if (tool.type === "custom") {
+                // Custom tools from module paths - extract name from path
+                const pathParts = tool.modulePath.split("/");
+                const fileName = pathParts[pathParts.length - 1] ?? "custom";
+                const name = fileName.replace(/\.(ts|js)$/, "");
+                return {
+                    name,
+                    description: `Custom tool from ${tool.modulePath}`,
+                };
+            }
+            return { name: "unknown", description: "Unknown tool type" };
+        });
+    }
+    /**
+     * Extract MCP metadata from the agent definition for exposing to clients.
+     */
+    getMcpsMetadata() {
+        const mcps = this.agent.definition.mcps ?? [];
+        return mcps.map((mcp) => {
+            if (typeof mcp === "string") {
+                return {
+                    name: mcp,
+                    transport: "http", // String configs are resolved to HTTP proxy
+                };
+            }
+            return {
+                name: mcp.name,
+                transport: mcp.transport,
+            };
+        });
+    }
+    /**
+     * Extract subagent metadata from the Task tool if present.
+     * This provides info about subagents configured via makeSubagentsTool.
+     */
+    getSubagentsMetadata() {
+        const tools = this.agent.definition.tools ?? [];
+        for (const tool of tools) {
+            // Look for direct tools with subagentConfigs (Task tools created by makeSubagentsTool)
+            if (typeof tool === "object" &&
+                tool.type === "direct" &&
+                "subagentConfigs" in tool &&
+                Array.isArray(tool.subagentConfigs)) {
+                return tool.subagentConfigs.map((config) => ({
+                    name: config.agentName,
+                    description: config.description,
+                }));
+            }
+        }
+        return [];
+    }
     /**
      * Helper to save session to disk
      * Call this after any modification to session.messages or session.context
@@ -166,19 +246,23 @@ export class AgentAcpAdapter {
                 ...(this.agentDisplayName ? { title: this.agentDisplayName } : {}),
             };
         }
-        // Pass description and suggestedPrompts via _meta extension point
-        // since Implementation doesn't support these fields
-        if (this.agentDescription || this.agentSuggestedPrompts) {
-            response._meta = {
-                ...response._meta,
-                ...(this.agentDescription
-                    ? { agentDescription: this.agentDescription }
-                    : {}),
-                ...(this.agentSuggestedPrompts
-                    ? { suggestedPrompts: this.agentSuggestedPrompts }
-                    : {}),
-            };
-        }
+        // Pass extended agent info via _meta extension point
+        // since ACP Implementation type doesn't support these fields directly
+        const toolsMetadata = this.getToolsMetadata();
+        const mcpsMetadata = this.getMcpsMetadata();
+        const subagentsMetadata = this.getSubagentsMetadata();
+        response._meta = {
+            ...response._meta,
+            ...(this.agentDescription
+                ? { agentDescription: this.agentDescription }
+                : {}),
+            ...(this.agentSuggestedPrompts
+                ? { suggestedPrompts: this.agentSuggestedPrompts }
+                : {}),
+            ...(toolsMetadata.length > 0 ? { tools: toolsMetadata } : {}),
+            ...(mcpsMetadata.length > 0 ? { mcps: mcpsMetadata } : {}),
+            ...(subagentsMetadata.length > 0 ? { subagents: subagentsMetadata } : {}),
+        };
         return response;
     }
     async newSession(params) {
@@ -234,6 +318,14 @@ export class AgentAcpAdapter {
                 }
                 else if (block.type === "tool_call") {
                     // Replay tool call directly in final state (skip pending → completed transitions)
+                    const replayMeta = {
+                        isReplay: true,
+                        ...(block.prettyName ? { prettyName: block.prettyName } : {}),
+                        ...(block.icon ? { icon: block.icon } : {}),
+                        ...(block.subline ? { subline: block.subline } : {}),
+                        ...(block.batchId ? { batchId: block.batchId } : {}),
+                        ...block._meta,
+                    };
                     this.connection.sessionUpdate({
                         sessionId: params.sessionId,
                         update: {
@@ -243,6 +335,7 @@ export class AgentAcpAdapter {
                             kind: block.kind,
                             status: block.status, // Use final status directly
                             rawInput: block.rawInput,
+                            _meta: replayMeta,
                         },
                     });
                     // If there's output, emit tool_output event for the UI to display
@@ -324,6 +417,22 @@ export class AgentAcpAdapter {
         return {};
     }
     async prompt(params) {
+        const promptSpan = telemetry.startSpan("adapter.prompt", {
+            "session.id": params.sessionId,
+        });
+        const spanContext = promptSpan
+            ? trace.setSpan(context.active(), promptSpan)
+            : context.active();
+        return context.with(spanContext, async () => {
+            try {
+                return await this._promptImpl(params);
+            }
+            finally {
+                telemetry.endSpan(promptSpan);
+            }
+        });
+    }
+    async _promptImpl(params) {
         let session = this.sessions.get(params.sessionId);
         // If session not found (e.g., after server restart), create a new one
         if (!session) {
@@ -338,9 +447,34 @@ export class AgentAcpAdapter {
         }
         session.pendingPrompt?.abort();
         session.pendingPrompt = new AbortController();
+        // Reset tool overhead for new turn (will be set by harness)
+        this.currentToolOverheadTokens = 0;
+        this.currentMcpOverheadTokens = 0;
         // Generate a unique messageId for this assistant response
         const messageId = Math.random().toString(36).substring(2);
-        // Extract and store the user message
+        // Convert prompt content blocks to session storage format
+        const userContentBlocks = params.prompt.map((block) => {
+            if (block.type === "text") {
+                return { type: "text", text: block.text };
+            }
+            else if (block.type === "image") {
+                // Preserve image block with all its data
+                const imgBlock = block;
+                const imageBlock = { type: "image" };
+                if (imgBlock.source)
+                    imageBlock.source = imgBlock.source;
+                if (imgBlock.url)
+                    imageBlock.url = imgBlock.url;
+                if (imgBlock.data)
+                    imageBlock.data = imgBlock.data;
+                if (imgBlock.mimeType)
+                    imageBlock.mimeType = imgBlock.mimeType;
+                return imageBlock;
+            }
+            // Fallback for unknown types - convert to text
+            return { type: "text", text: JSON.stringify(block) };
+        });
+        // Extract text for logging
         const userMessageText = params.prompt
             .filter((p) => p.type === "text")
             .map((p) => p.text)
@@ -354,7 +488,7 @@ export class AgentAcpAdapter {
         if (!this.noSession) {
             const userMessage = {
                 role: "user",
-                content: [{ type: "text", text: userMessageText }],
+                content: userContentBlocks,
                 timestamp: new Date().toISOString(),
             };
             session.messages.push(userMessage);
@@ -397,7 +531,9 @@ export class AgentAcpAdapter {
                 }
             }
             // Calculate context size - no LLM call yet, so only estimated values
-            const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, undefined);
+            const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, undefined, // No LLM-reported tokens yet
+            this.currentToolOverheadTokens, // Include tool overhead
+            this.currentMcpOverheadTokens);
             const contextSnapshot = createContextSnapshot(session.messages.length, new Date().toISOString(), previousContext, context_size);
             session.context.push(contextSnapshot);
             await this.saveSessionToDisk(params.sessionId, session);
@@ -461,6 +597,20 @@ export class AgentAcpAdapter {
             let iterResult = await generator.next();
             while (!iterResult.done) {
                 const msg = iterResult.value;
+                // Capture tool overhead info if provided by harness
+                if ("sessionUpdate" in msg &&
+                    msg.sessionUpdate === "tool_overhead_info") {
+                    const overheadInfo = msg;
+                    this.currentToolOverheadTokens = overheadInfo.toolOverheadTokens;
+                    this.currentMcpOverheadTokens = overheadInfo.mcpOverheadTokens;
+                    logger.debug("Received tool overhead info from harness", {
+                        toolOverheadTokens: this.currentToolOverheadTokens,
+                        mcpOverheadTokens: this.currentMcpOverheadTokens,
+                    });
+                    // Don't send this update to client, it's internal metadata
+                    iterResult = await generator.next();
+                    continue;
+                }
                 // Extract and accumulate token usage from message chunks
                 if ("sessionUpdate" in msg &&
                     msg.sessionUpdate === "agent_message_chunk" &&
@@ -516,10 +666,50 @@ export class AgentAcpAdapter {
                 if ("sessionUpdate" in msg && msg.sessionUpdate === "tool_call") {
                     flushPendingText();
                     const toolCallMsg = msg;
+                    // Extract prettyName, icon, and batchId from _meta
+                    const prettyName = toolCallMsg._meta &&
+                        typeof toolCallMsg._meta === "object" &&
+                        "prettyName" in toolCallMsg._meta
+                        ? String(toolCallMsg._meta.prettyName)
+                        : undefined;
+                    const icon = toolCallMsg._meta &&
+                        typeof toolCallMsg._meta === "object" &&
+                        "icon" in toolCallMsg._meta
+                        ? String(toolCallMsg._meta.icon)
+                        : undefined;
+                    const batchId = toolCallMsg._meta &&
+                        typeof toolCallMsg._meta === "object" &&
+                        "batchId" in toolCallMsg._meta
+                        ? String(toolCallMsg._meta.batchId)
+                        : undefined;
+                    // Extract subline from _meta, or compute it for todo_write from rawInput
+                    let subline = toolCallMsg._meta &&
+                        typeof toolCallMsg._meta === "object" &&
+                        "subline" in toolCallMsg._meta
+                        ? String(toolCallMsg._meta.subline)
+                        : undefined;
+                    // For todo_write, compute subline from in_progress item's activeForm
+                    if (!subline &&
+                        toolCallMsg.title === "todo_write" &&
+                        toolCallMsg.rawInput &&
+                        "todos" in toolCallMsg.rawInput &&
+                        Array.isArray(toolCallMsg.rawInput.todos)) {
+                        const inProgressItem = toolCallMsg.rawInput.todos.find((todo) => todo.status === "in_progress");
+                        if (inProgressItem &&
+                            typeof inProgressItem === "object" &&
+                            "activeForm" in inProgressItem &&
+                            typeof inProgressItem.activeForm === "string") {
+                            subline = inProgressItem.activeForm;
+                        }
+                    }
                     const toolCall = {
                         type: "tool_call",
                         id: toolCallMsg.toolCallId || `tool_${Date.now()}`,
+                        ...(batchId ? { batchId } : {}),
                         title: toolCallMsg.title || "Tool",
+                        ...(prettyName ? { prettyName } : {}),
+                        ...(icon ? { icon } : {}),
+                        ...(subline ? { subline } : {}),
                         kind: toolCallMsg.kind || "other",
                         status: toolCallMsg.status || "pending",
                         startedAt: Date.now(),
@@ -659,7 +849,9 @@ export class AgentAcpAdapter {
                                 }
                             }
                             // Calculate context size - tool result is now in the message, but hasn't been sent to LLM yet
-                            const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, undefined);
+                            const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, undefined, // Tool result hasn't been sent to LLM yet, so no new LLM-reported tokens
+                            this.currentToolOverheadTokens, // Include tool overhead
+                            this.currentMcpOverheadTokens);
                             // Create snapshot with a pointer to the partial message (not a full copy!)
                             const midTurnSnapshot = {
                                 timestamp: new Date().toISOString(),
@@ -691,8 +883,35 @@ export class AgentAcpAdapter {
                 }
                 // The agent may emit extended types (like tool_output) that aren't in ACP SDK yet
                 // The http transport will handle routing these appropriately
-                // Add context input tokens to messages with token usage metadata
+                // Enhance todo_write tool_call with subline showing in-progress item
                 let enhancedMsg = msg;
+                if ("sessionUpdate" in msg &&
+                    msg.sessionUpdate === "tool_call" &&
+                    "title" in msg &&
+                    msg.title === "todo_write" &&
+                    "rawInput" in msg &&
+                    msg.rawInput &&
+                    typeof msg.rawInput === "object" &&
+                    "todos" in msg.rawInput &&
+                    Array.isArray(msg.rawInput.todos)) {
+                    // Find the in_progress item and extract its activeForm
+                    const inProgressItem = msg.rawInput.todos.find((todo) => todo.status === "in_progress");
+                    if (inProgressItem &&
+                        typeof inProgressItem === "object" &&
+                        "activeForm" in inProgressItem &&
+                        typeof inProgressItem.activeForm === "string") {
+                        enhancedMsg = {
+                            ...msg,
+                            _meta: {
+                                ...(typeof msg._meta === "object" && msg._meta !== null
+                                    ? msg._meta
+                                    : {}),
+                                subline: inProgressItem.activeForm,
+                            },
+                        };
+                    }
+                }
+                // Add context input tokens to messages with token usage metadata
                 if (!this.noSession &&
                     "_meta" in msg &&
                     msg._meta &&
@@ -779,7 +998,9 @@ export class AgentAcpAdapter {
                 }
             }
             // Calculate context size with LLM-reported tokens from this turn
-            const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, turnTokenUsage.inputTokens);
+            const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, turnTokenUsage.inputTokens, // Final LLM-reported tokens from this turn
+            this.currentToolOverheadTokens, // Include tool overhead
+            this.currentMcpOverheadTokens);
             const contextSnapshot = createContextSnapshot(session.messages.length, new Date().toISOString(), previousContext, context_size);
             session.context.push(contextSnapshot);
             await this.saveSessionToDisk(params.sessionId, session);
@@ -799,6 +1020,24 @@ export class AgentAcpAdapter {
         if (this.noSession || !hooks || hooks.length === 0) {
             return [];
         }
+        const hookSpan = telemetry.startSpan("adapter.executeHooks", {
+            "hooks.executionPoint": executionPoint,
+            "hooks.count": hooks.length,
+            "session.id": sessionId,
+        });
+        const spanContext = hookSpan
+            ? trace.setSpan(context.active(), hookSpan)
+            : context.active();
+        return context.with(spanContext, async () => {
+            try {
+                return await this._executeHooksImpl(session, sessionId, executionPoint, hooks);
+            }
+            finally {
+                telemetry.endSpan(hookSpan);
+            }
+        });
+    }
+    async _executeHooksImpl(session, sessionId, executionPoint, hooks) {
         logger.info(`Executing hooks at ${executionPoint}`, {
             hooksLength: hooks.length,
             contextEntries: session.context.length,

package/dist/acp-server/http.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { gzipSync } from "node:zlib";
 import * as acp from "@agentclientprotocol/sdk";
 import { PGlite } from "@electric-sql/pglite";
@@ -264,6 +264,44 @@ export function makeHttpTransport(agent, agentDir, agentName) {
         allowMethods: ["GET", "POST", "OPTIONS"],
     }));
     app.get("/health", (c) => c.json({ ok: true }));
+    // Serve static files from agent directory (for generated images, etc.)
+    if (agentDir) {
+        app.get("/static/*", async (c) => {
+            const path = c.req.path.replace(/^\/static\//, "");
+            const filePath = join(agentDir, path);
+            // Security check: ensure the file is within the agent directory
+            const normalizedPath = resolve(filePath);
+            const normalizedAgentDir = resolve(agentDir);
+            if (!normalizedPath.startsWith(normalizedAgentDir)) {
+                logger.warn("Attempted to access file outside agent directory", {
+                    path,
+                    filePath,
+                    agentDir,
+                });
+                return c.json({ error: "Invalid path" }, 403);
+            }
+            try {
+                const file = Bun.file(filePath);
+                const exists = await file.exists();
+                if (!exists) {
+                    logger.warn("Static file not found", { path, filePath });
+                    return c.json({ error: "File not found" }, 404);
+                }
+                const buffer = await file.arrayBuffer();
+                const contentType = file.type || "application/octet-stream";
+                return new Response(buffer, {
+                    headers: {
+                        "Content-Type": contentType,
+                        "Cache-Control": "public, max-age=31536000",
+                    },
+                });
+            }
+            catch (error) {
+                logger.error("Error serving static file", { error, path, filePath });
+                return c.json({ error: "Internal server error" }, 500);
+            }
+        });
+    }
     app.get("/events", (c) => {
         const sessionId = c.req.header("X-Session-ID");
         if (!sessionId) {

package/dist/acp-server/session-storage.d.ts

@@ -5,10 +5,25 @@ export interface TextBlock {
     type: "text";
     text: string;
 }
+export interface ImageBlock {
+    type: "image";
+    source?: {
+        type: "base64";
+        media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        data: string;
+    } | undefined;
+    url?: string | undefined;
+    data?: string | undefined;
+    mimeType?: string | undefined;
+}
 export interface ToolCallBlock {
     type: "tool_call";
     id: string;
+    batchId?: string | undefined;
     title: string;
+    prettyName?: string | undefined;
+    icon?: string | undefined;
+    subline?: string | undefined;
     kind: "read" | "edit" | "delete" | "move" | "search" | "execute" | "think" | "fetch" | "switch_mode" | "other";
     status: "pending" | "in_progress" | "completed" | "failed";
     rawInput?: Record<string, unknown> | undefined;
@@ -23,7 +38,7 @@ export interface ToolCallBlock {
         finalTokens?: number;
     };
 }
-export type ContentBlock = TextBlock | ToolCallBlock;
+export type ContentBlock = TextBlock | ImageBlock | ToolCallBlock;
 /**
  * Session message format stored in files
  */
@@ -62,6 +77,8 @@ export interface ContextEntry {
      */
     context_size: {
         systemPromptTokens: number;
+        toolOverheadTokens?: number | undefined;
+        mcpOverheadTokens?: number | undefined;
         userMessagesTokens: number;
         assistantMessagesTokens: number;
         toolInputTokens: number;

package/dist/acp-server/session-storage.js

@@ -8,10 +8,32 @@ const textBlockSchema = z.object({
     type: z.literal("text"),
     text: z.string(),
 });
+const imageBlockSchema = z.object({
+    type: z.literal("image"),
+    source: z
+        .object({
+        type: z.literal("base64"),
+        media_type: z.enum([
+            "image/jpeg",
+            "image/png",
+            "image/gif",
+            "image/webp",
+        ]),
+        data: z.string(),
+    })
+        .optional(),
+    url: z.string().optional(),
+    data: z.string().optional(),
+    mimeType: z.string().optional(),
+});
 const toolCallBlockSchema = z.object({
     type: z.literal("tool_call"),
     id: z.string(),
+    batchId: z.string().optional(),
     title: z.string(),
+    prettyName: z.string().optional(),
+    icon: z.string().optional(),
+    subline: z.string().optional(),
     kind: z.enum([
         "read",
         "edit",
@@ -33,6 +55,7 @@ const toolCallBlockSchema = z.object({
 });
 const contentBlockSchema = z.discriminatedUnion("type", [
     textBlockSchema,
+    imageBlockSchema,
     toolCallBlockSchema,
 ]);
 const sessionMessageSchema = z.object({
@@ -58,6 +81,8 @@ const contextEntrySchema = z.object({
     compactedUpTo: z.number().optional(),
     context_size: z.object({
         systemPromptTokens: z.number(),
+        toolOverheadTokens: z.number().optional(),
+        mcpOverheadTokens: z.number().optional(),
         userMessagesTokens: z.number(),
         assistantMessagesTokens: z.number(),
         toolInputTokens: z.number(),

package/dist/definition/index.d.ts

@@ -11,7 +11,7 @@ export declare const McpConfigSchema: z.ZodUnion<readonly [z.ZodObject<{
     transport: z.ZodLiteral<"http">;
     url: z.ZodString;
     headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-}, z.core.$strip>]>;
+}, z.core.$strip>, z.ZodString]>;
 /** Hook configuration schema. */
 export declare const HookConfigSchema: z.ZodObject<{
     type: z.ZodEnum<{
@@ -59,7 +59,7 @@ export declare const AgentDefinitionSchema: z.ZodObject<{
         transport: z.ZodLiteral<"http">;
         url: z.ZodString;
         headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    }, z.core.$strip>]>>>;
+    }, z.core.$strip>, z.ZodString]>>>;
     harnessImplementation: z.ZodOptional<z.ZodLiteral<"langchain">>;
     hooks: z.ZodOptional<z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<{

package/dist/definition/index.js

@@ -23,6 +23,7 @@ const McpStreamableHttpConfigSchema = McpBaseConfigSchema.extend({
 export const McpConfigSchema = z.union([
     McpStdioConfigSchema,
     McpStreamableHttpConfigSchema,
+    z.string(),
 ]);
 /** Custom tool configuration schema. */
 const CustomToolSchema = z.object({

package/dist/runner/agent-runner.d.ts

@@ -8,7 +8,7 @@ export declare const zAgentRunnerParams: z.ZodObject<{
     suggestedPrompts: z.ZodOptional<z.ZodArray<z.ZodString>>;
     systemPrompt: z.ZodNullable<z.ZodString>;
     model: z.ZodString;
-    tools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">, z.ZodLiteral<"filesystem">]>, z.ZodObject<{
+    tools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">, z.ZodLiteral<"filesystem">, z.ZodLiteral<"generate_image">]>, z.ZodObject<{
         type: z.ZodLiteral<"custom">;
         modulePath: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
@@ -22,6 +22,11 @@ export declare const zAgentRunnerParams: z.ZodObject<{
         schema: z.ZodAny;
         prettyName: z.ZodOptional<z.ZodString>;
         icon: z.ZodOptional<z.ZodString>;
+        subagentConfigs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            agentName: z.ZodString;
+            description: z.ZodString;
+            displayName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>]>>>;
     mcps: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
         name: z.ZodString;
@@ -33,7 +38,7 @@ export declare const zAgentRunnerParams: z.ZodObject<{
         transport: z.ZodLiteral<"http">;
         url: z.ZodString;
         headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    }, z.core.$strip>]>>>;
+    }, z.core.$strip>, z.ZodString]>>>;
     hooks: z.ZodOptional<z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<{
             context_size: "context_size";
@@ -109,6 +114,10 @@ export type ExtendedSessionUpdate = (SessionNotification["update"] & {
         contextInputTokens?: number;
         [key: string]: unknown;
     };
+} | {
+    sessionUpdate: "tool_overhead_info";
+    toolOverheadTokens: number;
+    mcpOverheadTokens: number;
 } | AgentMessageChunkWithTokens | HookNotificationUpdate;
 /** Describes an object that can run an agent definition */
 export interface AgentRunner {

package/dist/runner/langchain/index.d.ts

@@ -10,7 +10,6 @@ type MakeLazy<T> = T extends LangchainTool ? () => T : never;
 export declare const TOOL_REGISTRY: Record<BuiltInToolType, LangchainTool | LazyLangchainTool | LazyLangchainTools>;
 export declare class LangchainAgent implements AgentRunner {
     definition: CreateAgentRunnerParams;
-    private toolSpans;
     constructor(params: CreateAgentRunnerParams);
     invoke(req: InvokeRequest): AsyncGenerator<ExtendedSessionUpdate, PromptResponse, undefined>;
 }