@townco/agent 0.1.114 → 0.1.115

package/dist/acp-server/adapter.js

@@ -879,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,
                     });
@@ -1490,17 +1492,43 @@ export class AgentAcpAdapter {
                             toolCallBlock.subagentSessionId = meta.subagentSessionId;
                         }
                         if (meta?.subagentMessages) {
+                            logger.info("[SUBAGENT-ADAPTER] Updating toolCallBlock with subagent messages", {
+                                sessionId: params.sessionId,
+                                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-ADAPTER] ToolCallBlock updated", {
+                                sessionId: params.sessionId,
+                                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) {
+                        const subagentCompletedValue = updateMsg._meta
+                            ?.subagentCompleted;
+                        logger.info("[DEBUG] Adapter forwarding tool_call_update to client", {
+                            toolCallId: updateMsg.toolCallId,
+                            hasSubagentCompleted: subagentCompletedValue !== undefined,
+                            subagentCompleted: subagentCompletedValue,
+                            metaKeys: Object.keys(updateMsg._meta),
+                        });
                         this.connection.sessionUpdate({
                             sessionId: params.sessionId,
                             update: {
                                 sessionUpdate: "tool_call_update",
                                 toolCallId: updateMsg.toolCallId,
                                 status: updateMsg.status,
+                                subagentCompleted: subagentCompletedValue,
                                 _meta: updateMsg._meta,
                             },
                         });
@@ -1823,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",
@@ -1990,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();
         }
@@ -2067,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,
@@ -2076,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,21 +160,9 @@ 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);
         };
@@ -185,17 +173,13 @@ export class LangchainAgent {
                 const messagesUpdate = subagentMessagesQueue.shift();
                 if (!messagesUpdate)
                     continue;
-                _logger.debug("[SUBAGENT] Yielding queued subagent messages update", {
-                    sessionId: req.sessionId,
-                    toolCallId: messagesUpdate.toolCallId,
-                    messageCount: messagesUpdate.messages.length,
-                });
                 const updateToYield = {
                     sessionUpdate: "tool_call_update",
                     toolCallId: messagesUpdate.toolCallId,
                     _meta: {
                         messageId: req.messageId,
                         subagentMessages: messagesUpdate.messages,
+                        subagentCompleted: messagesUpdate.completed,
                     },
                 };
                 yield updateToYield;
@@ -626,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,
@@ -840,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() {
@@ -870,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;
@@ -890,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
@@ -900,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
@@ -908,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") {
@@ -1011,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 {
@@ -1101,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: {
@@ -1318,12 +1289,9 @@ export class LangchainAgent {
             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) {
-                    break;
-                }
+                iterations++;
                 // Check if there are pending messages
                 if (subagentMessagesQueue.length > 0) {
                     yield* yieldPendingSubagentUpdates();
@@ -1336,11 +1304,6 @@ export class LangchainAgent {
                 // 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
@@ -1398,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.");
         }

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

@@ -22,7 +22,7 @@ export async function getTownE2BApiKey() {
         return _apiKeyFetchPromise;
     }
     _apiKeyFetchPromise = (async () => {
-        const shedAuth = getShedAuth();
+        const shedAuth = await getShedAuth();
         if (!shedAuth) {
             throw new Error("Not logged in. Run 'town login' or set SHED_API_KEY to use the code_sandbox tools.");
         }
@@ -329,7 +329,7 @@ function makeE2BToolsInternal(getSandbox) {
             const fileBuffer = Buffer.from(result.stdout.trim(), "base64");
             await fs.writeFile(outputPath, fileBuffer);
             // Step 2: Upload to Supabase Storage
-            const shedAuth = getShedAuth();
+            const shedAuth = await getShedAuth();
             if (!shedAuth) {
                 // Fallback to local URL if not authenticated
                 const port = process.env.PORT || "3100";

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

@@ -37,16 +37,6 @@ export function emitSubagentMessages(queryHash, messages, completed = false) {
         return;
     }
     if (toolCallId) {
-        const firstMessage = messages[0];
-        logger.info("✓ Emitting subagent messages for live streaming", {
-            queryHash,
-            toolCallId,
-            messageCount: messages.length,
-            hasContent: firstMessage ? firstMessage.content.length > 0 : false,
-            hasToolCalls: firstMessage ? firstMessage.toolCalls.length > 0 : false,
-            completed,
-            invocationId: invocationCtx.invocationId,
-        });
         // Emit to the parent's invocation-scoped EventEmitter
         invocationCtx.subagentEventEmitter.emit("messages", {
             toolCallId,

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

@@ -3,11 +3,13 @@ import * as fs from "node:fs/promises";
 import { mkdir } from "node:fs/promises";
 import * as path from "node:path";
 import { context, propagation, trace } from "@opentelemetry/api";
+import { createLogger } from "@townco/core";
 import { z } from "zod";
 import { SUBAGENT_MODE_KEY, } from "../../../acp-server/adapter.js";
 import { makeRunnerFromDefinition } from "../../index.js";
 import { bindGeneratorToSessionContext, getAbortSignal, } from "../../session-context.js";
 import { emitSubagentMessages, hashQuery, } from "./subagent-connections.js";
+const logger = createLogger("subagent-tool", "debug");
 /**
  * Name of the Task tool created by makeSubagentsTool
  */
@@ -217,6 +219,11 @@ async function querySubagent(agentName, agentPath, agentWorkingDirectory, query)
     };
     const toolCallMap = new Map();
     const queryHash = hashQuery(query);
+    logger.info("[DEBUG] Starting subagent generator loop", {
+        agentName,
+        queryHash,
+        sessionId: subagentSessionId,
+    });
     try {
         for await (const update of generator) {
             let shouldEmit = false;
@@ -291,23 +298,60 @@ async function querySubagent(agentName, agentPath, agentWorkingDirectory, query)
             }
             // Emit incremental update to parent (for live streaming)
             if (shouldEmit) {
+                logger.debug("[SUBAGENT-ACCUMULATION] Emitting incremental update", {
+                    agentName,
+                    queryHash,
+                    contentLength: currentMessage.content.length,
+                    contentBlocksCount: currentMessage.contentBlocks.length,
+                    toolCallsCount: currentMessage.toolCalls.length,
+                });
                 emitSubagentMessages(queryHash, [{ ...currentMessage }]);
             }
         }
+        logger.info("[DEBUG] Subagent generator loop finished", {
+            agentName,
+            queryHash,
+            sessionId: subagentSessionId,
+            contentLength: currentMessage.content.length,
+            toolCallCount: currentMessage.toolCalls.length,
+        });
         // Final emit to ensure everything is captured, with completion flag
         if (currentMessage.content || currentMessage.toolCalls.length > 0) {
+            logger.info("[DEBUG] Emitting final completion flag", {
+                agentName,
+                queryHash,
+                sessionId: subagentSessionId,
+                hasContent: true,
+            });
             emitSubagentMessages(queryHash, [currentMessage], true);
         }
         else {
             // Even if no messages, emit completion sentinel
+            logger.info("[DEBUG] Emitting empty completion flag", {
+                agentName,
+                queryHash,
+                sessionId: subagentSessionId,
+                hasContent: false,
+            });
             emitSubagentMessages(queryHash, [], true);
         }
+        logger.info("[DEBUG] Subagent querySubagent() returning result", {
+            agentName,
+            queryHash,
+            sessionId: subagentSessionId,
+        });
         return {
             text: responseText,
             sources: collectedSources,
         };
     }
     catch (error) {
+        logger.info("[DEBUG] Subagent querySubagent() caught error", {
+            agentName,
+            queryHash,
+            sessionId: subagentSessionId,
+            error: error instanceof Error ? error.message : String(error),
+        });
         // Emit completion sentinel even on error to prevent parent from hanging
         emitSubagentMessages(queryHash, [], true);
         if (parentAbortSignal?.aborted) {

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

@@ -19,11 +19,11 @@ function getDirectExaClient() {
     return _directExaClient;
 }
 /** Get Exa client using Town proxy with authenticated credentials */
-function getTownExaClient() {
+async function getTownExaClient() {
     if (_townExaClient) {
         return _townExaClient;
     }
-    const shedAuth = getShedAuth();
+    const shedAuth = await getShedAuth();
     if (!shedAuth) {
         throw new Error("Not logged in. Run 'town login' or set SHED_API_KEY to use the town_web_search tool.");
     }
@@ -43,7 +43,7 @@ export function getWebSearchCitationCounter() {
 }
 function makeWebSearchToolsInternal(getClient) {
     const webSearch = tool(async ({ query }) => {
-        const client = getClient();
+        const client = await getClient();
         const result = await client.searchAndContents(query, {
             numResults: 5,
             type: "auto",
@@ -102,7 +102,7 @@ function makeWebSearchToolsInternal(getClient) {
         paramKey: "query",
     };
     const webFetch = tool(async ({ url, prompt }) => {
-        const client = getClient();
+        const client = await getClient();
         try {
             const result = await client.getContents([url], {
                 text: true,