@townco/agent 0.1.55 → 0.1.57

package/dist/runner/langchain/index.js

@@ -1,5 +1,6 @@
 import { MultiServerMCPClient } from "@langchain/mcp-adapters";
 import { context, propagation, trace } from "@opentelemetry/api";
+import { loadAuthCredentials } from "@townco/core/auth";
 import { AIMessageChunk, createAgent, ToolMessage, tool, } from "langchain";
 import { z } from "zod";
 import { SUBAGENT_MODE_KEY } from "../../acp-server/adapter";
@@ -8,9 +9,11 @@ import { telemetry } from "../../telemetry/index.js";
 import { loadCustomToolModule, } from "../tool-loader.js";
 import { createModelFromString, detectProvider } from "./model-factory.js";
 import { makeOtelCallbacks } from "./otel-callbacks.js";
+import { makeBrowserTools } from "./tools/browser";
 import { makeFilesystemTools } from "./tools/filesystem";
 import { makeGenerateImageTool } from "./tools/generate_image";
 import { SUBAGENT_TOOL_NAME } from "./tools/subagent";
+import { hashQuery, queryToToolCallId, subagentEvents, } from "./tools/subagent-connections";
 import { TODO_WRITE_TOOL_NAME, todoWrite } from "./tools/todo";
 import { makeWebSearchTools } from "./tools/web_search";
 const _logger = createLogger("agent-runner");
@@ -29,6 +32,7 @@ export const TOOL_REGISTRY = {
     web_search: () => makeWebSearchTools(),
     filesystem: () => makeFilesystemTools(process.cwd()),
     generate_image: () => makeGenerateImageTool(),
+    browser: () => makeBrowserTools(),
 };
 // ============================================================================
 // Custom tool loading
@@ -78,11 +82,64 @@ export class LangchainAgent {
         const countedMessageIds = new Set();
         // Track tool calls for which we've emitted preliminary notifications (from early tool_use blocks)
         const preliminaryToolCallIds = new Set();
+        // Set session_id as a base attribute so all spans in this invocation include it
+        telemetry.setBaseAttributes({
+            "agent.session_id": req.sessionId,
+        });
+        const subagentUpdateQueue = [];
+        let subagentUpdateResolver = null;
+        // 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);
+        // Helper to get next subagent update (returns immediately if queued, otherwise waits)
+        const waitForSubagentUpdate = () => {
+            if (subagentUpdateQueue.length > 0) {
+                return Promise.resolve(subagentUpdateQueue.shift());
+            }
+            return new Promise((resolve) => {
+                subagentUpdateResolver = resolve;
+            });
+        };
+        // Helper to check and yield all pending subagent updates
+        async function* yieldPendingSubagentUpdates() {
+            while (subagentUpdateQueue.length > 0) {
+                const update = subagentUpdateQueue.shift();
+                _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,
+                    },
+                };
+            }
+        }
         // Start telemetry span for entire invocation
         const invocationSpan = telemetry.startSpan("agent.invoke", {
             "agent.model": this.definition.model,
             "agent.subagent": meta?.[SUBAGENT_MODE_KEY] === true,
-            "agent.session_id": req.sessionId,
             "agent.message_id": req.messageId,
         }, parentContext);
         // Create a context with the invocation span as active
@@ -294,7 +351,7 @@ export class LangchainAgent {
                 : wrappedTools;
             // Wrap tools with tracing so each tool executes within its own span context.
             // This ensures subagent spans are children of the Task tool span.
-            const finalTools = filteredTools.map((t) => wrapToolWithTracing(t, req.sessionId));
+            const finalTools = filteredTools.map((t) => wrapToolWithTracing(t));
             // Create the model instance using the factory
             // This detects the provider from the model string:
             // - "gemini-2.0-flash" → Google Generative AI
@@ -419,7 +476,53 @@ export class LangchainAgent {
                 recursionLimit: 200,
                 callbacks: [otelCallbacks],
             }));
-            for await (const streamItem of await stream) {
+            // 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,
+                    });
+                    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;
+                }
+                // Also yield any queued subagent updates before processing stream item
+                yield* yieldPendingSubagentUpdates();
                 const [streamMode, chunk] = streamItem;
                 if (streamMode === "updates") {
                     const updatesChunk = modelRequestSchema.safeParse(chunk);
@@ -511,6 +614,17 @@ export class LangchainAgent {
                                 const subagentConfigs = taskTool?.subagentConfigs;
                                 const subagentConfig = subagentConfigs?.find((config) => config.agentName === agentName);
                                 prettyName = subagentConfig?.displayName ?? agentName;
+                                // Register query hash -> toolCallId mapping for subagent connection info
+                                if ("query" in toolCall.args &&
+                                    typeof toolCall.args.query === "string") {
+                                    const qHash = hashQuery(toolCall.args.query);
+                                    queryToToolCallId.set(qHash, toolCall.id);
+                                    telemetry.log("info", "Registered subagent query hash mapping", {
+                                        queryHash: qHash,
+                                        toolCallId: toolCall.id,
+                                        queryPreview: toolCall.args.query.slice(0, 50),
+                                    });
+                                }
                             }
                             // Check if we already emitted a preliminary notification from early tool_use block
                             const alreadyEmittedPreliminary = preliminaryToolCallIds.has(toolCall.id);
@@ -744,6 +858,16 @@ export class LangchainAgent {
                 else {
                     throw new Error(`Unhandled stream mode: ${streamMode}`);
                 }
+                // Yield any pending subagent connection updates
+                yield* yieldPendingSubagentUpdates();
+            }
+            // Yield any remaining pending subagent connection updates after stream ends
+            yield* yieldPendingSubagentUpdates();
+            // Clean up subagent connection listener
+            subagentEvents.off("connection", onSubagentConnection);
+            // Cancel any pending wait
+            if (subagentUpdateResolver) {
+                subagentUpdateResolver = null;
             }
             // Log successful completion
             telemetry.log("info", "Agent invocation completed", {
@@ -758,6 +882,8 @@ export class LangchainAgent {
             };
         }
         catch (error) {
+            // Clean up subagent connection listener on error
+            subagentEvents.off("connection", onSubagentConnection);
             // Log error and end span with error status
             telemetry.log("error", "Agent invocation failed", {
                 error: error instanceof Error ? error.message : String(error),
@@ -776,12 +902,19 @@ const modelRequestSchema = z.object({
 const makeMcpToolsClient = (mcpConfigs) => {
     const mcpServers = mcpConfigs?.map((config) => {
         if (typeof config === "string") {
-            // Default to localhost:3000/mcp_proxy if not specified
-            const proxyUrl = process.env.MCP_PROXY_URL || "http://localhost:3000/mcp_proxy";
+            // String configs use the centralized MCP proxy with auth
+            const credentials = loadAuthCredentials();
+            if (!credentials) {
+                throw new Error("Not logged in. Run 'town login' first to use cloud MCP servers.");
+            }
+            const proxyUrl = process.env.MCP_PROXY_URL ?? `${credentials.shed_url}/mcp_proxy`;
             return [
                 config,
                 {
                     url: `${proxyUrl}?server=${config}`,
+                    headers: {
+                        Authorization: `Bearer ${credentials.access_token}`,
+                    },
                 },
             ];
         }
@@ -874,13 +1007,12 @@ export { makeSubagentsTool } from "./tools/subagent.js";
  * so any child operations (like subagent spawning) become children
  * of the tool span rather than the parent invocation span.
  */
-function wrapToolWithTracing(originalTool, sessionId) {
+function wrapToolWithTracing(originalTool) {
     const wrappedFunc = async (input) => {
         const toolInputJson = JSON.stringify(input);
         const toolSpan = telemetry.startSpan("agent.tool_call", {
             "tool.name": originalTool.name,
             "tool.input": toolInputJson,
-            "agent.session_id": sessionId,
         });
         // Create a context with the tool span as active
         const spanContext = toolSpan

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

@@ -4,6 +4,7 @@ import type { BaseChatModel } from "@langchain/core/language_models/chat_models"
  * LangChain chat model instance.
  *
  * Detection logic:
+ * - If model starts with "town-" → Proxied via shed (strips prefix, uses TOWN_SHED_URL)
  * - If model starts with "vertex-" → Google Vertex AI (strips prefix)
  * - If model contains "gemini" (unprefixed) → Google Generative AI
  * - If model contains "gpt" → OpenAI (future support)
@@ -12,6 +13,7 @@ import type { BaseChatModel } from "@langchain/core/language_models/chat_models"
  * Supported formats:
  * - Direct model name: "gemini-2.0-flash", "vertex-gemini-2.0-flash", "claude-sonnet-4-5-20250929"
  * - 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;
 /**

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

@@ -1,6 +1,7 @@
 import { ChatAnthropic } from "@langchain/anthropic";
 import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
 import { ChatVertexAI } from "@langchain/google-vertexai";
+import { loadAuthCredentials } from "@townco/core/auth";
 import { createLogger } from "../../logger.js";
 const logger = createLogger("model-factory");
 /**
@@ -8,6 +9,7 @@ const logger = createLogger("model-factory");
  * LangChain chat model instance.
  *
  * Detection logic:
+ * - If model starts with "town-" → Proxied via shed (strips prefix, uses TOWN_SHED_URL)
  * - If model starts with "vertex-" → Google Vertex AI (strips prefix)
  * - If model contains "gemini" (unprefixed) → Google Generative AI
  * - If model contains "gpt" → OpenAI (future support)
@@ -16,8 +18,25 @@ const logger = createLogger("model-factory");
  * Supported formats:
  * - Direct model name: "gemini-2.0-flash", "vertex-gemini-2.0-flash", "claude-sonnet-4-5-20250929"
  * - 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) {
+    // Check for town- prefix for proxied models via shed
+    if (modelString.startsWith("town-")) {
+        const actualModel = modelString.slice(5); // strip "town-"
+        const credentials = loadAuthCredentials();
+        if (!credentials) {
+            throw new Error("Not logged in. Run 'town login' first.");
+        }
+        const shedUrl = credentials.shed_url ??
+            process.env.TOWN_SHED_URL ??
+            "http://localhost:3000";
+        return new ChatAnthropic({
+            model: actualModel,
+            anthropicApiUrl: `${shedUrl}/api/anthropic`,
+            apiKey: credentials.access_token,
+        });
+    }
     // Check if the model string uses provider prefix format
     const parts = modelString.split(":", 2);
     const maybeProvider = parts[0];

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

@@ -0,0 +1,100 @@
+import { z } from "zod";
+interface BrowserNavigateResult {
+    success: boolean;
+    url?: string;
+    title?: string;
+    liveViewUrl?: string;
+    error?: string;
+}
+interface BrowserScreenshotResult {
+    success: boolean;
+    screenshotPath?: string;
+    liveViewUrl?: string;
+    error?: string;
+}
+interface BrowserExtractResult {
+    success: boolean;
+    content?: string;
+    url?: string;
+    title?: string;
+    liveViewUrl?: string;
+    error?: string;
+}
+interface BrowserClickResult {
+    success: boolean;
+    message?: string;
+    liveViewUrl?: string;
+    error?: string;
+}
+interface BrowserTypeResult {
+    success: boolean;
+    message?: string;
+    liveViewUrl?: string;
+    error?: string;
+}
+interface BrowserCloseResult {
+    success: boolean;
+    message?: string;
+    error?: string;
+}
+export declare function makeBrowserTools(): readonly [import("langchain").DynamicStructuredTool<z.ZodObject<{
+    url: z.ZodString;
+    waitUntil: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        load: "load";
+        domcontentloaded: "domcontentloaded";
+        networkidle: "networkidle";
+    }>>>;
+}, z.core.$strip>, {
+    url: string;
+    waitUntil: "load" | "domcontentloaded" | "networkidle";
+}, {
+    url: string;
+    waitUntil?: "load" | "domcontentloaded" | "networkidle" | undefined;
+}, BrowserNavigateResult>, import("langchain").DynamicStructuredTool<z.ZodObject<{
+    fullPage: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    selector: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    fullPage: boolean;
+    selector?: string | undefined;
+}, {
+    fullPage?: boolean | undefined;
+    selector?: string | undefined;
+}, BrowserScreenshotResult>, import("langchain").DynamicStructuredTool<z.ZodObject<{
+    selector: z.ZodOptional<z.ZodString>;
+    extractType: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        text: "text";
+        html: "html";
+    }>>>;
+}, z.core.$strip>, {
+    extractType: "text" | "html";
+    selector?: string | undefined;
+}, {
+    selector?: string | undefined;
+    extractType?: "text" | "html" | undefined;
+}, BrowserExtractResult>, import("langchain").DynamicStructuredTool<z.ZodObject<{
+    selector: z.ZodString;
+    button: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        left: "left";
+        right: "right";
+        middle: "middle";
+    }>>>;
+}, z.core.$strip>, {
+    selector: string;
+    button: "left" | "right" | "middle";
+}, {
+    selector: string;
+    button?: "left" | "right" | "middle" | undefined;
+}, BrowserClickResult>, import("langchain").DynamicStructuredTool<z.ZodObject<{
+    selector: z.ZodString;
+    text: z.ZodString;
+    pressEnter: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>, {
+    selector: string;
+    text: string;
+    pressEnter: boolean;
+}, {
+    selector: string;
+    text: string;
+    pressEnter?: boolean | undefined;
+}, BrowserTypeResult>, import("langchain").DynamicStructuredTool<z.ZodObject<{}, z.core.$strip>, Record<string, never>, Record<string, never>, BrowserCloseResult>];
+export {};