@townco/agent 0.1.72 → 0.1.74

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

@@ -7,7 +7,7 @@ import { createLogger as coreCreateLogger } from "@townco/core";
 import { z } from "zod";
 import { SUBAGENT_MODE_KEY } from "../../../acp-server/adapter.js";
 import { findAvailablePort } from "./port-utils.js";
-import { emitSubagentConnection, hashQuery } from "./subagent-connections.js";
+import { emitSubagentConnection, emitSubagentMessages, hashQuery, } from "./subagent-connections.js";
 /**
  * Name of the Task tool created by makeSubagentsTool
  */
@@ -317,6 +317,15 @@ async function querySubagent(agentName, agentPath, agentWorkingDirectory, query)
         // Step 3: Connect to SSE for receiving streaming responses
         sseAbortController = new AbortController();
         let responseText = "";
+        // Track full message structure for session storage
+        const currentMessage = {
+            id: `subagent-${Date.now()}`,
+            content: "",
+            contentBlocks: [],
+            toolCalls: [],
+        };
+        // Map of tool call IDs to their indices in toolCalls array
+        const toolCallMap = new Map();
         const ssePromise = (async () => {
             const sseResponse = await fetch(`${baseUrl}/events`, {
                 headers: { "X-Session-ID": sessionId },
@@ -342,18 +351,63 @@ async function querySubagent(agentName, agentPath, agentWorkingDirectory, query)
                             continue;
                         try {
                             const message = JSON.parse(data);
-                            // Handle session/update notifications for agent_message_chunk
-                            if (message.method === "session/update" &&
-                                message.params?.update?.sessionUpdate === "agent_message_chunk") {
-                                const content = message.params.update.content;
+                            const update = message.params?.update;
+                            if (message.method !== "session/update" || !update)
+                                continue;
+                            // Handle agent_message_chunk - accumulate text
+                            if (update.sessionUpdate === "agent_message_chunk") {
+                                const content = update.content;
                                 if (content?.type === "text" &&
                                     typeof content.text === "string") {
                                     responseText += content.text;
+                                    currentMessage.content += content.text;
+                                    // Add to contentBlocks - append to last text block or create new one
+                                    const lastBlock = currentMessage.contentBlocks[currentMessage.contentBlocks.length - 1];
+                                    if (lastBlock && lastBlock.type === "text") {
+                                        lastBlock.text += content.text;
+                                    }
+                                    else {
+                                        currentMessage.contentBlocks.push({
+                                            type: "text",
+                                            text: content.text,
+                                        });
+                                    }
                                 }
                             }
-                            // Reset on tool_call (marks new message boundary)
-                            if (message.params?.update?.sessionUpdate === "tool_call") {
-                                responseText = "";
+                            // Handle tool_call - track new tool calls
+                            if (update.sessionUpdate === "tool_call" && update.toolCallId) {
+                                const toolCall = {
+                                    id: update.toolCallId,
+                                    title: update.title || "Tool call",
+                                    prettyName: update._meta?.prettyName,
+                                    icon: update._meta?.icon,
+                                    status: update.status || "pending",
+                                };
+                                currentMessage.toolCalls.push(toolCall);
+                                toolCallMap.set(update.toolCallId, currentMessage.toolCalls.length - 1);
+                                // Add to contentBlocks for interleaved display
+                                currentMessage.contentBlocks.push({
+                                    type: "tool_call",
+                                    toolCall,
+                                });
+                            }
+                            // Handle tool_call_update - update existing tool call status
+                            if (update.sessionUpdate === "tool_call_update" &&
+                                update.toolCallId) {
+                                const idx = toolCallMap.get(update.toolCallId);
+                                if (idx !== undefined && currentMessage.toolCalls[idx]) {
+                                    if (update.status) {
+                                        currentMessage.toolCalls[idx].status =
+                                            update.status;
+                                    }
+                                    // Also update in contentBlocks
+                                    const block = currentMessage.contentBlocks.find((b) => b.type === "tool_call" &&
+                                        b.toolCall.id === update.toolCallId);
+                                    if (block && update.status) {
+                                        block.toolCall.status =
+                                            update.status;
+                                    }
+                                }
                             }
                         }
                         catch {
@@ -404,6 +458,10 @@ async function querySubagent(agentName, agentPath, agentWorkingDirectory, query)
             ssePromise.catch(() => { }), // Ignore abort errors
             new Promise((r) => setTimeout(r, 1000)),
         ]);
+        // Emit accumulated messages for session storage
+        if (currentMessage.content || currentMessage.toolCalls.length > 0) {
+            emitSubagentMessages(queryHash, [currentMessage]);
+        }
         return responseText;
     }
     finally {

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

@@ -78,3 +78,7 @@ When in doubt, use this tool. Being proactive with task management demonstrates
 });
 todoWrite.prettyName = "Todo List";
 todoWrite.icon = "CheckSquare";
+todoWrite.verbiage = {
+    active: "Updating to-do's",
+    past: "Updated to-do's",
+};

package/dist/runner/langchain/tools/web_search.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+/** Create web search tools using direct EXA_API_KEY */
 export declare function makeWebSearchTools(): readonly [import("langchain").DynamicStructuredTool<z.ZodObject<{
     query: z.ZodString;
 }, z.core.$strip>, {
@@ -21,3 +22,26 @@ export declare function makeWebSearchTools(): readonly [import("langchain").Dyna
     url: string;
     prompt: string;
 }, string>];
+/** Create web search tools using Town proxy */
+export declare function makeTownWebSearchTools(): readonly [import("langchain").DynamicStructuredTool<z.ZodObject<{
+    query: z.ZodString;
+}, z.core.$strip>, {
+    query: string;
+}, {
+    query: string;
+}, string | import("exa-js").SearchResponse<{
+    numResults: number;
+    type: "auto";
+    text: {
+        maxCharacters: number;
+    };
+}>>, import("langchain").DynamicStructuredTool<z.ZodObject<{
+    url: z.ZodString;
+    prompt: z.ZodString;
+}, z.core.$strip>, {
+    url: string;
+    prompt: string;
+}, {
+    url: string;
+    prompt: string;
+}, string>];

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

@@ -1,24 +1,38 @@
 import Anthropic from "@anthropic-ai/sdk";
+import { getShedAuth } from "@townco/core/auth";
 import Exa from "exa-js";
 import { tool } from "langchain";
 import { z } from "zod";
-let _exaClient = null;
-function getExaClient() {
-    if (_exaClient) {
-        return _exaClient;
+let _directExaClient = null;
+let _townExaClient = null;
+/** Get Exa client using direct EXA_API_KEY environment variable */
+function getDirectExaClient() {
+    if (_directExaClient) {
+        return _directExaClient;
     }
     const apiKey = process.env.EXA_API_KEY;
     if (!apiKey) {
         throw new Error("EXA_API_KEY environment variable is required to use the web_search tool. " +
             "Please set it to your Exa API key from https://exa.ai");
     }
-    _exaClient = new Exa(apiKey);
-    return _exaClient;
+    _directExaClient = new Exa(apiKey);
+    return _directExaClient;
 }
-export function makeWebSearchTools() {
-    // WebSearch tool - search the web
+/** Get Exa client using Town proxy with authenticated credentials */
+function getTownExaClient() {
+    if (_townExaClient) {
+        return _townExaClient;
+    }
+    const shedAuth = getShedAuth();
+    if (!shedAuth) {
+        throw new Error("Not logged in. Run 'town login' or set SHED_API_KEY to use the town_web_search tool.");
+    }
+    _townExaClient = new Exa(shedAuth.accessToken, `${shedAuth.shedUrl}/api/exa`);
+    return _townExaClient;
+}
+function makeWebSearchToolsInternal(getClient) {
     const webSearch = tool(async ({ query }) => {
-        const client = getExaClient();
+        const client = getClient();
         const result = await client.searchAndContents(query, {
             numResults: 5,
             type: "auto",
@@ -48,9 +62,13 @@ export function makeWebSearchTools() {
     });
     webSearch.prettyName = "Web Search";
     webSearch.icon = "Globe";
-    // WebFetch tool - get contents of specific URLs
+    webSearch.verbiage = {
+        active: "Searching the web for {query}",
+        past: "Searched the web for {query}",
+        paramKey: "query",
+    };
     const webFetch = tool(async ({ url, prompt }) => {
-        const client = getExaClient();
+        const client = getClient();
         try {
             const result = await client.getContents([url], {
                 text: true,
@@ -122,8 +140,21 @@ export function makeWebSearchTools() {
     });
     webFetch.prettyName = "Web Fetch";
     webFetch.icon = "Link";
+    webFetch.verbiage = {
+        active: "Fetching {url}",
+        past: "Fetched {url}",
+        paramKey: "url",
+    };
     return [webSearch, webFetch];
 }
+/** Create web search tools using direct EXA_API_KEY */
+export function makeWebSearchTools() {
+    return makeWebSearchToolsInternal(getDirectExaClient);
+}
+/** Create web search tools using Town proxy */
+export function makeTownWebSearchTools() {
+    return makeWebSearchToolsInternal(getTownExaClient);
+}
 function buildWebFetchUserMessage(pageContent, prompt) {
     return `Web page content:
 ---

package/dist/runner/tool-loader.d.ts

@@ -6,6 +6,11 @@ export type CustomToolModule = {
     description: string;
     prettyName?: string;
     icon?: string;
+    verbiage?: {
+        active: string;
+        past: string;
+        paramKey?: string;
+    };
 };
 export type ResolvedCustomTool = {
     fn: (input: unknown) => unknown | Promise<unknown>;
@@ -14,5 +19,10 @@ export type ResolvedCustomTool = {
     description: string;
     prettyName?: string;
     icon?: string;
+    verbiage?: {
+        active: string;
+        past: string;
+        paramKey?: string;
+    };
 };
 export declare function loadCustomToolModule(modulePath: string): Promise<ResolvedCustomTool>;

package/dist/runner/tool-loader.js

@@ -37,6 +37,7 @@ export async function loadCustomToolModule(modulePath) {
         description: mod.description,
         ...(mod.prettyName && { prettyName: mod.prettyName }),
         ...(mod.icon && { icon: mod.icon }),
+        ...(mod.verbiage && { verbiage: mod.verbiage }),
     };
     // Cache the resolved tool
     customToolCache.set(modulePath, resolved);

package/dist/runner/tools.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 /** Built-in tool types. */
-export declare const zBuiltInToolType: z.ZodUnion<readonly [z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">, z.ZodLiteral<"filesystem">, z.ZodLiteral<"generate_image">, z.ZodLiteral<"browser">]>;
+export declare const zBuiltInToolType: z.ZodUnion<readonly [z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">, z.ZodLiteral<"town_web_search">, z.ZodLiteral<"filesystem">, z.ZodLiteral<"generate_image">, z.ZodLiteral<"browser">]>;
 /** Subagent configuration schema for Task tools. */
 export declare const zSubagentConfig: z.ZodObject<{
     agentName: z.ZodString;
@@ -23,7 +23,7 @@ declare const zDirectTool: z.ZodObject<{
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 /** Tool type - can be a built-in tool string or custom tool object. */
-export declare const zToolType: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">, z.ZodLiteral<"filesystem">, z.ZodLiteral<"generate_image">, z.ZodLiteral<"browser">]>, z.ZodObject<{
+export declare const zToolType: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">, z.ZodLiteral<"town_web_search">, z.ZodLiteral<"filesystem">, z.ZodLiteral<"generate_image">, z.ZodLiteral<"browser">]>, z.ZodObject<{
     type: z.ZodLiteral<"custom">;
     modulePath: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{

package/dist/runner/tools.js

@@ -4,6 +4,7 @@ export const zBuiltInToolType = z.union([
     z.literal("todo_write"),
     z.literal("get_weather"),
     z.literal("web_search"),
+    z.literal("town_web_search"),
     z.literal("filesystem"),
     z.literal("generate_image"),
     z.literal("browser"),

package/dist/telemetry/index.d.ts

@@ -28,6 +28,11 @@ declare class AgentTelemetry {
      * @param attributes - Attributes to merge with existing base attributes
      */
     setBaseAttributes(attributes: Record<string, string | number>): void;
+    /**
+     * Remove a base attribute
+     * @param key - Attribute key to remove
+     */
+    clearBaseAttribute(key: string): void;
     /**
      * Start a new span
      * @param name - Span name

package/dist/telemetry/index.js

@@ -40,6 +40,14 @@ class AgentTelemetry {
             ...attributes,
         };
     }
+    /**
+     * Remove a base attribute
+     * @param key - Attribute key to remove
+     */
+    clearBaseAttribute(key) {
+        const { [key]: _, ...rest } = this.baseAttributes;
+        this.baseAttributes = rest;
+    }
     /**
      * Start a new span
      * @param name - Span name

package/dist/telemetry/setup.js

@@ -68,10 +68,12 @@ export function initializeOpenTelemetry(options = {}) {
                     // false "Request timed out" errors. The export usually succeeds anyway.
                     // Only log non-timeout errors as actual errors.
                     const errorMsg = result.error?.message ?? "";
-                    if (errorMsg.includes("timed out")) {
+                    if (errorMsg.includes("timed out") ||
+                        errorMsg.includes("Request timed out")) {
                         if (debug) {
-                            console.log(`⚠️  Export reported timeout (Bun http bug - data likely sent successfully)`);
+                            console.log(`⚠️  Export reported timeout (Bun http bug - data successfully sent)`);
                         }
+                        // Don't log timeout errors at all - they're false positives
                     }
                     else {
                         console.error(`❌ Failed to export spans:`, result.error);
@@ -141,7 +143,12 @@ export function initializeOpenTelemetry(options = {}) {
             }
         }
         catch (error) {
-            console.error("Error flushing telemetry:", error);
+            // Filter out Bun HTTP timeout errors - they're false positives
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            if (!errorMsg.includes("timed out") &&
+                !errorMsg.includes("Request timed out")) {
+                console.error("Error flushing telemetry:", error);
+            }
         }
     };
     return { provider, loggerProvider, shutdown };