@townco/agent 0.1.72 → 0.1.74

package/dist/runner/langchain/index.js

@@ -1,6 +1,6 @@
 import { MultiServerMCPClient } from "@langchain/mcp-adapters";
 import { context, propagation, trace } from "@opentelemetry/api";
-import { loadAuthCredentials } from "@townco/core/auth";
+import { getShedAuth } from "@townco/core/auth";
 import { AIMessageChunk, createAgent, ToolMessage, tool, } from "langchain";
 import { z } from "zod";
 import { SUBAGENT_MODE_KEY } from "../../acp-server/adapter";
@@ -15,7 +15,7 @@ import { makeGenerateImageTool } from "./tools/generate_image";
 import { SUBAGENT_TOOL_NAME } from "./tools/subagent";
 import { hashQuery, queryToToolCallId, subagentEvents, } from "./tools/subagent-connections";
 import { TODO_WRITE_TOOL_NAME, todoWrite } from "./tools/todo";
-import { makeWebSearchTools } from "./tools/web_search";
+import { makeTownWebSearchTools, makeWebSearchTools } from "./tools/web_search";
 const _logger = createLogger("agent-runner");
 const getWeather = tool(({ city }) => `It's always sunny in ${city}!`, {
     name: "get_weather",
@@ -30,6 +30,7 @@ export const TOOL_REGISTRY = {
     todo_write: todoWrite,
     get_weather: getWeather,
     web_search: () => makeWebSearchTools(),
+    town_web_search: () => makeTownWebSearchTools(),
     filesystem: () => makeFilesystemTools(process.cwd()),
     generate_image: () => makeGenerateImageTool(),
     browser: () => makeBrowserTools(),
@@ -96,12 +97,9 @@ export class LangchainAgent {
             // Clear the buffer after flushing
             pendingToolCallNotifications.length = 0;
         }
-        // Set session_id as a base attribute so all spans in this invocation include it
-        telemetry.setBaseAttributes({
-            "agent.session_id": req.sessionId,
-        });
         const subagentUpdateQueue = [];
         let subagentUpdateResolver = null;
+        const subagentMessagesQueue = [];
         // Listen for subagent connection events - resolve any waiting promise immediately
         const onSubagentConnection = (event) => {
             _logger.info("Received subagent connection event", {
@@ -121,6 +119,15 @@ export class LangchainAgent {
             }
         };
         subagentEvents.on("connection", onSubagentConnection);
+        // Listen for subagent messages events (for session storage)
+        const onSubagentMessages = (event) => {
+            _logger.info("Received subagent messages event", {
+                toolCallId: event.toolCallId,
+                messageCount: event.messages.length,
+            });
+            subagentMessagesQueue.push(event);
+        };
+        subagentEvents.on("messages", onSubagentMessages);
         // Helper to get next subagent update (returns immediately if queued, otherwise waits)
         const waitForSubagentUpdate = () => {
             if (subagentUpdateQueue.length > 0) {
@@ -149,12 +156,34 @@ export class LangchainAgent {
                     },
                 };
             }
+            // Also yield any pending messages updates
+            while (subagentMessagesQueue.length > 0) {
+                const messagesUpdate = subagentMessagesQueue.shift();
+                _logger.info("Yielding queued subagent messages update", {
+                    toolCallId: messagesUpdate.toolCallId,
+                    messageCount: messagesUpdate.messages.length,
+                });
+                yield {
+                    sessionUpdate: "tool_call_update",
+                    toolCallId: messagesUpdate.toolCallId,
+                    _meta: {
+                        messageId: req.messageId,
+                        subagentMessages: messagesUpdate.messages,
+                    },
+                };
+            }
         }
+        // Add agent.session_id as a base attribute so it propagates to all child spans
+        // We'll clear this in a finally block to prevent cross-contamination
+        telemetry.setBaseAttributes({
+            "agent.session_id": req.sessionId,
+        });
         // Start telemetry span for entire invocation
         const invocationSpan = telemetry.startSpan("agent.invoke", {
             "agent.model": this.definition.model,
             "agent.subagent": meta?.[SUBAGENT_MODE_KEY] === true,
             "agent.message_id": req.messageId,
+            "agent.session_id": req.sessionId,
         }, parentContext);
         // Create a context with the invocation span as active
         // This will be used when creating child spans (tool calls)
@@ -166,7 +195,29 @@ export class LangchainAgent {
             sessionId: req.sessionId,
             messageId: req.messageId,
         });
+        // Yield the invocation span to the adapter so it can use it for parenting hook spans
+        if (invocationSpan) {
+            yield {
+                sessionUpdate: "__invocation_span",
+                invocationSpan,
+            };
+        }
+        // Declare otelCallbacks outside try block so it's accessible in catch
+        let otelCallbacks = null;
         try {
+            // Determine effective model early so we can detect provider for callbacks
+            // Use override model if provided (Town Hall comparison feature)
+            const effectiveModel = req.configOverrides?.model ?? this.definition.model;
+            const provider = detectProvider(effectiveModel);
+            // Create OTEL callbacks for instrumentation early so we can use them during tool wrapping
+            // Track iteration index across LLM calls in this invocation
+            const iterationIndexRef = { current: 0 };
+            otelCallbacks = makeOtelCallbacks({
+                provider,
+                model: effectiveModel,
+                parentContext: invocationContext,
+                iterationIndexRef,
+            });
             // Track todo_write tool call IDs to suppress their tool_call notifications
             const todoWriteToolCallIds = new Set();
             // --------------------------------------------------------------------------
@@ -365,19 +416,34 @@ export class LangchainAgent {
                 : wrappedTools;
             // Wrap tools with tracing so each tool executes within its own span context.
             // This ensures subagent spans are children of the Task tool span.
-            const finalTools = filteredTools.map((t) => wrapToolWithTracing(t));
+            // Pass the context getter so tools can nest under the current iteration span.
+            let finalTools = filteredTools.map((t) => wrapToolWithTracing(t, otelCallbacks?.getCurrentIterationContext ??
+                (() => invocationContext)));
+            // Apply tool overrides if provided (Town Hall comparison feature)
+            if (req.configOverrides?.tools && req.configOverrides.tools.length > 0) {
+                const allowedToolNames = new Set(req.configOverrides.tools);
+                finalTools = finalTools.filter((t) => allowedToolNames.has(t.name));
+                _logger.debug("Applied tool override filter", {
+                    requested: req.configOverrides.tools,
+                    filtered: finalTools.map((t) => t.name),
+                });
+            }
             // Create the model instance using the factory
             // This detects the provider from the model string:
             // - "gemini-2.0-flash" → Google Generative AI
             // - "vertex-gemini-2.0-flash" → Vertex AI (strips prefix)
             // - "claude-sonnet-4-5-20250929" → Anthropic
-            const model = createModelFromString(this.definition.model);
+            const model = createModelFromString(effectiveModel);
             const agentConfig = {
                 model,
                 tools: finalTools,
             };
-            if (this.definition.systemPrompt) {
-                agentConfig.systemPrompt = this.definition.systemPrompt;
+            // Use override system prompt if provided (Town Hall comparison feature)
+            const effectiveSystemPrompt = req.configOverrides?.systemPrompt !== undefined
+                ? req.configOverrides.systemPrompt
+                : this.definition.systemPrompt;
+            if (effectiveSystemPrompt) {
+                agentConfig.systemPrompt = effectiveSystemPrompt;
             }
             // Inject system prompt with optional TodoWrite instructions
             const hasTodoWrite = builtInNames.includes("todo_write");
@@ -385,8 +451,6 @@ export class LangchainAgent {
                 agentConfig.systemPrompt = `${agentConfig.systemPrompt ?? ""}\n\n${TODO_WRITE_INSTRUCTIONS}`;
             }
             const agent = createAgent(agentConfig);
-            // Add logging callbacks for model requests
-            const provider = detectProvider(this.definition.model);
             // Build messages from context history if available, otherwise use just the prompt
             let messages;
             // Helper to convert content blocks to LangChain format
@@ -477,12 +541,6 @@ export class LangchainAgent {
                     },
                 ];
             }
-            // Create OTEL callbacks for instrumentation
-            const otelCallbacks = makeOtelCallbacks({
-                provider,
-                model: this.definition.model,
-                parentContext: invocationContext,
-            });
             // Create the stream within the invocation context so AsyncLocalStorage
             // propagates the context to all tool executions and callbacks
             const stream = context.with(invocationContext, () => agent.stream({ messages }, {
@@ -613,6 +671,7 @@ export class LangchainAgent {
                             const matchingTool = finalTools.find((t) => t.name === toolCall.name);
                             let prettyName = matchingTool?.prettyName;
                             const icon = matchingTool?.icon;
+                            const verbiage = matchingTool?.verbiage;
                             // For the Task tool, use the displayName (or agentName as fallback) as the prettyName
                             if (toolCall.name === SUBAGENT_TOOL_NAME &&
                                 toolCall.args &&
@@ -654,6 +713,7 @@ export class LangchainAgent {
                                         messageId: req.messageId,
                                         ...(prettyName ? { prettyName } : {}),
                                         ...(icon ? { icon } : {}),
+                                        ...(verbiage ? { verbiage } : {}),
                                         ...(batchId ? { batchId } : {}),
                                     },
                                 });
@@ -672,6 +732,7 @@ export class LangchainAgent {
                                         messageId: req.messageId,
                                         ...(prettyName ? { prettyName } : {}),
                                         ...(icon ? { icon } : {}),
+                                        ...(verbiage ? { verbiage } : {}),
                                         ...(batchId ? { batchId } : {}),
                                     },
                                 });
@@ -888,12 +949,15 @@ export class LangchainAgent {
             yield* yieldPendingSubagentUpdates();
             // Now that content streaming is complete, yield all buffered tool call notifications
             yield* flushPendingToolCalls();
-            // Clean up subagent connection listener
+            // Clean up subagent event listeners
             subagentEvents.off("connection", onSubagentConnection);
+            subagentEvents.off("messages", onSubagentMessages);
             // Cancel any pending wait
             if (subagentUpdateResolver) {
                 subagentUpdateResolver = null;
             }
+            // Clean up any remaining iteration span
+            otelCallbacks?.cleanup();
             // Log successful completion
             telemetry.log("info", "Agent invocation completed", {
                 sessionId: req.sessionId,
@@ -907,8 +971,11 @@ export class LangchainAgent {
             };
         }
         catch (error) {
-            // Clean up subagent connection listener on error
+            // Clean up subagent event listeners on error
             subagentEvents.off("connection", onSubagentConnection);
+            subagentEvents.off("messages", onSubagentMessages);
+            // Clean up any remaining iteration span
+            otelCallbacks?.cleanup();
             // Log error and end span with error status
             telemetry.log("error", "Agent invocation failed", {
                 error: error instanceof Error ? error.message : String(error),
@@ -917,6 +984,10 @@ export class LangchainAgent {
             telemetry.endSpan(invocationSpan, error instanceof Error ? error : new Error(String(error)));
             throw error;
         }
+        finally {
+            // Clear agent.session_id from base attributes to prevent cross-contamination
+            telemetry.clearBaseAttribute("agent.session_id");
+        }
     }
 }
 const modelRequestSchema = z.object({
@@ -928,17 +999,17 @@ const makeMcpToolsClient = (mcpConfigs) => {
     const mcpServers = mcpConfigs?.map((config) => {
         if (typeof config === "string") {
             // String configs use the centralized MCP proxy with auth
-            const credentials = loadAuthCredentials();
-            if (!credentials) {
-                throw new Error("Not logged in. Run 'town login' first to use cloud MCP servers.");
+            const shedAuth = getShedAuth();
+            if (!shedAuth) {
+                throw new Error("Not logged in. Run 'town login' or set SHED_API_KEY to use cloud MCP servers.");
             }
-            const proxyUrl = process.env.MCP_PROXY_URL ?? `${credentials.shed_url}/mcp_proxy`;
+            const proxyUrl = process.env.MCP_PROXY_URL ?? `${shedAuth.shedUrl}/mcp_proxy`;
             return [
                 config,
                 {
                     url: `${proxyUrl}?server=${config}`,
                     headers: {
-                        Authorization: `Bearer ${credentials.access_token}`,
+                        Authorization: `Bearer ${shedAuth.accessToken}`,
                     },
                 },
             ];
@@ -1031,18 +1102,22 @@ export { makeSubagentsTool } from "./tools/subagent.js";
  * This ensures the tool executes within its own span context,
  * so any child operations (like subagent spawning) become children
  * of the tool span rather than the parent invocation span.
+ * @param originalTool The tool to wrap
+ * @param getIterationContext Function that returns the current iteration context
  */
-function wrapToolWithTracing(originalTool) {
+function wrapToolWithTracing(originalTool, getIterationContext) {
     const wrappedFunc = async (input) => {
         const toolInputJson = JSON.stringify(input);
+        // Get the current iteration context so the tool span is created as a child
+        const iterationContext = getIterationContext();
         const toolSpan = telemetry.startSpan("agent.tool_call", {
             "tool.name": originalTool.name,
             "tool.input": toolInputJson,
-        });
+        }, iterationContext);
         // Create a context with the tool span as active
         const spanContext = toolSpan
-            ? trace.setSpan(context.active(), toolSpan)
-            : context.active();
+            ? trace.setSpan(iterationContext, toolSpan)
+            : iterationContext;
         try {
             // Execute within the tool span's context
             const result = await context.with(spanContext, () => originalTool.invoke(input));

package/dist/runner/langchain/model-factory.js

@@ -1,7 +1,7 @@
 import { ChatAnthropic } from "@langchain/anthropic";
 import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
 import { ChatVertexAI } from "@langchain/google-vertexai";
-import { loadAuthCredentials } from "@townco/core/auth";
+import { getShedAuth } from "@townco/core/auth";
 import { createLogger } from "../../logger.js";
 const logger = createLogger("model-factory");
 /**
@@ -24,17 +24,14 @@ export function createModelFromString(modelString) {
     // Check for town- prefix for proxied models via shed
     if (modelString.startsWith("town-")) {
         const actualModel = modelString.slice(5); // strip "town-"
-        const credentials = loadAuthCredentials();
-        if (!credentials) {
-            throw new Error("Not logged in. Run 'town login' first.");
+        const shedAuth = getShedAuth();
+        if (!shedAuth) {
+            throw new Error("Not logged in. Run 'town login' or set SHED_API_KEY.");
         }
-        const shedUrl = credentials.shed_url ??
-            process.env.TOWN_SHED_URL ??
-            "http://localhost:3000";
         return new ChatAnthropic({
             model: actualModel,
-            anthropicApiUrl: `${shedUrl}/api/anthropic`,
-            apiKey: credentials.access_token,
+            anthropicApiUrl: `${shedAuth.shedUrl}/api/anthropic`,
+            apiKey: shedAuth.accessToken,
         });
     }
     // Check if the model string uses provider prefix format

package/dist/runner/langchain/otel-callbacks.d.ts

@@ -4,6 +4,9 @@ export interface OtelCallbackOptions {
     provider: string;
     model: string;
     parentContext: Context;
+    iterationIndexRef: {
+        current: number;
+    };
 }
 /**
  * Creates OpenTelemetry callback handlers for LangChain LLM calls.
@@ -15,4 +18,7 @@ export interface OtelCallbackOptions {
  * @param opts.parentContext - The parent OTEL context to create child spans under
  * @returns CallbackHandlerMethods object that can be passed to LangChain
  */
-export declare function makeOtelCallbacks(opts: OtelCallbackOptions): CallbackHandlerMethods;
+export declare function makeOtelCallbacks(opts: OtelCallbackOptions): CallbackHandlerMethods & {
+    cleanup: () => void;
+    getCurrentIterationContext: () => Context;
+};

package/dist/runner/langchain/otel-callbacks.js

@@ -5,11 +5,15 @@ import { telemetry } from "../../telemetry/index.js";
  * Creates spans for each LLM request to track model invocations and token usage.
  */
 /**
- * Map to store active spans by their LangChain run ID
+ * Map to store active chat spans by their LangChain run ID
  *
  * There's a memory leak opportunity here, but we are OK with that for now.
  */
 const spansByRunId = new Map();
+/**
+ * Map to store active iteration spans by their LangChain run ID
+ */
+const iterationSpansByRunId = new Map();
 /**
  * Serializes LangChain messages to a JSON string for span attributes.
  * Extracts role and content from each message.
@@ -88,19 +92,41 @@ function serializeOutput(output) {
  * @returns CallbackHandlerMethods object that can be passed to LangChain
  */
 export function makeOtelCallbacks(opts) {
+    // Track the iteration span for this specific invocation
+    let localIterationSpan = null;
+    let currentIterationContext = opts.parentContext;
     return {
         /**
          * Called when a chat model/LLM request starts.
-         * Creates a new OTEL span for this LLM request.
+         * Creates iteration span first, then chat span as its child.
          */
         async handleChatModelStart(_llm, messages, runId, _parentRunId, _extraParams, tags, _metadata) {
             // Extract system prompt and serialize messages
             const systemPrompt = extractSystemPrompt(messages);
             const serializedMessages = serializeMessages(messages);
-            // Create span within the parent context (invocation span)
+            // Close previous iteration span if it exists (tools from previous iteration are done)
+            if (localIterationSpan) {
+                telemetry.endSpan(localIterationSpan);
+                localIterationSpan = null;
+            }
+            // Create iteration span within the parent context (invocation span)
+            const iterationIndex = opts.iterationIndexRef.current;
+            const iterationSpan = context.with(opts.parentContext, () => telemetry.startSpan("agent.iteration", {
+                "agent.iteration.index": iterationIndex,
+                "langchain.run_id": runId,
+            }));
+            // Track as current iteration span (will be closed when next iteration starts or invocation ends)
+            localIterationSpan = iterationSpan;
+            // Create context with iteration span as active
+            const iterationContext = iterationSpan
+                ? trace.setSpan(opts.parentContext, iterationSpan)
+                : opts.parentContext;
+            // Store current iteration context so tools can use it
+            currentIterationContext = iterationContext;
+            // Create chat span as child of iteration span
             // Following OpenTelemetry GenAI semantic conventions:
             // https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-spans/
-            const span = context.with(opts.parentContext, () => telemetry.startSpan(`chat ${opts.model}`, {
+            const chatSpan = context.with(iterationContext, () => telemetry.startSpan(`chat ${opts.model}`, {
                 "gen_ai.operation.name": "chat",
                 "gen_ai.provider.name": opts.provider,
                 "gen_ai.request.model": opts.model,
@@ -114,10 +140,14 @@ export function makeOtelCallbacks(opts) {
                     ? { "langchain.tags": tags.join(",") }
                     : {}),
             }));
-            if (span) {
-                spansByRunId.set(runId, span);
+            // Store both spans
+            if (iterationSpan) {
+                iterationSpansByRunId.set(runId, iterationSpan);
+            }
+            if (chatSpan) {
+                spansByRunId.set(runId, chatSpan);
                 // Emit log for LLM request with trace context
-                const spanContext = span.spanContext();
+                const spanContext = chatSpan.spanContext();
                 telemetry.log("info", "LLM Request", {
                     "gen_ai.operation.name": "chat",
                     "gen_ai.provider.name": opts.provider,
@@ -129,14 +159,16 @@ export function makeOtelCallbacks(opts) {
                     span_id: spanContext.spanId,
                 });
             }
+            // Increment iteration index for next LLM call
+            opts.iterationIndexRef.current++;
         },
         /**
          * Called when an LLM request completes successfully.
-         * Records token usage and ends the span.
+         * Records token usage and ends both chat and iteration spans.
          */
         async handleLLMEnd(output, runId) {
-            const span = spansByRunId.get(runId);
-            if (!span)
+            const chatSpan = spansByRunId.get(runId);
+            if (!chatSpan)
                 return;
             // Extract token usage from LLM output
             // The structure varies by provider but LangChain normalizes it
@@ -147,15 +179,15 @@ export function makeOtelCallbacks(opts) {
                     (tokenUsage.totalTokens != null
                         ? tokenUsage.totalTokens - inputTokens
                         : 0);
-                telemetry.recordTokenUsage(inputTokens, outputTokens, span);
+                telemetry.recordTokenUsage(inputTokens, outputTokens, chatSpan);
             }
             // Serialize output and attach to span
             const serializedOutput = serializeOutput(output);
-            telemetry.setSpanAttributes(span, {
+            telemetry.setSpanAttributes(chatSpan, {
                 "gen_ai.output.messages": serializedOutput,
             });
             // Emit log for LLM response with trace context
-            const spanContext = span.spanContext();
+            const spanContext = chatSpan.spanContext();
             telemetry.log("info", "LLM Response", {
                 "gen_ai.operation.name": "chat",
                 "gen_ai.output.messages": serializedOutput,
@@ -171,19 +203,47 @@ export function makeOtelCallbacks(opts) {
                 trace_id: spanContext.traceId,
                 span_id: spanContext.spanId,
             });
-            telemetry.endSpan(span);
+            // End chat span
+            telemetry.endSpan(chatSpan);
             spansByRunId.delete(runId);
+            // DON'T close iteration span here - tools will execute after this
+            // The iteration span will be closed when:
+            // 1. Next iteration starts (in handleChatModelStart)
+            // 2. Invocation ends (caller must close remaining span)
+            iterationSpansByRunId.delete(runId);
         },
         /**
          * Called when an LLM request fails with an error.
-         * Records the error and ends the span with error status.
+         * Records the error and ends both chat and iteration spans.
          */
         async handleLLMError(error, runId) {
-            const span = spansByRunId.get(runId);
-            if (!span)
-                return;
-            telemetry.endSpan(span, error instanceof Error ? error : new Error(String(error)));
-            spansByRunId.delete(runId);
+            const chatSpan = spansByRunId.get(runId);
+            if (chatSpan) {
+                telemetry.endSpan(chatSpan, error instanceof Error ? error : new Error(String(error)));
+                spansByRunId.delete(runId);
+            }
+            // Close iteration span on error
+            if (localIterationSpan) {
+                telemetry.endSpan(localIterationSpan, error instanceof Error ? error : new Error(String(error)));
+                localIterationSpan = null;
+            }
+            iterationSpansByRunId.delete(runId);
+        },
+        /**
+         * Get the current iteration context for tool span creation
+         */
+        getCurrentIterationContext() {
+            return currentIterationContext;
+        },
+        /**
+         * Cleanup function to close any remaining iteration span
+         * Should be called when invocation completes
+         */
+        cleanup() {
+            if (localIterationSpan) {
+                telemetry.endSpan(localIterationSpan);
+                localIterationSpan = null;
+            }
         },
     };
 }

package/dist/runner/langchain/tools/filesystem.js

@@ -190,6 +190,11 @@ export function makeFilesystemTools(workingDirectory) {
     });
     grep.prettyName = "Codebase Search";
     grep.icon = "Search";
+    grep.verbiage = {
+        active: "Searching for {query}",
+        past: "Searched for {query}",
+        paramKey: "pattern",
+    };
     const read = tool(async ({ file_path, offset, limit }) => {
         await ensureSandbox(resolvedWd);
         assertAbsolutePath(file_path, "file_path");
@@ -234,6 +239,11 @@ export function makeFilesystemTools(workingDirectory) {
     });
     read.prettyName = "Read File";
     read.icon = "FileText";
+    read.verbiage = {
+        active: "Reading {file}",
+        past: "Read {file}",
+        paramKey: "file_path",
+    };
     const write = tool(async ({ file_path, content }) => {
         await ensureSandbox(resolvedWd);
         assertAbsolutePath(file_path, "file_path");
@@ -263,5 +273,10 @@ export function makeFilesystemTools(workingDirectory) {
     });
     write.prettyName = "Write File";
     write.icon = "Edit";
+    write.verbiage = {
+        active: "Writing {file}",
+        past: "Wrote {file}",
+        paramKey: "file_path",
+    };
     return [grep, read, write];
 }

package/dist/runner/langchain/tools/subagent-connections.d.ts

@@ -7,6 +7,35 @@ export interface SubagentConnectionInfo {
     port: number;
     sessionId: string;
 }
+/**
+ * Sub-agent tool call tracked during streaming
+ */
+export interface SubagentToolCall {
+    id: string;
+    title: string;
+    prettyName?: string | undefined;
+    icon?: string | undefined;
+    status: "pending" | "in_progress" | "completed" | "failed";
+}
+/**
+ * Content block for sub-agent messages
+ */
+export type SubagentContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "tool_call";
+    toolCall: SubagentToolCall;
+};
+/**
+ * Sub-agent message accumulated during streaming
+ */
+export interface SubagentMessage {
+    id: string;
+    content: string;
+    contentBlocks: SubagentContentBlock[];
+    toolCalls: SubagentToolCall[];
+}
 /**
  * Event emitter for subagent connection events.
  * The runner listens to these events and emits tool_call_update.
@@ -26,3 +55,8 @@ export declare function hashQuery(query: string): string;
  * Emits an event that the runner can listen to.
  */
 export declare function emitSubagentConnection(queryHash: string, connectionInfo: SubagentConnectionInfo): void;
+/**
+ * Called by the subagent tool when it completes with accumulated messages.
+ * Emits an event with the messages for session storage.
+ */
+export declare function emitSubagentMessages(queryHash: string, messages: SubagentMessage[]): void;

package/dist/runner/langchain/tools/subagent-connections.js

@@ -12,6 +12,11 @@ export const subagentEvents = new EventEmitter();
  * Set by the runner when it sees a subagent tool_call.
  */
 export const queryToToolCallId = new Map();
+/**
+ * Maps query hash to resolved toolCallId (preserved after connection event).
+ * Used to correlate messages when the tool completes.
+ */
+const queryToResolvedToolCallId = new Map();
 /**
  * Generate a hash from the query string for correlation.
  */
@@ -46,7 +51,8 @@ export function emitSubagentConnection(queryHash, connectionInfo) {
             toolCallId,
             ...connectionInfo,
         });
-        // Clean up the mapping
+        // Preserve the toolCallId for message emission, but remove from pending lookup
+        queryToResolvedToolCallId.set(queryHash, toolCallId);
         queryToToolCallId.delete(queryHash);
     }
     else {
@@ -56,3 +62,28 @@ export function emitSubagentConnection(queryHash, connectionInfo) {
         });
     }
 }
+/**
+ * Called by the subagent tool when it completes with accumulated messages.
+ * Emits an event with the messages for session storage.
+ */
+export function emitSubagentMessages(queryHash, messages) {
+    const toolCallId = queryToResolvedToolCallId.get(queryHash);
+    if (toolCallId) {
+        logger.info("Emitting subagent messages for storage", {
+            queryHash,
+            toolCallId,
+            messageCount: messages.length,
+        });
+        subagentEvents.emit("messages", {
+            toolCallId,
+            messages,
+        });
+        // Clean up the resolved mapping
+        queryToResolvedToolCallId.delete(queryHash);
+    }
+    else {
+        logger.warn("No resolved toolCallId for messages emission", {
+            queryHash,
+        });
+    }
+}