@townco/agent 0.1.112 → 0.1.114

package/dist/acp-server/adapter.js

@@ -273,14 +273,12 @@ export class AgentAcpAdapter {
                         "url" in result &&
                         typeof result.url === "string") {
                         // Use the citationId from the tool output if available
-                        let citationId;
-                        if (typeof result.citationId === "number") {
-                            citationId = String(result.citationId);
-                        }
-                        else {
-                            session.sourceCounter++;
-                            citationId = String(session.sourceCounter);
-                        }
+                        const citationId = typeof result.citationId === "number"
+                            ? String(result.citationId)
+                            : (() => {
+                                session.sourceCounter++;
+                                return String(session.sourceCounter);
+                            })();
                         const url = result.url;
                         const title = typeof result.title === "string" ? result.title : "Untitled";
                         const snippet = typeof result.text === "string"
@@ -420,14 +418,11 @@ export class AgentAcpAdapter {
                 if (!docUrl && !docTitle)
                     return null;
                 // Use document_id as the citation ID if available, otherwise use counter
-                let citationId;
-                if (docId) {
-                    citationId = docId;
-                }
-                else {
-                    session.sourceCounter++;
-                    citationId = String(session.sourceCounter);
-                }
+                const citationId = docId ||
+                    (() => {
+                        session.sourceCounter++;
+                        return String(session.sourceCounter);
+                    })();
                 // Extract snippet from summary or content
                 let snippet;
                 if (typeof doc.summary === "string") {
@@ -1075,7 +1070,7 @@ export class AgentAcpAdapter {
         }
         logger.info("User message received", {
             sessionId: params.sessionId,
-            messagePreview: userMessageText.slice(0, 100),
+            message: userMessageText,
             noSession: this.noSession,
         });
         // Only store messages if session persistence is enabled
@@ -1134,12 +1129,40 @@ export class AgentAcpAdapter {
         // Build ordered content blocks for the assistant response
         const contentBlocks = [];
         let pendingText = "";
+        // Buffer for logging agent response in readable chunks
+        let logBuffer = "";
+        const flushLogBuffer = (force = false) => {
+            if (logBuffer.length === 0)
+                return;
+            if (force) {
+                // Flush everything
+                logger.info("Agent response", {
+                    sessionId: params.sessionId,
+                    text: logBuffer,
+                });
+                logBuffer = "";
+            }
+            else {
+                // Only flush complete lines (up to and including the last newline)
+                const lastNewline = logBuffer.lastIndexOf("\n");
+                if (lastNewline !== -1) {
+                    const completeLines = logBuffer.slice(0, lastNewline + 1);
+                    logBuffer = logBuffer.slice(lastNewline + 1);
+                    logger.info("Agent response", {
+                        sessionId: params.sessionId,
+                        text: completeLines,
+                    });
+                }
+            }
+        };
         // Helper function to flush pending text as a TextBlock
         const flushPendingText = () => {
             if (pendingText.length > 0) {
                 contentBlocks.push({ type: "text", text: pendingText });
                 pendingText = "";
             }
+            // Force flush any remaining log buffer when text block completes
+            flushLogBuffer(true);
         };
         // Helper to save cancelled message to session
         const saveCancelledMessage = async () => {
@@ -1332,6 +1355,11 @@ export class AgentAcpAdapter {
                         const content = msg.content;
                         if (content.type === "text" && typeof content.text === "string") {
                             pendingText += content.text;
+                            // Buffer for logging - flush on newlines
+                            logBuffer += content.text;
+                            if (logBuffer.includes("\n")) {
+                                flushLogBuffer();
+                            }
                         }
                     }
                     // Debug: log if this chunk has tokenUsage in _meta
@@ -1405,6 +1433,13 @@ export class AgentAcpAdapter {
                     if (toolCallMsg.rawInput) {
                         toolCall.rawInput = toolCallMsg.rawInput;
                     }
+                    // Log tool call start
+                    logger.info("Tool call started", {
+                        sessionId: params.sessionId,
+                        toolCallId: toolCall.id,
+                        tool: toolCall.title,
+                        prettyName: toolCall.prettyName,
+                    });
                     contentBlocks.push(toolCall);
                 }
                 // Handle tool_call_update - update existing ToolCallBlock
@@ -1431,6 +1466,17 @@ export class AgentAcpAdapter {
                         if (toolCallBlock.status === "completed" ||
                             toolCallBlock.status === "failed") {
                             toolCallBlock.completedAt = Date.now();
+                            // Log tool call completion
+                            logger.info("Tool call completed", {
+                                sessionId: params.sessionId,
+                                toolCallId: updateMsg.toolCallId,
+                                tool: toolCallBlock.title,
+                                status: toolCallBlock.status,
+                                durationMs: toolCallBlock.startedAt
+                                    ? toolCallBlock.completedAt - toolCallBlock.startedAt
+                                    : undefined,
+                                error: toolCallBlock.error,
+                            });
                         }
                         const meta = updateMsg._meta;
                         // Update batchId from _meta (comes from tool_call_update after preliminary tool_call)
@@ -1444,37 +1490,11 @@ export class AgentAcpAdapter {
                             toolCallBlock.subagentSessionId = meta.subagentSessionId;
                         }
                         if (meta?.subagentMessages) {
-                            logger.info("Storing subagent messages for session replay", {
-                                toolCallId: updateMsg.toolCallId,
-                                messageCount: meta.subagentMessages.length,
-                            });
                             toolCallBlock.subagentMessages = meta.subagentMessages;
                         }
                     }
                     // Forward tool_call_update with _meta to the client (for subagent connection info, etc.)
                     if (updateMsg._meta) {
-                        logger.info("Forwarding tool_call_update with _meta to client", {
-                            toolCallId: updateMsg.toolCallId,
-                            status: updateMsg.status,
-                            _meta: updateMsg._meta,
-                        });
-                        this.connection.sessionUpdate({
-                            sessionId: params.sessionId,
-                            update: {
-                                sessionUpdate: "tool_call_update",
-                                toolCallId: updateMsg.toolCallId,
-                                status: updateMsg.status,
-                                _meta: updateMsg._meta,
-                            },
-                        });
-                    }
-                    // Forward tool_call_update with _meta to the client (for subagent connection info, etc.)
-                    if (updateMsg._meta) {
-                        logger.info("Forwarding tool_call_update with _meta to client", {
-                            toolCallId: updateMsg.toolCallId,
-                            status: updateMsg.status,
-                            _meta: updateMsg._meta,
-                        });
                         this.connection.sessionUpdate({
                             sessionId: params.sessionId,
                             update: {

package/dist/acp-server/http.js

@@ -406,6 +406,27 @@ export function createAcpHttpApp(agent, agentDir, agentName) {
         allowMethods: ["GET", "POST", "OPTIONS"],
     }));
     app.get("/health", (c) => c.json({ ok: true }));
+    // Receive browser console logs and write to agent.log
+    const browserLogger = createLogger("gui-console");
+    app.post("/logs/browser", async (c) => {
+        try {
+            const { logs } = await c.req.json();
+            if (Array.isArray(logs)) {
+                for (const log of logs) {
+                    const level = log.level;
+                    const method = browserLogger[level];
+                    if (typeof method === "function") {
+                        method.call(browserLogger, log.message, log.metadata);
+                    }
+                }
+            }
+            return c.json({ ok: true });
+        }
+        catch (error) {
+            logger.error("Failed to process browser logs", { error });
+            return c.json({ ok: false }, 400);
+        }
+    });
     // List available sessions
     app.get("/sessions", async (c) => {
         if (!agentDir || !agentName) {

package/dist/runner/langchain/index.js

@@ -1,3 +1,4 @@
+import { EventEmitter } from "node:events";
 import { mkdir } from "node:fs/promises";
 import * as path from "node:path";
 import { MultiServerMCPClient } from "@langchain/mcp-adapters";
@@ -11,7 +12,7 @@ import { telemetry } from "../../telemetry/index.js";
 import { calculateContextSize } from "../../utils/context-size-calculator.js";
 import { getModelContextWindow } from "../hooks/constants.js";
 import { isContextOverflowError } from "../hooks/predefined/context-validator.js";
-import { bindGeneratorToAbortSignal, bindGeneratorToEmitUpdate, bindGeneratorToSessionContext, getAbortSignal, runWithAbortSignal, } from "../session-context";
+import { bindGeneratorToAbortSignal, bindGeneratorToEmitUpdate, bindGeneratorToInvocationContext, bindGeneratorToSessionContext, getAbortSignal, getInvocationContext, runWithAbortSignal, } from "../session-context";
 import { loadCustomToolModule, } from "../tool-loader.js";
 import { createModelFromString, detectProvider } from "./model-factory.js";
 import { makeOtelCallbacks } from "./otel-callbacks.js";
@@ -19,7 +20,7 @@ import { makeBrowserTools } from "./tools/browser";
 import { makeDocumentExtractTool } from "./tools/document_extract";
 import { makeTownE2BTools } from "./tools/e2b";
 import { SUBAGENT_TOOL_NAME } from "./tools/subagent";
-import { hashQuery, queryToToolCallId, subagentEvents, } from "./tools/subagent-connections";
+import { hashQuery, queryToToolCallId, } from "./tools/subagent-connections";
 import { makeTodoWriteTool, TODO_WRITE_TOOL_NAME } from "./tools/todo";
 import { makeTownWebSearchTools, makeWebSearchTools } from "./tools/web_search";
 const _logger = createLogger("agent-runner");
@@ -82,6 +83,14 @@ export class LangchainAgent {
     async *invokeInternal(req) {
         // Start with the base generator
         let generator = this.invokeWithContext(req);
+        // Create invocation-scoped context for subagent event routing
+        // This must be done here so it's available before invokeWithContext starts
+        const subagentInvocationContext = {
+            invocationId: req.sessionId,
+            subagentEventEmitter: new EventEmitter(),
+        };
+        // Bind invocation context first so it's available to all nested operations
+        generator = bindGeneratorToInvocationContext(subagentInvocationContext, generator);
         // Bind abort signal if available (for cancellation support)
         if (req.abortSignal) {
             generator = bindGeneratorToAbortSignal(req.abortSignal, generator);
@@ -108,6 +117,11 @@ export class LangchainAgent {
         return yield* generator;
     }
     async *invokeWithContext(req) {
+        // Get subagent invocation context from AsyncLocalStorage (created in invokeInternal)
+        const subagentInvCtx = getInvocationContext();
+        if (!subagentInvCtx) {
+            throw new Error("No subagent invocation context available - invokeWithContext called outside of invocation binding");
+        }
         // Derive the parent OTEL context for this invocation.
         // If this is a subagent and the parent process propagated an OTEL trace
         // context via sessionMeta.otelTraceContext, use that as the parent;
@@ -140,78 +154,43 @@ export class LangchainAgent {
             // Clear the buffer after flushing
             pendingToolCallNotifications.length = 0;
         }
-        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", {
-                toolCallId: event.toolCallId,
-                port: event.port,
-                sessionId: event.sessionId,
-            });
-            if (subagentUpdateResolver) {
-                // If someone is waiting, resolve immediately
-                const resolver = subagentUpdateResolver;
-                subagentUpdateResolver = null;
-                resolver(event);
-            }
-            else {
-                // Otherwise queue for later
-                subagentUpdateQueue.push(event);
-            }
-        };
-        subagentEvents.on("connection", onSubagentConnection);
-        // Listen for subagent messages events (for session storage)
+        const completedSubagentToolCalls = new Set();
+        const activeSubagentToolCalls = new Set();
+        // Listen for subagent messages events (for live streaming)
+        // Use the invocation-scoped EventEmitter to ensure messages route correctly
         const onSubagentMessages = (event) => {
-            _logger.info("Received subagent messages event", {
+            _logger.info("✓ Received subagent messages event from scoped emitter", {
                 toolCallId: event.toolCallId,
                 messageCount: event.messages.length,
+                completed: event.completed,
+                invocationId: subagentInvCtx.invocationId,
+                sessionId: req.sessionId,
             });
-            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) {
-                // biome-ignore lint/style/noNonNullAssertion: We check length > 0, so shift() will return a value
-                return Promise.resolve(subagentUpdateQueue.shift());
+            // Track completion
+            if (event.completed) {
+                completedSubagentToolCalls.add(event.toolCallId);
+                _logger.info("✓ Subagent stream completed", {
+                    toolCallId: event.toolCallId,
+                    sessionId: req.sessionId,
+                    totalCompleted: completedSubagentToolCalls.size,
+                });
             }
-            return new Promise((resolve) => {
-                subagentUpdateResolver = resolve;
-            });
+            subagentMessagesQueue.push(event);
         };
-        // Helper to check and yield all pending subagent updates
+        subagentInvCtx.subagentEventEmitter.on("messages", onSubagentMessages);
+        // Helper to check and yield all pending subagent message updates
         async function* yieldPendingSubagentUpdates() {
-            while (subagentUpdateQueue.length > 0) {
-                const update = subagentUpdateQueue.shift();
-                if (!update)
-                    continue;
-                _logger.info("Yielding queued subagent connection update", {
-                    toolCallId: update.toolCallId,
-                    subagentPort: update.port,
-                    subagentSessionId: update.sessionId,
-                });
-                yield {
-                    sessionUpdate: "tool_call_update",
-                    toolCallId: update.toolCallId,
-                    _meta: {
-                        messageId: req.messageId,
-                        subagentPort: update.port,
-                        subagentSessionId: update.sessionId,
-                    },
-                };
-            }
-            // Also yield any pending messages updates
             while (subagentMessagesQueue.length > 0) {
                 const messagesUpdate = subagentMessagesQueue.shift();
                 if (!messagesUpdate)
                     continue;
-                _logger.info("Yielding queued subagent messages update", {
+                _logger.debug("[SUBAGENT] Yielding queued subagent messages update", {
+                    sessionId: req.sessionId,
                     toolCallId: messagesUpdate.toolCallId,
                     messageCount: messagesUpdate.messages.length,
                 });
-                yield {
+                const updateToYield = {
                     sessionUpdate: "tool_call_update",
                     toolCallId: messagesUpdate.toolCallId,
                     _meta: {
@@ -219,6 +198,7 @@ export class LangchainAgent {
                         subagentMessages: messagesUpdate.messages,
                     },
                 };
+                yield updateToYield;
             }
         }
         // Add agent.session_id as a base attribute so it propagates to all child spans
@@ -871,53 +851,63 @@ export class LangchainAgent {
                 callbacks: [otelCallbacks],
             }));
             _logger.info("agent.stream created, starting iteration");
-            // Use manual iteration with Promise.race to interleave stream events with subagent updates
-            const streamIterator = (await stream)[Symbol.asyncIterator]();
-            let streamDone = false;
-            let pendingStreamPromise = null;
-            while (!streamDone) {
-                // Get or create the stream promise (reuse if still pending from last iteration)
-                const nextStreamPromise = pendingStreamPromise ?? streamIterator.next();
-                pendingStreamPromise = nextStreamPromise; // Track it
-                // Create subagent wait promise (only if no queued updates)
-                const subagentPromise = waitForSubagentUpdate();
-                // Use Promise.race, but we need to handle both outcomes
-                const result = await Promise.race([
-                    nextStreamPromise.then((r) => ({
-                        type: "stream",
-                        result: r,
-                    })),
-                    subagentPromise.then((u) => ({ type: "subagent", update: u })),
-                ]);
-                if (result.type === "subagent") {
-                    // Got a subagent update - yield it immediately
-                    const update = result.update;
-                    _logger.info("Yielding subagent connection update (via race)", {
-                        toolCallId: update.toolCallId,
-                        subagentPort: update.port,
-                        subagentSessionId: update.sessionId,
+            // Merge the LangChain stream with subagent event stream
+            // This allows both to yield concurrently without polling
+            async function* mergeStreams() {
+                const streamIterator = (await stream)[Symbol.asyncIterator]();
+                const _pending = [];
+                let streamDone = false;
+                let subagentListenerActive = true;
+                // Create a promise that resolves when the next subagent event arrives
+                function createSubagentEventPromise() {
+                    return new Promise((resolve) => {
+                        const handler = (event) => {
+                            subagentInvCtx?.subagentEventEmitter.off("messages", handler);
+                            resolve({ source: "subagent", value: event, done: false });
+                        };
+                        subagentInvCtx?.subagentEventEmitter.once("messages", handler);
                     });
-                    yield {
-                        sessionUpdate: "tool_call_update",
-                        toolCallId: update.toolCallId,
-                        _meta: {
-                            messageId: req.messageId,
-                            subagentPort: update.port,
-                            subagentSessionId: update.sessionId,
-                        },
-                    };
-                    // Continue - the stream promise is still pending, will be reused
-                    continue;
                 }
-                // Got a stream item - clear the pending promise
-                pendingStreamPromise = null;
-                const { done, value: streamItem } = result.result;
-                if (done) {
-                    streamDone = true;
-                    break;
+                // Start listening for subagent events
+                let subagentPromise = createSubagentEventPromise();
+                while (!streamDone || subagentListenerActive) {
+                    // Race between next stream item and next subagent event
+                    const streamPromise = streamIterator.next().then((result) => ({
+                        source: "stream",
+                        value: result.value,
+                        done: result.done ?? false,
+                    }));
+                    const result = await Promise.race([streamPromise, subagentPromise]);
+                    if (result.source === "stream") {
+                        if (result.done) {
+                            streamDone = true;
+                            // Continue to drain remaining subagent events
+                            subagentListenerActive = false;
+                            // Yield any remaining queued messages
+                            while (subagentMessagesQueue.length > 0) {
+                                yield { source: "subagent" };
+                            }
+                            break;
+                        }
+                        yield { source: "stream", value: result.value };
+                    }
+                    else if (result.source === "subagent") {
+                        // Subagent event arrived - it's already in the queue
+                        yield { source: "subagent" };
+                        // Start listening for the next subagent event
+                        subagentPromise = createSubagentEventPromise();
+                    }
                 }
-                // Also yield any queued subagent updates before processing stream item
-                yield* yieldPendingSubagentUpdates();
+            }
+            // Iterate through the merged stream
+            for await (const item of mergeStreams()) {
+                if (item.source === "subagent") {
+                    // Yield any queued subagent messages
+                    yield* yieldPendingSubagentUpdates();
+                    continue;
+                }
+                // Process the stream item
+                const streamItem = item.value;
                 // biome-ignore lint/suspicious/noExplicitAny: LangChain stream items are tuples with dynamic types
                 const [streamMode, chunk] = streamItem;
                 if (streamMode === "updates") {
@@ -1020,10 +1010,19 @@ export class LangchainAgent {
                                     typeof toolCall.args.query === "string") {
                                     const qHash = hashQuery(toolCall.args.query);
                                     queryToToolCallId.set(qHash, toolCall.id);
-                                    telemetry.log("info", "Registered subagent query hash mapping", {
+                                    activeSubagentToolCalls.add(toolCall.id);
+                                    telemetry.log("info", "✓ Registered subagent query hash mapping", {
                                         queryHash: qHash,
                                         toolCallId: toolCall.id,
                                         queryPreview: toolCall.args.query.slice(0, 50),
+                                        timestamp: new Date().toISOString(),
+                                    });
+                                }
+                                else {
+                                    telemetry.log("warn", "✗ Subagent tool call missing query parameter", {
+                                        toolCallId: toolCall.id,
+                                        hasQuery: "query" in (toolCall.args || {}),
+                                        argsKeys: Object.keys(toolCall.args || {}),
                                     });
                                 }
                             }
@@ -1312,15 +1311,42 @@ export class LangchainAgent {
             }
             // Yield any remaining pending subagent connection updates after stream ends
             yield* yieldPendingSubagentUpdates();
+            // Keep polling for subagent messages after stream ends
+            // This ensures we capture messages that arrive after LangChain stream completes
+            const checkInterval = 100; // Check every 100ms
+            const maxIdleTime = 5000; // Stop if no messages for 5 seconds (fallback)
+            const maxWaitTime = 300000; // Absolute max 5 minutes
+            const startTime = Date.now();
+            let lastMessageTime = Date.now();
+            while (Date.now() - startTime < maxWaitTime) {
+                // Check if all subagent tool calls have completed
+                if (activeSubagentToolCalls.size > 0 &&
+                    completedSubagentToolCalls.size >= activeSubagentToolCalls.size) {
+                    break;
+                }
+                // Check if there are pending messages
+                if (subagentMessagesQueue.length > 0) {
+                    yield* yieldPendingSubagentUpdates();
+                    lastMessageTime = Date.now();
+                }
+                // Stop if we haven't seen messages for maxIdleTime (fallback for no subagents)
+                if (Date.now() - lastMessageTime > maxIdleTime) {
+                    break;
+                }
+                // Wait a bit before checking again
+                await new Promise((resolve) => setTimeout(resolve, checkInterval));
+            }
+            if (Date.now() - startTime >= maxWaitTime) {
+                _logger.warn("[SUBAGENT] Timeout waiting for subagents", {
+                    sessionId: req.sessionId,
+                });
+            }
+            // Final yield of any remaining messages
+            yield* yieldPendingSubagentUpdates();
             // Now that content streaming is complete, yield all buffered tool call notifications
             yield* flushPendingToolCalls();
-            // Clean up subagent event listeners
-            subagentEvents.off("connection", onSubagentConnection);
-            subagentEvents.off("messages", onSubagentMessages);
-            // Cancel any pending wait
-            if (subagentUpdateResolver) {
-                subagentUpdateResolver = null;
-            }
+            // Clean up subagent event listener from invocation-scoped emitter
+            subagentInvCtx.subagentEventEmitter.off("messages", onSubagentMessages);
             // Clean up any remaining iteration span
             otelCallbacks?.cleanup();
             // Log successful completion
@@ -1336,9 +1362,8 @@ export class LangchainAgent {
             };
         }
         catch (error) {
-            // Clean up subagent event listeners on error
-            subagentEvents.off("connection", onSubagentConnection);
-            subagentEvents.off("messages", onSubagentMessages);
+            // Clean up subagent event listener on error from invocation-scoped emitter
+            subagentInvCtx.subagentEventEmitter.off("messages", onSubagentMessages);
             // Clean up any remaining iteration span
             otelCallbacks?.cleanup();
             // Check if this is a context overflow error - wrap it for retry handling

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

@@ -1,12 +1,3 @@
-import { EventEmitter } from "node:events";
-/**
- * Registry for subagent connection info.
- * Maps query hash to connection info so the runner can emit tool_call_update.
- */
-export interface SubagentConnectionInfo {
-    port: number;
-    sessionId: string;
-}
 /**
  * Sub-agent tool call tracked during streaming
  */
@@ -36,14 +27,11 @@ export interface SubagentMessage {
     contentBlocks: SubagentContentBlock[];
     toolCalls: SubagentToolCall[];
 }
-/**
- * Event emitter for subagent connection events.
- * The runner listens to these events and emits tool_call_update.
- */
-export declare const subagentEvents: EventEmitter<[never]>;
 /**
  * Maps query hash to toolCallId.
  * Set by the runner when it sees a subagent tool_call.
+ * This is still global because the registration happens in the parent runner
+ * before subagent execution begins.
  */
 export declare const queryToToolCallId: Map<string, string>;
 /**
@@ -51,12 +39,9 @@ export declare const queryToToolCallId: Map<string, string>;
  */
 export declare function hashQuery(query: string): string;
 /**
- * Called by the subagent tool when connection is established.
- * 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.
+ * Called by the subagent tool during execution to emit incremental messages.
+ * Emits an event with the messages for live streaming to the UI.
+ * Uses the invocation context's EventEmitter to ensure messages go to the correct parent.
+ * @param completed - If true, signals that the subagent stream has finished
  */
-export declare function emitSubagentMessages(queryHash: string, messages: SubagentMessage[]): void;
+export declare function emitSubagentMessages(queryHash: string, messages: SubagentMessage[], completed?: boolean): void;