@townco/agent 0.1.113 → 0.1.115

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") {
@@ -884,6 +879,8 @@ export class AgentAcpAdapter {
                         hasSubagentSessionId: !!block.subagentSessionId,
                         hasSubagentMessages: !!block.subagentMessages,
                         subagentMessagesCount: block.subagentMessages?.length,
+                        firstSubagentMessageContentLength: block.subagentMessages?.[0]?.content?.length,
+                        firstSubagentMessageBlocksCount: block.subagentMessages?.[0]?.contentBlocks?.length,
                         blockMeta: block._meta,
                         replayMeta,
                     });
@@ -1075,7 +1072,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 +1131,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 +1357,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,28 +1435,20 @@ 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
                 if ("sessionUpdate" in msg &&
                     msg.sessionUpdate === "tool_call_update") {
                     const updateMsg = msg;
-                    logger.info("[SUBAGENT] Adapter received tool_call_update", {
-                        sessionId: params.sessionId,
-                        toolCallId: updateMsg.toolCallId,
-                        status: updateMsg.status,
-                        hasMeta: !!updateMsg._meta,
-                        hasSubagentMessages: !!updateMsg._meta?.subagentMessages,
-                        subagentMessageCount: updateMsg._meta?.subagentMessages?.length ||
-                            0,
-                    });
                     const toolCallBlock = contentBlocks.find((block) => block.type === "tool_call" && block.id === updateMsg.toolCallId);
-                    logger.info("[SUBAGENT] Tool call block lookup result", {
-                        sessionId: params.sessionId,
-                        toolCallId: updateMsg.toolCallId,
-                        found: !!toolCallBlock,
-                        blockStatus: toolCallBlock?.status,
-                    });
                     if (toolCallBlock) {
                         if (updateMsg.status) {
                             toolCallBlock.status =
@@ -1446,6 +1468,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)
@@ -1459,30 +1492,35 @@ export class AgentAcpAdapter {
                             toolCallBlock.subagentSessionId = meta.subagentSessionId;
                         }
                         if (meta?.subagentMessages) {
-                            logger.info("[SUBAGENT] Storing subagent messages for session replay", {
+                            logger.info("[SUBAGENT-ADAPTER] Updating toolCallBlock with subagent messages", {
                                 sessionId: params.sessionId,
-                                toolCallId: updateMsg.toolCallId,
-                                messageCount: meta.subagentMessages.length,
-                                contentPreview: meta.subagentMessages[0]?.content?.substring(0, 100),
+                                toolCallId: toolCallBlock.id,
+                                messagesReceived: meta.subagentMessages.length,
+                                firstMessageContentLength: meta.subagentMessages[0]?.content?.length,
+                                firstMessageBlocksCount: meta.subagentMessages[0]?.contentBlocks?.length,
+                                existingMessagesCount: toolCallBlock.subagentMessages?.length || 0,
                             });
                             toolCallBlock.subagentMessages = meta.subagentMessages;
-                            logger.info("[SUBAGENT] Successfully stored messages", {
+                            logger.info("[SUBAGENT-ADAPTER] ToolCallBlock updated", {
                                 sessionId: params.sessionId,
-                                toolCallId: updateMsg.toolCallId,
-                                storedCount: toolCallBlock.subagentMessages?.length,
+                                toolCallId: toolCallBlock.id,
+                                toolCallBlockMessagesCount: toolCallBlock.subagentMessages?.length,
+                                toolCallBlockFirstMessageLength: toolCallBlock.subagentMessages?.[0]?.content?.length,
                             });
                         }
+                        if (meta?.subagentCompleted !== undefined) {
+                            toolCallBlock.subagentCompleted = meta.subagentCompleted;
+                        }
                     }
                     // Forward tool_call_update with _meta to the client (for subagent connection info, etc.)
                     if (updateMsg._meta) {
-                        logger.info("[SUBAGENT] Forwarding tool_call_update with _meta to client", {
-                            sessionId: params.sessionId,
+                        const subagentCompletedValue = updateMsg._meta
+                            ?.subagentCompleted;
+                        logger.info("[DEBUG] Adapter forwarding tool_call_update to client", {
                             toolCallId: updateMsg.toolCallId,
-                            status: updateMsg.status,
-                            hasSubagentMessages: !!updateMsg._meta
-                                ?.subagentMessages,
-                            subagentMessageCount: updateMsg._meta?.subagentMessages
-                                ?.length || 0,
+                            hasSubagentCompleted: subagentCompletedValue !== undefined,
+                            subagentCompleted: subagentCompletedValue,
+                            metaKeys: Object.keys(updateMsg._meta),
                         });
                         this.connection.sessionUpdate({
                             sessionId: params.sessionId,
@@ -1490,13 +1528,10 @@ export class AgentAcpAdapter {
                                 sessionUpdate: "tool_call_update",
                                 toolCallId: updateMsg.toolCallId,
                                 status: updateMsg.status,
+                                subagentCompleted: subagentCompletedValue,
                                 _meta: updateMsg._meta,
                             },
                         });
-                        logger.info("[SUBAGENT] Successfully forwarded to client", {
-                            sessionId: params.sessionId,
-                            toolCallId: updateMsg.toolCallId,
-                        });
                     }
                 }
                 // Handle tool_output - update ToolCallBlock with output content
@@ -1816,7 +1851,9 @@ export class AgentAcpAdapter {
                         // 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
+                            // DON'T flush here - text should only be flushed when tool_call arrives or at end
+                            // Flushing here causes text that arrives between tool outputs to be lost
+                            // because the final message assembly replaces the entire message
                             // Update or create the partial assistant message in the messages array
                             const partialAssistantMessage = {
                                 role: "assistant",
@@ -1983,6 +2020,13 @@ export class AgentAcpAdapter {
             }
             // Capture the return value (PromptResponse with tokenUsage)
             _agentResponse = iterResult.value;
+            logger.info("[MSG_ACCUMULATION] Generator loop completed", {
+                sessionId: params.sessionId,
+                pendingTextLength: pendingText.length,
+                pendingTextPreview: pendingText.slice(0, 200),
+                contentBlocksCount: contentBlocks.length,
+                contentBlockTypes: contentBlocks.map((b) => b.type),
+            });
             // Flush any remaining pending text
             flushPendingText();
         }
@@ -2060,6 +2104,45 @@ export class AgentAcpAdapter {
         // Store the complete assistant response in session messages
         // Only store if session persistence is enabled
         if (!this.noSession && contentBlocks.length > 0) {
+            logger.info("[MSG_ACCUMULATION] Constructing final assistant message", {
+                sessionId: params.sessionId,
+                contentBlocksCount: contentBlocks.length,
+                contentBlockTypes: contentBlocks.map((b) => b.type),
+                contentBlockSummary: contentBlocks.map((b) => {
+                    if (b.type === "text") {
+                        return {
+                            type: "text",
+                            length: b.text.length,
+                            preview: b.text.slice(0, 100),
+                        };
+                    }
+                    if (b.type === "tool_call") {
+                        return {
+                            type: "tool_call",
+                            id: b.id,
+                            title: b.title,
+                            status: b.status,
+                        };
+                    }
+                    return { type: b.type };
+                }),
+            });
+            // Debug: log contentBlocks before creating assistant message
+            const subagentToolCalls = contentBlocks.filter((b) => b.type === "tool_call" && !!b.subagentMessages);
+            if (subagentToolCalls.length > 0) {
+                logger.info("[SUBAGENT-SESSION-SAVE] Creating assistant message with subagent tool calls", {
+                    sessionId: params.sessionId,
+                    totalContentBlocks: contentBlocks.length,
+                    subagentToolCallsCount: subagentToolCalls.length,
+                    subagentToolCallsDetails: subagentToolCalls.map((tc) => ({
+                        id: tc.id,
+                        title: tc.title,
+                        messagesCount: tc.subagentMessages?.length,
+                        firstMessageContentLength: tc.subagentMessages?.[0]?.content?.length,
+                        firstMessageBlocksCount: tc.subagentMessages?.[0]?.contentBlocks?.length,
+                    })),
+                });
+            }
             const assistantMessage = {
                 role: "assistant",
                 content: contentBlocks,
@@ -2069,10 +2152,19 @@ export class AgentAcpAdapter {
             const lastMessage = session.messages[session.messages.length - 1];
             if (lastMessage && lastMessage.role === "assistant") {
                 // Update the existing message instead of adding a duplicate
+                logger.debug("[MSG_ACCUMULATION] Updating existing assistant message", {
+                    sessionId: params.sessionId,
+                    previousContentBlocks: lastMessage.content.length,
+                    newContentBlocks: contentBlocks.length,
+                });
                 session.messages[session.messages.length - 1] = assistantMessage;
             }
             else {
                 // Add new message (no mid-turn updates occurred)
+                logger.debug("[MSG_ACCUMULATION] Adding new assistant message", {
+                    sessionId: params.sessionId,
+                    messageIndex: session.messages.length,
+                });
                 session.messages.push(assistantMessage);
             }
             // Create context snapshot based on previous context

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

@@ -79,6 +79,8 @@ export interface ToolCallBlock {
     subagentSessionId?: string | undefined;
     /** Stored sub-agent messages for replay */
     subagentMessages?: SubagentMessage[] | undefined;
+    /** Whether the sub-agent has completed */
+    subagentCompleted?: boolean | undefined;
 }
 export type ContentBlock = TextBlock | ImageBlock | ToolCallBlock;
 /**

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

@@ -78,6 +78,7 @@ const toolCallBlockSchema = z.object({
     subagentPort: z.number().optional(),
     subagentSessionId: z.string().optional(),
     subagentMessages: z.array(subagentMessageSchema).optional(),
+    subagentCompleted: z.boolean().optional(),
     _meta: z
         .object({
         truncationWarning: z.string().optional(),
@@ -183,6 +184,29 @@ export class SessionStorage {
      * Uses atomic write (write to temp file, then rename)
      */
     async saveSession(sessionId, messages, context) {
+        // Debug: log subagent data being saved
+        const messagesWithSubagents = messages.filter((msg) => msg.content.some((block) => block.type === "tool_call" &&
+            "subagentMessages" in block &&
+            block.subagentMessages));
+        if (messagesWithSubagents.length > 0) {
+            console.log("[SUBAGENT-STORAGE] Saving session with subagent messages", {
+                sessionId,
+                totalMessages: messages.length,
+                messagesWithSubagents: messagesWithSubagents.length,
+                subagentDetails: messagesWithSubagents.map((msg) => ({
+                    role: msg.role,
+                    toolCallsWithSubagents: msg.content
+                        .filter((block) => block.type === "tool_call" &&
+                        !!("subagentMessages" in block && block.subagentMessages))
+                        .map((tc) => ({
+                        id: tc.id,
+                        title: tc.title,
+                        messagesCount: tc.subagentMessages?.length,
+                        firstMessageContentLength: tc.subagentMessages?.[0]?.content?.length,
+                    })),
+                })),
+            });
+        }
         this.ensureSessionDir(sessionId);
         const sessionPath = this.getSessionPath(sessionId);
         const tempPath = `${sessionPath}.tmp`;

package/dist/runner/langchain/index.js

@@ -3,7 +3,7 @@ import { mkdir } from "node:fs/promises";
 import * as path from "node:path";
 import { MultiServerMCPClient } from "@langchain/mcp-adapters";
 import { context, propagation, trace } from "@opentelemetry/api";
-import { ensureAuthenticated } from "@townco/core/auth";
+import { getShedAuth } from "@townco/core/auth";
 import { AIMessageChunk, createAgent, ToolMessage, tool, } from "langchain";
 import { z } from "zod";
 import { ContextOverflowError, SUBAGENT_MODE_KEY, } from "../../acp-server/adapter";
@@ -160,62 +160,29 @@ export class LangchainAgent {
         // 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 from scoped emitter", {
-                toolCallId: event.toolCallId,
-                messageCount: event.messages.length,
-                completed: event.completed,
-                invocationId: subagentInvCtx.invocationId,
-                sessionId: req.sessionId,
-            });
             // Track completion
             if (event.completed) {
                 completedSubagentToolCalls.add(event.toolCallId);
-                _logger.info("✓ Subagent stream completed", {
-                    toolCallId: event.toolCallId,
-                    sessionId: req.sessionId,
-                    totalCompleted: completedSubagentToolCalls.size,
-                });
             }
             subagentMessagesQueue.push(event);
         };
         subagentInvCtx.subagentEventEmitter.on("messages", onSubagentMessages);
         // Helper to check and yield all pending subagent message updates
         async function* yieldPendingSubagentUpdates() {
-            _logger.info("[SUBAGENT] yieldPendingSubagentUpdates called", {
-                sessionId: req.sessionId,
-                queueLength: subagentMessagesQueue.length,
-            });
             while (subagentMessagesQueue.length > 0) {
                 const messagesUpdate = subagentMessagesQueue.shift();
                 if (!messagesUpdate)
                     continue;
-                _logger.info("[SUBAGENT] Yielding queued subagent messages update", {
-                    sessionId: req.sessionId,
-                    toolCallId: messagesUpdate.toolCallId,
-                    messageCount: messagesUpdate.messages.length,
-                    contentPreview: messagesUpdate.messages[0]?.content?.substring(0, 100),
-                    hasContentBlocks: (messagesUpdate.messages[0]?.contentBlocks?.length ?? 0) > 0,
-                    toolCallCount: messagesUpdate.messages[0]?.toolCalls?.length ?? 0,
-                });
                 const updateToYield = {
                     sessionUpdate: "tool_call_update",
                     toolCallId: messagesUpdate.toolCallId,
                     _meta: {
                         messageId: req.messageId,
                         subagentMessages: messagesUpdate.messages,
+                        subagentCompleted: messagesUpdate.completed,
                     },
                 };
-                _logger.info("[SUBAGENT] About to yield update object", {
-                    sessionId: req.sessionId,
-                    toolCallId: messagesUpdate.toolCallId,
-                    updateType: updateToYield.sessionUpdate,
-                    hasMetaSubagentMessages: !!updateToYield._meta?.subagentMessages,
-                });
                 yield updateToYield;
-                _logger.info("[SUBAGENT] Successfully yielded update", {
-                    sessionId: req.sessionId,
-                    toolCallId: messagesUpdate.toolCallId,
-                });
             }
         }
         // Add agent.session_id as a base attribute so it propagates to all child spans
@@ -643,7 +610,7 @@ export class LangchainAgent {
             // - "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(effectiveModel);
+            const model = await createModelFromString(effectiveModel);
             const agentConfig = {
                 model,
                 tools: finalTools,
@@ -857,17 +824,11 @@ export class LangchainAgent {
             }
             // Create the stream within the invocation context so AsyncLocalStorage
             // propagates the context to all tool executions and callbacks
-            _logger.info("Starting agent.stream", {
-                messageCount: messages.length,
-                effectiveModel,
-                sessionId: req.sessionId,
-            });
             const stream = context.with(invocationContext, () => agent.stream({ messages }, {
                 streamMode: ["updates", "messages"],
                 recursionLimit: 200,
                 callbacks: [otelCallbacks],
             }));
-            _logger.info("agent.stream created, starting iteration");
             // Merge the LangChain stream with subagent event stream
             // This allows both to yield concurrently without polling
             async function* mergeStreams() {
@@ -887,16 +848,20 @@ export class LangchainAgent {
                 }
                 // Start listening for subagent events
                 let subagentPromise = createSubagentEventPromise();
+                // Create the first stream promise
+                let streamPromise = streamIterator.next().then((result) => ({
+                    source: "stream",
+                    value: result.value,
+                    done: result.done ?? false,
+                }));
                 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) {
+                            // Yield the final value if it exists (don't skip the last message)
+                            if (result.value !== undefined) {
+                                yield { source: "stream", value: result.value };
+                            }
                             streamDone = true;
                             // Continue to drain remaining subagent events
                             subagentListenerActive = false;
@@ -907,6 +872,12 @@ export class LangchainAgent {
                             break;
                         }
                         yield { source: "stream", value: result.value };
+                        // Create next stream promise after processing this one
+                        streamPromise = streamIterator.next().then((result) => ({
+                            source: "stream",
+                            value: result.value,
+                            done: result.done ?? false,
+                        }));
                     }
                     else if (result.source === "subagent") {
                         // Subagent event arrived - it's already in the queue
@@ -917,6 +888,7 @@ export class LangchainAgent {
                 }
             }
             // Iterate through the merged stream
+            let messageCount = 0;
             for await (const item of mergeStreams()) {
                 if (item.source === "subagent") {
                     // Yield any queued subagent messages
@@ -925,6 +897,7 @@ export class LangchainAgent {
                 }
                 // Process the stream item
                 const streamItem = item.value;
+                messageCount++;
                 // biome-ignore lint/suspicious/noExplicitAny: LangChain stream items are tuples with dynamic types
                 const [streamMode, chunk] = streamItem;
                 if (streamMode === "updates") {
@@ -1028,11 +1001,10 @@ export class LangchainAgent {
                                     const qHash = hashQuery(toolCall.args.query);
                                     queryToToolCallId.set(qHash, toolCall.id);
                                     activeSubagentToolCalls.add(toolCall.id);
-                                    telemetry.log("info", "✓ Registered subagent query hash mapping", {
-                                        queryHash: qHash,
+                                    telemetry.log("info", "Subagent invoked", {
                                         toolCallId: toolCall.id,
-                                        queryPreview: toolCall.args.query.slice(0, 50),
-                                        timestamp: new Date().toISOString(),
+                                        agentName: agentName,
+                                        sessionId: req.sessionId,
                                     });
                                 }
                                 else {
@@ -1118,30 +1090,12 @@ export class LangchainAgent {
                             turnTokenUsage.totalTokens += messageTokenUsage.totalTokens ?? 0;
                             countedMessageIds.add(aiMessage.id);
                         }
-                        if (messageTokenUsage) {
-                            const contentType = typeof aiMessage.content;
-                            const contentIsArray = Array.isArray(aiMessage.content);
-                            const contentLength = contentIsArray
-                                ? aiMessage.content.length
-                                : typeof aiMessage.content === "string"
-                                    ? aiMessage.content.length
-                                    : -1;
-                            _logger.debug("messageTokenUsage", {
-                                messageTokenUsage,
-                                contentType,
-                                isArray: contentIsArray,
-                                length: contentLength,
-                            });
-                        }
                         // If we have tokenUsage but no content, send a token-only chunk
                         if (messageTokenUsage &&
                             (typeof aiMessage.content === "string"
                                 ? aiMessage.content === ""
                                 : Array.isArray(aiMessage.content) &&
                                     aiMessage.content.length === 0)) {
-                            _logger.debug("sending token-only chunk", {
-                                messageTokenUsage,
-                            });
                             const msgToYield = {
                                 sessionUpdate: "agent_message_chunk",
                                 content: {
@@ -1330,56 +1284,28 @@ export class LangchainAgent {
             yield* yieldPendingSubagentUpdates();
             // Keep polling for subagent messages after stream ends
             // This ensures we capture messages that arrive after LangChain stream completes
-            _logger.info("[SUBAGENT] Starting post-stream polling for subagent messages", {
-                sessionId: req.sessionId,
-                activeSubagentCount: activeSubagentToolCalls.size,
-            });
             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();
+            let iterations = 0;
             while (Date.now() - startTime < maxWaitTime) {
-                // Check if all subagent tool calls have completed
-                if (activeSubagentToolCalls.size > 0 &&
-                    completedSubagentToolCalls.size >= activeSubagentToolCalls.size) {
-                    _logger.info("[SUBAGENT] All subagent tool calls completed", {
-                        sessionId: req.sessionId,
-                        totalSubagents: activeSubagentToolCalls.size,
-                        completedCount: completedSubagentToolCalls.size,
-                    });
-                    break;
-                }
+                iterations++;
                 // Check if there are pending messages
                 if (subagentMessagesQueue.length > 0) {
-                    _logger.info("[SUBAGENT] Found pending messages, yielding", {
-                        sessionId: req.sessionId,
-                        queueLength: subagentMessagesQueue.length,
-                    });
                     yield* yieldPendingSubagentUpdates();
                     lastMessageTime = Date.now();
                 }
                 // Stop if we haven't seen messages for maxIdleTime (fallback for no subagents)
                 if (Date.now() - lastMessageTime > maxIdleTime) {
-                    _logger.info("[SUBAGENT] No new messages for 5 seconds, finishing", {
-                        sessionId: req.sessionId,
-                        hasActiveSubagents: activeSubagentToolCalls.size > 0,
-                    });
                     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();
-            _logger.info("[SUBAGENT] Finished post-stream polling", {
-                sessionId: req.sessionId,
-            });
             // Now that content streaming is complete, yield all buffered tool call notifications
             yield* flushPendingToolCalls();
             // Clean up subagent event listener from invocation-scoped emitter
@@ -1435,7 +1361,7 @@ const makeMcpToolsClient = async (mcpConfigs) => {
     const mcpServers = await Promise.all((mcpConfigs ?? []).map(async (config) => {
         if (typeof config === "string") {
             // String configs use the centralized MCP proxy with auth
-            const shedAuth = await ensureAuthenticated();
+            const shedAuth = await getShedAuth();
             if (!shedAuth) {
                 throw new Error("Not logged in. Run 'town login' or set SHED_API_KEY to use cloud MCP servers.");
             }

package/dist/runner/langchain/model-factory.d.ts

@@ -15,7 +15,7 @@ import type { BaseChatModel } from "@langchain/core/language_models/chat_models"
  * - Provider prefix: "google_vertexai:gemini-2.0-flash", "google_genai:gemini-2.0-flash", "anthropic:claude-3-5-sonnet"
  * - Proxied: "town-claude-sonnet-4-5-20250929" (uses TOWN_SHED_URL or defaults to localhost:3000)
  */
-export declare function createModelFromString(modelString: string): BaseChatModel;
+export declare function createModelFromString(modelString: string): Promise<BaseChatModel>;
 /**
  * Helper function to detect if a model string is for a specific provider
  */

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

@@ -22,11 +22,11 @@ const logger = createLogger("model-factory");
  * - Provider prefix: "google_vertexai:gemini-2.0-flash", "google_genai:gemini-2.0-flash", "anthropic:claude-3-5-sonnet"
  * - Proxied: "town-claude-sonnet-4-5-20250929" (uses TOWN_SHED_URL or defaults to localhost:3000)
  */
-export function createModelFromString(modelString) {
+export async function createModelFromString(modelString) {
     // Check for town- prefix for proxied models via shed
     if (modelString.startsWith("town-")) {
         const actualModel = modelString.slice(5); // strip "town-"
-        const shedAuth = getShedAuth();
+        const shedAuth = await getShedAuth();
         if (!shedAuth) {
             throw new Error("Not logged in. Run 'town login' or set SHED_API_KEY.");
         }