@townco/agent 0.1.48 → 0.1.50

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

@@ -26,5 +26,10 @@ 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>;
+    /**
+     * Execute hooks if configured for this agent
+     * Returns new context entries that should be appended to session.context
+     */
+    private executeHooksIfConfigured;
     cancel(params: acp.CancelNotification): Promise<void>;
 }

package/dist/acp-server/adapter.js

@@ -12,7 +12,7 @@ export const SUBAGENT_MODE_KEY = "town.com/isSubagent";
  * Create a context snapshot based on the previous context
  * Preserves full messages from previous context and adds new pointers
  */
-function createContextSnapshot(messageCount, timestamp, previousContext) {
+function createContextSnapshot(messageCount, timestamp, previousContext, inputTokens) {
     const messages = [];
     if (previousContext) {
         // Start with all messages from previous context
@@ -45,7 +45,12 @@ function createContextSnapshot(messageCount, timestamp, previousContext) {
             messages.push({ type: "pointer", index: i });
         }
     }
-    return { timestamp, messages };
+    return {
+        timestamp,
+        messages,
+        compactedUpTo: previousContext?.compactedUpTo,
+        inputTokens,
+    };
 }
 /**
  * Resolve context entries to session messages
@@ -260,7 +265,7 @@ export class AgentAcpAdapter {
             const previousContext = session.context.length > 0
                 ? session.context[session.context.length - 1]
                 : undefined;
-            const contextSnapshot = createContextSnapshot(session.messages.length, new Date().toISOString(), previousContext);
+            const contextSnapshot = createContextSnapshot(session.messages.length, new Date().toISOString(), previousContext, previousContext?.inputTokens ?? 0);
             session.context.push(contextSnapshot);
         }
         // Build ordered content blocks for the assistant response
@@ -273,48 +278,31 @@ export class AgentAcpAdapter {
                 pendingText = "";
             }
         };
+        // Declare agentResponse and turnTokenUsage outside try block so they're accessible after catch
+        let agentResponse;
+        // Track accumulated token usage during the turn
+        const turnTokenUsage = {
+            inputTokens: 0,
+            outputTokens: 0,
+            totalTokens: 0,
+        };
         try {
-            // Execute hooks before agent invocation
-            const hooks = this.agent.definition.hooks;
-            logger.info("Checking hooks", {
-                noSession: this.noSession,
-                hasHooks: !!hooks,
-                hooksLength: hooks?.length ?? 0,
-                contextEntries: session.context.length,
-                totalMessages: session.messages.length,
-            });
-            if (!this.noSession && hooks && hooks.length > 0) {
-                logger.info("Executing hooks before agent invocation");
-                const hookExecutor = new HookExecutor(hooks, this.agent.definition.model, (callbackRef) => loadHookCallback(callbackRef, this.agentDir));
-                // Create read-only session view for hooks
-                const readonlySession = {
-                    messages: session.messages,
-                    context: session.context,
-                    requestParams: session.requestParams,
-                };
-                const hookResult = await hookExecutor.executeHooks(readonlySession);
-                // Send hook notifications to client
-                for (const notification of hookResult.notifications) {
-                    this.connection.sessionUpdate({
-                        sessionId: params.sessionId,
-                        update: notification,
-                    });
-                }
-                // Append new context entries returned by hooks
-                if (hookResult.newContextEntries.length > 0) {
-                    logger.info(`Appending ${hookResult.newContextEntries.length} new context entries from hooks`);
-                    session.context.push(...hookResult.newContextEntries);
-                    // Save session immediately after hooks to persist compacted context
-                    if (this.storage) {
-                        try {
-                            await this.storage.saveSession(params.sessionId, session.messages, session.context);
-                            logger.info("Session saved after hook execution with new context entries");
-                        }
-                        catch (error) {
-                            logger.error(`Failed to save session ${params.sessionId} after hook execution`, {
-                                error: error instanceof Error ? error.message : String(error),
-                            });
-                        }
+            // Execute hooks before agent invocation (turn start)
+            const turnStartContextEntries = await this.executeHooksIfConfigured(session, params.sessionId, "turn_start");
+            // Append new context entries returned by hooks (e.g., compaction)
+            if (turnStartContextEntries.length > 0) {
+                logger.info(`Appending ${turnStartContextEntries.length} new context entries from turn_start hooks`);
+                session.context.push(...turnStartContextEntries);
+                // Save session immediately after hooks to persist compacted context
+                if (this.storage) {
+                    try {
+                        await this.storage.saveSession(params.sessionId, session.messages, session.context);
+                        logger.info("Session saved after turn_start hook execution with new context entries");
+                    }
+                    catch (error) {
+                        logger.error(`Failed to save session ${params.sessionId} after turn_start hook execution`, {
+                            error: error instanceof Error ? error.message : String(error),
+                        });
                     }
                 }
             }
@@ -333,7 +321,30 @@ export class AgentAcpAdapter {
             if (session.requestParams._meta) {
                 invokeParams.sessionMeta = session.requestParams._meta;
             }
-            for await (const msg of this.agent.invoke(invokeParams)) {
+            const generator = this.agent.invoke(invokeParams);
+            // Manually iterate to capture the return value
+            let iterResult = await generator.next();
+            while (!iterResult.done) {
+                const msg = iterResult.value;
+                // Extract and accumulate token usage from message chunks
+                if ("sessionUpdate" in msg &&
+                    msg.sessionUpdate === "agent_message_chunk" &&
+                    "_meta" in msg &&
+                    msg._meta &&
+                    typeof msg._meta === "object" &&
+                    "tokenUsage" in msg._meta) {
+                    const tokenUsage = msg._meta.tokenUsage;
+                    if (tokenUsage) {
+                        // Only update inputTokens if we receive a positive value
+                        // (subsequent messages may have inputTokens: 0 for output-only chunks)
+                        if (tokenUsage.inputTokens !== undefined &&
+                            tokenUsage.inputTokens > 0) {
+                            turnTokenUsage.inputTokens = tokenUsage.inputTokens;
+                        }
+                        turnTokenUsage.outputTokens += tokenUsage.outputTokens ?? 0;
+                        turnTokenUsage.totalTokens += tokenUsage.totalTokens ?? 0;
+                    }
+                }
                 // Accumulate text content from message chunks
                 if ("sessionUpdate" in msg &&
                     msg.sessionUpdate === "agent_message_chunk") {
@@ -407,15 +418,125 @@ export class AgentAcpAdapter {
                         }
                         // Note: content blocks are handled by the transport for display
                         // We store the raw output here for session persistence
+                        // Create mid-turn context snapshot after tool completes
+                        if (!this.noSession) {
+                            flushPendingText(); // Ensure all text is captured
+                            // Update or create the partial assistant message in the messages array
+                            const partialAssistantMessage = {
+                                role: "assistant",
+                                content: [...contentBlocks], // Clone current content blocks
+                                timestamp: new Date().toISOString(),
+                            };
+                            // Check if we already have a partial assistant message in messages
+                            const lastMessage = session.messages[session.messages.length - 1];
+                            let partialMessageIndex;
+                            if (lastMessage && lastMessage.role === "assistant") {
+                                // Update existing partial message
+                                session.messages[session.messages.length - 1] =
+                                    partialAssistantMessage;
+                                partialMessageIndex = session.messages.length - 1;
+                            }
+                            else {
+                                // Add new partial message
+                                session.messages.push(partialAssistantMessage);
+                                partialMessageIndex = session.messages.length - 1;
+                            }
+                            // Get the latest context
+                            const latestContext = session.context.length > 0
+                                ? session.context[session.context.length - 1]
+                                : undefined;
+                            // Create snapshot with a pointer to the partial message (not a full copy!)
+                            const midTurnSnapshot = {
+                                timestamp: new Date().toISOString(),
+                                messages: [
+                                    ...(latestContext?.messages ?? []),
+                                    { type: "pointer", index: partialMessageIndex },
+                                ],
+                                compactedUpTo: latestContext?.compactedUpTo,
+                                inputTokens: turnTokenUsage.inputTokens || latestContext?.inputTokens || 0,
+                            };
+                            session.context.push(midTurnSnapshot);
+                            logger.debug("Created mid-turn context snapshot after tool output", {
+                                toolCallId: outputMsg.toolCallId,
+                                contentBlocks: contentBlocks.length,
+                                partialMessageIndex,
+                                inputTokens: midTurnSnapshot.inputTokens,
+                            });
+                            // Execute hooks mid-turn to check if compaction is needed
+                            const midTurnContextEntries = await this.executeHooksIfConfigured(session, params.sessionId, "mid_turn");
+                            // Append new context entries returned by hooks (e.g., compaction)
+                            if (midTurnContextEntries.length > 0) {
+                                logger.info(`Appending ${midTurnContextEntries.length} new context entries from mid_turn hooks`, {
+                                    toolCallId: outputMsg.toolCallId,
+                                });
+                                session.context.push(...midTurnContextEntries);
+                                // Save session immediately after mid-turn compaction
+                                if (this.storage) {
+                                    try {
+                                        await this.storage.saveSession(params.sessionId, session.messages, session.context);
+                                        logger.info("Session saved after mid_turn hook execution with new context entries", {
+                                            toolCallId: outputMsg.toolCallId,
+                                        });
+                                    }
+                                    catch (error) {
+                                        logger.error(`Failed to save session ${params.sessionId} after mid_turn hook execution`, {
+                                            toolCallId: outputMsg.toolCallId,
+                                            error: error instanceof Error
+                                                ? error.message
+                                                : String(error),
+                                        });
+                                    }
+                                }
+                            }
+                        }
                     }
                 }
                 // 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
+                let enhancedMsg = msg;
+                if (!this.noSession &&
+                    "_meta" in msg &&
+                    msg._meta &&
+                    typeof msg._meta === "object" &&
+                    "tokenUsage" in msg._meta) {
+                    // Use accumulated turn tokens if available, otherwise fall back to previous context
+                    let contextInputTokens;
+                    if (turnTokenUsage.inputTokens > 0) {
+                        // Use current turn's accumulated tokens (most up-to-date)
+                        contextInputTokens = turnTokenUsage.inputTokens;
+                    }
+                    else {
+                        // Fall back to previous context's tokens (for start of turn)
+                        const latestContext = session.context.length > 0
+                            ? session.context[session.context.length - 1]
+                            : undefined;
+                        contextInputTokens = latestContext?.inputTokens;
+                    }
+                    // Add context tokens to _meta only if defined
+                    if (contextInputTokens !== undefined) {
+                        enhancedMsg = {
+                            ...msg,
+                            _meta: {
+                                ...msg._meta,
+                                contextInputTokens,
+                            },
+                        };
+                        logger.debug("Sending contextInputTokens to GUI", {
+                            contextInputTokens,
+                            turnTokens: turnTokenUsage.inputTokens,
+                            previousContextTokens: session.context[session.context.length - 1]?.inputTokens,
+                        });
+                    }
+                }
                 this.connection.sessionUpdate({
                     sessionId: params.sessionId,
-                    update: msg,
+                    update: enhancedMsg,
                 });
+                iterResult = await generator.next();
             }
+            // Capture the return value (PromptResponse with tokenUsage)
+            agentResponse = iterResult.value;
             // Flush any remaining pending text
             flushPendingText();
         }
@@ -433,12 +554,24 @@ export class AgentAcpAdapter {
                 content: contentBlocks,
                 timestamp: new Date().toISOString(),
             };
-            session.messages.push(assistantMessage);
+            // Check if we already have a partial assistant message from mid-turn updates
+            const lastMessage = session.messages[session.messages.length - 1];
+            if (lastMessage && lastMessage.role === "assistant") {
+                // Update the existing message instead of adding a duplicate
+                session.messages[session.messages.length - 1] = assistantMessage;
+            }
+            else {
+                // Add new message (no mid-turn updates occurred)
+                session.messages.push(assistantMessage);
+            }
             // Create context snapshot based on previous context
             const previousContext = session.context.length > 0
                 ? session.context[session.context.length - 1]
                 : undefined;
-            const contextSnapshot = createContextSnapshot(session.messages.length, new Date().toISOString(), previousContext);
+            const contextSnapshot = createContextSnapshot(session.messages.length, new Date().toISOString(), previousContext, 
+            // Use accumulated turn tokens (latest API call's input tokens)
+            // not agentResponse.tokenUsage which may sum all calls in the turn
+            turnTokenUsage.inputTokens || previousContext?.inputTokens || 0);
             session.context.push(contextSnapshot);
         }
         // Save session to disk if storage is configured and session persistence is enabled
@@ -457,6 +590,44 @@ export class AgentAcpAdapter {
             stopReason: "end_turn",
         };
     }
+    /**
+     * Execute hooks if configured for this agent
+     * Returns new context entries that should be appended to session.context
+     */
+    async executeHooksIfConfigured(session, sessionId, executionPoint) {
+        // Check if hooks are configured and session persistence is enabled
+        const hooks = this.agent.definition.hooks;
+        if (this.noSession || !hooks || hooks.length === 0) {
+            return [];
+        }
+        logger.info(`Executing hooks at ${executionPoint}`, {
+            hooksLength: hooks.length,
+            contextEntries: session.context.length,
+            totalMessages: session.messages.length,
+        });
+        const hookExecutor = new HookExecutor(hooks, this.agent.definition.model, (callbackRef) => loadHookCallback(callbackRef, this.agentDir));
+        // Create read-only session view for hooks
+        const readonlySession = {
+            messages: session.messages,
+            context: session.context,
+            requestParams: session.requestParams,
+        };
+        // Get actual input token count from latest context entry
+        const latestContext = session.context.length > 0
+            ? session.context[session.context.length - 1]
+            : undefined;
+        const actualInputTokens = latestContext?.inputTokens ?? 0;
+        const hookResult = await hookExecutor.executeHooks(readonlySession, actualInputTokens);
+        // Send hook notifications to client
+        for (const notification of hookResult.notifications) {
+            this.connection.sessionUpdate({
+                sessionId,
+                update: notification,
+            });
+        }
+        // Return new context entries (will be appended by caller)
+        return hookResult.newContextEntries;
+    }
     async cancel(params) {
         this.sessions.get(params.sessionId)?.pendingPrompt?.abort();
     }

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

@@ -50,6 +50,11 @@ export interface ContextEntry {
      * compacted into the full message(s) in this entry
      */
     compactedUpTo?: number | undefined;
+    /**
+     * Actual input token count from API for this context.
+     * Used for accurate context size tracking and compaction decisions.
+     */
+    inputTokens?: number | undefined;
 }
 /**
  * Session metadata

package/dist/index.d.ts

@@ -1 +1,2 @@
-export {};
+export { configureTelemetry, type TelemetryConfig } from "./telemetry/index.js";
+export { initializeOpenTelemetry, initializeOpenTelemetryFromEnv, type TelemetrySetupOptions, } from "./telemetry/setup.js";

package/dist/index.js

@@ -1,7 +1,16 @@
 import { basename } from "node:path";
 import { createLogger } from "@townco/core";
 import { makeHttpTransport, makeStdioTransport } from "./acp-server";
+import { initializeOpenTelemetryFromEnv } from "./telemetry/setup.js";
 import { makeSubagentsTool } from "./utils";
+// Re-export telemetry configuration for library users
+export { configureTelemetry } from "./telemetry/index.js";
+export { initializeOpenTelemetry, initializeOpenTelemetryFromEnv, } from "./telemetry/setup.js";
+// Configure OpenTelemetry if enabled via environment variable
+// Example: ENABLE_TELEMETRY=true bun run index.ts stdio
+if (process.env.ENABLE_TELEMETRY === "true") {
+    initializeOpenTelemetryFromEnv();
+}
 const logger = createLogger("agent-index");
 const exampleAgent = {
     model: "claude-sonnet-4-5-20250929",

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

@@ -64,6 +64,7 @@ export interface AgentMessageChunkWithTokens {
     };
     _meta?: {
         tokenUsage?: TokenUsage;
+        contextInputTokens?: number;
         [key: string]: unknown;
     };
 }
@@ -97,6 +98,8 @@ export type ExtendedSessionUpdate = (SessionNotification["update"] & {
     rawOutput?: Record<string, unknown>;
     _meta?: {
         messageId?: string;
+        contextInputTokens?: number;
+        [key: string]: unknown;
     };
 } | AgentMessageChunkWithTokens | HookNotificationUpdate;
 /** Describes an object that can run an agent definition */

package/dist/runner/hooks/executor.d.ts

@@ -12,7 +12,7 @@ export declare class HookExecutor {
      * Execute hooks before agent invocation
      * Returns new context entries to append and any notifications to send
      */
-    executeHooks(session: ReadonlySession): Promise<{
+    executeHooks(session: ReadonlySession, actualInputTokens: number): Promise<{
         newContextEntries: ContextEntry[];
         notifications: HookNotification[];
     }>;

package/dist/runner/hooks/executor.js

@@ -7,58 +7,6 @@ const logger = createLogger("hook-executor");
 function getModelMaxTokens(model) {
     return MODEL_CONTEXT_WINDOWS[model] ?? DEFAULT_CONTEXT_SIZE;
 }
-/**
- * Estimate token count for session messages
- * This is a rough estimate: ~4 characters per token
- */
-function estimateTokens(messages) {
-    let totalChars = 0;
-    for (const message of messages) {
-        // Count characters in content blocks
-        for (const block of message.content) {
-            if (block.type === "text") {
-                totalChars += block.text.length;
-            }
-            else if (block.type === "tool_call") {
-                // Estimate tool call size (title + inputs/outputs)
-                totalChars += block.title.length;
-                if (block.rawInput) {
-                    totalChars += JSON.stringify(block.rawInput).length;
-                }
-                if (block.rawOutput) {
-                    totalChars += JSON.stringify(block.rawOutput).length;
-                }
-            }
-        }
-    }
-    // Rough estimate: 4 characters per token
-    return Math.ceil(totalChars / 4);
-}
-/**
- * Resolve context entries to session messages
- */
-function resolveContextToMessages(context, allMessages) {
-    if (context.length === 0) {
-        return [];
-    }
-    const latestContext = context[context.length - 1];
-    if (!latestContext) {
-        return [];
-    }
-    const resolved = [];
-    for (const entry of latestContext.messages) {
-        if (entry.type === "pointer") {
-            const message = allMessages[entry.index];
-            if (message) {
-                resolved.push(message);
-            }
-        }
-        else if (entry.type === "full") {
-            resolved.push(entry.message);
-        }
-    }
-    return resolved;
-}
 /**
  * Hook executor manages hook lifecycle
  */
@@ -75,17 +23,18 @@ export class HookExecutor {
      * Execute hooks before agent invocation
      * Returns new context entries to append and any notifications to send
      */
-    async executeHooks(session) {
+    async executeHooks(session, actualInputTokens) {
         logger.info(`Executing hooks - found ${this.hooks.length} hook(s)`, {
             hooks: this.hooks.map((h) => h.type),
             contextEntries: session.context.length,
             totalMessages: session.messages.length,
+            actualInputTokens,
         });
         const newContextEntries = [];
         const notifications = [];
         for (const hook of this.hooks) {
             if (hook.type === "context_size") {
-                const result = await this.executeContextSizeHook(hook, session);
+                const result = await this.executeContextSizeHook(hook, session, actualInputTokens);
                 if (result) {
                     notifications.push(...result.notifications);
                     if (result.newContextEntry) {
@@ -99,20 +48,17 @@ export class HookExecutor {
     /**
      * Execute a context_size hook
      */
-    async executeContextSizeHook(hook, session) {
-        // Resolve context to messages for token estimation
-        const resolvedMessages = resolveContextToMessages(session.context, session.messages);
+    async executeContextSizeHook(hook, session, actualInputTokens) {
         const maxTokens = getModelMaxTokens(this.model);
-        const currentTokens = estimateTokens(resolvedMessages);
-        const percentage = (currentTokens / maxTokens) * 100;
+        const percentage = (actualInputTokens / maxTokens) * 100;
         // Default threshold is 95%
         const threshold = hook.setting?.threshold ?? 95;
         // Check if threshold exceeded
         if (percentage < threshold) {
-            logger.info(`Context hook not triggered: ${currentTokens} tokens (${percentage.toFixed(1)}%) < threshold ${threshold}%`);
+            logger.info(`Context hook not triggered: ${actualInputTokens} tokens (${percentage.toFixed(1)}%) < threshold ${threshold}%`);
             return null; // No action needed
         }
-        logger.info(`Context hook triggered: ${currentTokens} tokens (${percentage.toFixed(1)}%) exceeds threshold ${threshold}%`);
+        logger.info(`Context hook triggered: ${actualInputTokens} tokens (${percentage.toFixed(1)}%) exceeds threshold ${threshold}%`);
         const notifications = [];
         // Notify that hook is triggered
         notifications.push({
@@ -127,7 +73,7 @@ export class HookExecutor {
             const callback = await this.loadCallback(hook.callback);
             const hookContext = {
                 session,
-                currentTokens,
+                currentTokens: actualInputTokens,
                 maxTokens,
                 percentage,
                 model: this.model,

package/dist/runner/hooks/predefined/compaction-tool.js

@@ -78,26 +78,36 @@ Please provide your summary based on the conversation above, following this stru
             ? response.content
             : Array.isArray(response.content)
                 ? response.content
-                    .filter((block) => typeof block === "object" && block !== null && "text" in block)
+                    .filter((block) => typeof block === "object" &&
+                    block !== null &&
+                    "text" in block)
                     .map((block) => block.text)
                     .join("\n")
                 : "Failed to extract summary";
+        // Extract token usage from LLM response
+        const responseUsage = response.usage_metadata;
+        const summaryTokens = responseUsage?.output_tokens ?? 0;
+        const inputTokensUsed = responseUsage?.input_tokens ?? ctx.currentTokens;
         logger.info("Generated compaction summary", {
             originalMessages: messagesToCompact.length,
             summaryLength: summaryText.length,
-            estimatedTokensSaved: Math.round(ctx.currentTokens * 0.7),
+            inputTokens: inputTokensUsed,
+            summaryTokens,
+            tokensSaved: inputTokensUsed - summaryTokens,
         });
         // Create a new context entry with the summary
         const summaryEntry = createFullMessageEntry("user", `This session is being continued from a previous conversation that ran out of context. The conversation is summarized below:\n${summaryText}`);
         // Set compactedUpTo to indicate all messages have been compacted into the summary
         const lastMessageIndex = messagesToCompact.length - 1;
-        const newContextEntry = createContextEntry([summaryEntry], undefined, lastMessageIndex);
+        const newContextEntry = createContextEntry([summaryEntry], undefined, lastMessageIndex, summaryTokens);
         return {
             newContextEntry,
             metadata: {
                 action: "compacted",
                 messagesRemoved: messagesToCompact.length - 1,
-                tokensSaved: Math.round(ctx.currentTokens * 0.7),
+                tokensBeforeCompaction: inputTokensUsed,
+                tokensSaved: inputTokensUsed - summaryTokens,
+                summaryTokens, // Token count of the summary itself
                 summaryGenerated: true,
             },
         };

package/dist/runner/hooks/types.d.ts

@@ -106,7 +106,7 @@ export declare function createContextEntry(messages: Array<{
 } | {
     type: "full";
     message: SessionMessage;
-}>, timestamp?: string, compactedUpTo?: number): ContextEntry;
+}>, timestamp?: string, compactedUpTo?: number, inputTokens?: number): ContextEntry;
 /**
  * Helper function to create a full message entry for context
  * Use this when hooks need to inject new messages into context

package/dist/runner/hooks/types.js

@@ -2,7 +2,7 @@
  * Helper function to create a new context entry
  * Use this when hooks want to create a new context snapshot
  */
-export function createContextEntry(messages, timestamp, compactedUpTo) {
+export function createContextEntry(messages, timestamp, compactedUpTo, inputTokens) {
     const entry = {
         timestamp: timestamp || new Date().toISOString(),
         messages,
@@ -10,6 +10,9 @@ export function createContextEntry(messages, timestamp, compactedUpTo) {
     if (compactedUpTo !== undefined) {
         entry.compactedUpTo = compactedUpTo;
     }
+    if (inputTokens !== undefined) {
+        entry.inputTokens = inputTokens;
+    }
     return entry;
 }
 /**

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

@@ -10,6 +10,7 @@ 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>;
 }