@townco/agent 0.1.119 → 0.1.120

package/dist/acp-server/http.js

@@ -259,19 +259,7 @@ export function createAcpHttpApp(agent, agentDir, agentName) {
                                 const stream = sseStreams.get(msgSessionId);
                                 if (stream) {
                                     try {
-                                        // Check if this is a sources message
-                                        const isSourcesMsg = rawMsg &&
-                                            typeof rawMsg === "object" &&
-                                            "params" in rawMsg &&
-                                            rawMsg.params?.update?.sessionUpdate === "sources";
-                                        if (isSourcesMsg) {
-                                            const sourcesCount = rawMsg.params?.update?.sources?.length;
-                                            logger.info("🔶 SENDING LARGE SOURCES VIA DIRECT SSE", {
-                                                sessionId: msgSessionId,
-                                                sourcesCount,
-                                                compressedSize,
-                                            });
-                                        }
+                                        // Send large messages directly via SSE
                                         await stream.writeSSE({
                                             event: "message",
                                             data: JSON.stringify(rawMsg),
@@ -811,21 +799,7 @@ export function createAcpHttpApp(agent, agentDir, agentName) {
                         return;
                     }
                 }
-                // Check if this is a sources message and log prominently
-                const isSourcesMsg = json &&
-                    typeof json === "object" &&
-                    "params" in json &&
-                    json.params?.update?.sessionUpdate === "sources";
-                if (isSourcesMsg) {
-                    logger.info("🔶 SENDING SOURCES VIA SSE", {
-                        sessionId,
-                        channel,
-                        sourcesCount: json.params?.update?.sources?.length,
-                    });
-                }
-                else {
-                    logger.trace("Sending SSE message", { sessionId, channel });
-                }
+                logger.trace("Sending SSE message", { sessionId, channel });
                 await stream.writeSSE({
                     event: "message",
                     data: JSON.stringify(json),

package/dist/runner/e2b-sandbox-manager.d.ts

@@ -3,6 +3,9 @@ import type { Sandbox } from "@e2b/code-interpreter";
  * Get or create an E2B sandbox for the current session.
  * Sandboxes are session-scoped and reused across tool calls.
  * Attempts to reconnect to persisted sandboxes when resuming sessions.
+ *
+ * Uses promise caching to prevent race conditions when multiple tools
+ * are called in parallel - all concurrent calls will share the same sandbox.
  */
 export declare function getSessionSandbox(apiKey: string): Promise<Sandbox>;
 /**

package/dist/runner/e2b-sandbox-manager.js

@@ -8,6 +8,8 @@ const sessionSandboxes = new Map();
 const sandboxActivity = new Map();
 // Map sessionId -> cleanup timeout handle
 const cleanupTimeouts = new Map();
+// Map sessionId -> Promise<Sandbox> for in-flight creations (prevents race condition)
+const sandboxCreationPromises = new Map();
 // Sandbox timeout in milliseconds (default: 15 minutes)
 const SANDBOX_TIMEOUT_MS = 15 * 60 * 1000;
 /**
@@ -58,24 +60,10 @@ function getSessionStorage() {
     }
 }
 /**
- * Get or create an E2B sandbox for the current session.
- * Sandboxes are session-scoped and reused across tool calls.
- * Attempts to reconnect to persisted sandboxes when resuming sessions.
+ * Internal function to create or reconnect to a sandbox for a session.
+ * This should only be called from getSessionSandbox() with proper promise tracking.
  */
-export async function getSessionSandbox(apiKey) {
-    if (!hasSessionContext()) {
-        throw new Error("E2B tools require session context");
-    }
-    const { sessionId } = getSessionContext();
-    // Check for existing in-memory sandbox
-    let sandbox = sessionSandboxes.get(sessionId);
-    if (sandbox) {
-        // Update activity timestamp and reschedule cleanup
-        sandboxActivity.set(sessionId, Date.now());
-        rescheduleCleanup(sessionId);
-        logger.debug("Reusing existing sandbox", { sessionId });
-        return sandbox;
-    }
+async function createSandboxForSession(sessionId, apiKey) {
     // Try to reconnect to persisted sandbox
     const storage = getSessionStorage();
     const persistedSandboxId = storage?.getSandboxId(sessionId);
@@ -86,7 +74,9 @@ export async function getSessionSandbox(apiKey) {
         });
         try {
             const { Sandbox: SandboxClass } = await import("@e2b/code-interpreter");
-            sandbox = await SandboxClass.connect(persistedSandboxId, { apiKey });
+            const sandbox = await SandboxClass.connect(persistedSandboxId, {
+                apiKey,
+            });
             logger.info("Successfully reconnected to sandbox", {
                 sessionId,
                 sandboxId: persistedSandboxId,
@@ -131,7 +121,7 @@ export async function getSessionSandbox(apiKey) {
         config.template = templateId;
         logger.info("Using custom E2B template", { templateId });
     }
-    sandbox = await SandboxClass.create(config);
+    const sandbox = await SandboxClass.create(config);
     logger.info("Created new sandbox", {
         sessionId,
         sandboxId: sandbox.sandboxId,
@@ -167,6 +157,45 @@ logging.basicConfig(
     scheduleCleanup(sessionId);
     return sandbox;
 }
+/**
+ * Get or create an E2B sandbox for the current session.
+ * Sandboxes are session-scoped and reused across tool calls.
+ * Attempts to reconnect to persisted sandboxes when resuming sessions.
+ *
+ * Uses promise caching to prevent race conditions when multiple tools
+ * are called in parallel - all concurrent calls will share the same sandbox.
+ */
+export async function getSessionSandbox(apiKey) {
+    if (!hasSessionContext()) {
+        throw new Error("E2B tools require session context");
+    }
+    const { sessionId } = getSessionContext();
+    // Check for existing in-memory sandbox
+    const existingSandbox = sessionSandboxes.get(sessionId);
+    if (existingSandbox) {
+        // Update activity timestamp and reschedule cleanup
+        sandboxActivity.set(sessionId, Date.now());
+        rescheduleCleanup(sessionId);
+        logger.debug("Reusing existing sandbox", { sessionId });
+        return existingSandbox;
+    }
+    // Check for in-flight creation (prevents race condition when tools run in parallel)
+    const existingPromise = sandboxCreationPromises.get(sessionId);
+    if (existingPromise) {
+        logger.debug("Waiting for in-flight sandbox creation", { sessionId });
+        return existingPromise;
+    }
+    // Create new sandbox with promise tracking
+    const creationPromise = createSandboxForSession(sessionId, apiKey);
+    sandboxCreationPromises.set(sessionId, creationPromise);
+    try {
+        const sandbox = await creationPromise;
+        return sandbox;
+    }
+    finally {
+        sandboxCreationPromises.delete(sessionId);
+    }
+}
 /**
  * Explicitly destroy a session's sandbox (called on session end).
  * Also clears the persisted sandboxId from storage.

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

@@ -50,11 +50,11 @@ export declare function makeTownE2BTools(): readonly [import("langchain").Dynami
     sandboxPath: string;
     fileName?: string | undefined;
 }, string>, import("langchain").DynamicStructuredTool<z.ZodObject<{
-    document_id: z.ZodString;
+    document_ids: z.ZodArray<z.ZodString>;
 }, z.core.$strip>, {
-    document_id: string;
+    document_ids: string[];
 }, {
-    document_id: string;
+    document_ids: string[];
 }, string>, import("langchain").DynamicStructuredTool<z.ZodObject<{
     prompt: z.ZodString;
 }, z.core.$strip>, {

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

@@ -403,8 +403,8 @@ function makeE2BToolsInternal(getSandbox) {
     shareSandboxFile.prettyName = "Share from Sandbox";
     // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
     shareSandboxFile.icon = "Share";
-    // Tool 6: Upload Library Document to Sandbox
-    const uploadLibraryDocument = tool(async ({ document_id }) => {
+    // Tool 6: Load Library Documents to Sandbox
+    const loadLibraryDocuments = tool(async ({ document_ids }) => {
         const sandbox = await getSandbox();
         try {
             const libraryApiUrl = process.env.LIBRARY_API_URL;
@@ -412,14 +412,14 @@ function makeE2BToolsInternal(getSandbox) {
             if (!libraryApiUrl || !libraryApiKey) {
                 throw new Error("LIBRARY_API_URL and LIBRARY_API_KEY environment variables are required");
             }
-            const response = await fetch(`${libraryApiUrl}/sandbox/upload_document_to_sandbox`, {
+            const response = await fetch(`${libraryApiUrl}/sandbox/upload_documents_to_sandbox`, {
                 method: "POST",
                 headers: {
                     "Content-Type": "application/json",
                     Authorization: `Bearer ${libraryApiKey}`,
                 },
                 body: JSON.stringify({
-                    document_id,
+                    document_ids,
                     sandbox_id: sandbox.sandboxId,
                 }),
             });
@@ -428,34 +428,50 @@ function makeE2BToolsInternal(getSandbox) {
                 throw new Error(`Library API error: ${response.status} - ${text}`);
             }
             const result = await response.json();
-            return result.path;
+            // Format the response
+            const successfulUploads = result.results
+                .filter((r) => r.status === "success")
+                .map((r) => r.file_path);
+            const failedUploads = result.results
+                .filter((r) => r.status === "error")
+                .map((r) => `${r.document_id}: ${r.error}`);
+            let output = `Status: ${result.status}\n`;
+            output += `Uploaded ${result.successful_uploads}/${result.total_requested} documents\n`;
+            if (successfulUploads.length > 0) {
+                output += `\nSuccessful uploads:\n${successfulUploads.join("\n")}`;
+            }
+            if (failedUploads.length > 0) {
+                output += `\nFailed uploads:\n${failedUploads.join("\n")}`;
+            }
+            return output;
         }
         catch (error) {
-            logger.error("Error uploading library document to sandbox", {
+            logger.error("Error loading library documents to sandbox", {
                 error,
-                document_id,
+                document_ids,
             });
-            return `Error uploading document: ${error instanceof Error ? error.message : String(error)}`;
+            return `Error loading documents: ${error instanceof Error ? error.message : String(error)}`;
         }
     }, {
-        name: "Sandbox_UploadLibraryDocument",
-        description: "Upload a document from the library to the cloud sandbox. " +
-            "Use this to make library documents available for processing in the sandbox environment.",
+        name: "Sandbox_LoadLibraryDocuments",
+        description: "Load multiple documents from the library to the cloud sandbox. " +
+            "Use this to make library documents available for processing in the sandbox environment. " +
+            "Supports batch uploads - some documents may succeed while others fail.",
         schema: z.object({
-            document_id: z
-                .string()
-                .describe("The ID of the document to upload from the library"),
+            document_ids: z
+                .array(z.string())
+                .describe("The IDs of the documents to load from the library"),
         }),
     });
     // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
-    uploadLibraryDocument.prettyName = "Upload Library Document";
+    loadLibraryDocuments.prettyName = "Load Library Documents";
     // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
-    uploadLibraryDocument.icon = "Upload";
+    loadLibraryDocuments.icon = "FileText";
     // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
-    uploadLibraryDocument.verbiage = {
-        active: "Uploading document {document_id}",
-        past: "Uploaded document {document_id}",
-        paramKey: "document_id",
+    loadLibraryDocuments.verbiage = {
+        active: "Loading {document_ids.length} documents",
+        past: "Loaded {document_ids.length} documents",
+        paramKey: "document_ids",
     };
     // Tool 7: Generate Image in Sandbox
     const generateImage = tool(async ({ prompt }) => {
@@ -634,7 +650,7 @@ generateImage();
         readSandboxFile,
         writeSandboxFile,
         shareSandboxFile,
-        uploadLibraryDocument,
+        loadLibraryDocuments,
         generateImage,
     ];
 }

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

@@ -28,6 +28,12 @@ export interface SubagentMessage {
     content: string;
     contentBlocks: SubagentContentBlock[];
     toolCalls: SubagentToolCall[];
+    _meta?: {
+        semanticName?: string;
+        agentDefinitionName?: string;
+        currentActivity?: string;
+        statusGenerating?: boolean;
+    };
 }
 /**
  * Maps query hash to toolCallId.

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

@@ -2,6 +2,7 @@ import * as crypto from "node:crypto";
 import * as fs from "node:fs/promises";
 import { mkdir } from "node:fs/promises";
 import * as path from "node:path";
+import { ChatAnthropic } from "@langchain/anthropic";
 import { context, propagation, trace } from "@opentelemetry/api";
 import { createLogger } from "@townco/core";
 import { z } from "zod";
@@ -10,6 +11,58 @@ 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");
+/**
+ * Generate status message using Haiku (fast, cheap model)
+ */
+async function generateStatusMessage(recentContent, toolCalls) {
+    try {
+        const activeTool = toolCalls.find((tc) => tc.status === "in_progress");
+        const model = new ChatAnthropic({
+            modelName: "claude-3-haiku-20240307",
+            temperature: 0.3,
+            maxTokens: 30,
+        });
+        const prompt = `Summarize the current activity in 5-7 words for a progress indicator:
+
+Recent output: ${recentContent.slice(-500)}
+${activeTool ? `Active tool: ${activeTool.prettyName || activeTool.title}` : ""}
+
+Requirements:
+- Use present continuous tense (e.g., "Searching for...", "Analyzing...")
+- Be specific but concise
+- Focus on user-visible progress
+- Return ONLY the status, no explanation
+
+Status:`;
+        const response = await model.invoke(prompt);
+        const status = response.content.toString().trim().slice(0, 80);
+        return status;
+    }
+    catch (error) {
+        logger.warn("Failed to generate status message", { error });
+        return extractHeuristicStatus(recentContent, toolCalls);
+    }
+}
+/**
+ * Heuristic status extraction (fallback when LLM fails)
+ */
+function extractHeuristicStatus(content, toolCalls) {
+    // Priority 1: Active tool
+    const activeTool = toolCalls.find((tc) => tc.status === "in_progress");
+    if (activeTool) {
+        return `${activeTool.prettyName || activeTool.title}...`;
+    }
+    // Priority 2: First complete sentence from recent content
+    if (content.length > 50) {
+        const lastAdded = content.slice(-200);
+        const firstSentence = lastAdded.match(/[^.!?]+[.!?]/)?.[0];
+        if (firstSentence && firstSentence.length > 10) {
+            return firstSentence.trim().slice(0, 80);
+        }
+    }
+    // Priority 3: Generic fallback
+    return "Processing...";
+}
 /**
  * Helper to derive favicon URL from a domain
  */
@@ -311,23 +364,26 @@ assistant: "I'm going to use the Task tool to launch the greeting-responder agen
                 .enum(agentNames)
                 .describe("The name of the subagent to use"),
             query: z.string().describe("The query or task to send to the subagent"),
+            taskName: z
+                .string()
+                .describe("A concise 3-5 word name describing this specific task (e.g., 'Searching for React patterns', 'Analyzing API responses'). IMPORTANT: Be specific and action-oriented!"),
         }),
         // Expose subagent configs for metadata extraction by the adapter
         subagentConfigs,
         fn: async (input) => {
-            const { agentName, query } = input;
+            const { agentName, query, taskName } = input;
             const agent = agentMap.get(agentName);
             if (!agent) {
                 throw new Error(`Unknown agent: ${agentName}`);
             }
-            return await querySubagent(agentName, agent.agentPath, agent.agentDir, query);
+            return await querySubagent(agentName, agent.agentPath, agent.agentDir, query, taskName);
         },
     };
 }
 /**
  * Internal function that runs a subagent in-process and queries it.
  */
-async function querySubagent(agentName, agentPath, agentWorkingDirectory, query) {
+async function querySubagent(agentName, agentPath, agentWorkingDirectory, query, taskName) {
     // Get the abort signal from context (set by parent agent's cancellation)
     const parentAbortSignal = getAbortSignal();
     // Check if already cancelled before starting
@@ -358,6 +414,11 @@ async function querySubagent(agentName, agentPath, agentWorkingDirectory, query)
     const otelCarrier = {};
     if (activeSpan) {
         propagation.inject(trace.setSpan(activeCtx, activeSpan), otelCarrier);
+        // Set span attributes for observability
+        activeSpan.setAttributes({
+            "subagent.semantic_name": taskName,
+            "subagent.agent_definition": agentName,
+        });
     }
     // Create invoke request
     const invokeRequest = {
@@ -386,10 +447,37 @@ async function querySubagent(agentName, agentPath, agentWorkingDirectory, query)
         content: "",
         contentBlocks: [],
         toolCalls: [],
+        _meta: {
+            semanticName: taskName,
+            agentDefinitionName: agentName,
+            statusGenerating: true,
+        },
     };
     const toolCallMap = new Map();
     const toolNameMap = new Map(); // Map toolCallId -> toolName
     const queryHash = hashQuery(query);
+    // Emit initial message with semantic name immediately
+    emitSubagentMessages(queryHash, [currentMessage]);
+    // Track status updates for periodic generation
+    let lastStatusUpdate = Date.now();
+    let statusUpdateInProgress = false;
+    const STATUS_UPDATE_INTERVAL = 5000; // 5 seconds
+    // Fire async initial status generation (don't await)
+    generateStatusMessage(query, [])
+        .then((status) => {
+        if (currentMessage._meta) {
+            currentMessage._meta.currentActivity = status;
+            currentMessage._meta.statusGenerating = false;
+        }
+        // Emit update with status
+        emitSubagentMessages(queryHash, [currentMessage]);
+    })
+        .catch((error) => {
+        logger.warn("Initial status generation failed", { error });
+        if (currentMessage._meta) {
+            currentMessage._meta.statusGenerating = false;
+        }
+    });
     logger.info("[DEBUG] Starting subagent generator loop", {
         agentName,
         queryHash,
@@ -507,6 +595,29 @@ async function querySubagent(agentName, agentPath, agentWorkingDirectory, query)
                 }
                 shouldEmit = true; // Emit when sources are added
             }
+            // Periodic status update check
+            const now = Date.now();
+            const shouldUpdateStatus = !statusUpdateInProgress &&
+                now - lastStatusUpdate > STATUS_UPDATE_INTERVAL &&
+                currentMessage.content.length > 100; // Only if there's meaningful content
+            if (shouldUpdateStatus) {
+                statusUpdateInProgress = true;
+                lastStatusUpdate = now;
+                // Fire async status update (don't await)
+                generateStatusMessage(currentMessage.content, currentMessage.toolCalls)
+                    .then((status) => {
+                    if (currentMessage._meta) {
+                        currentMessage._meta.currentActivity = status;
+                    }
+                    // Emit update
+                    emitSubagentMessages(queryHash, [currentMessage]);
+                    statusUpdateInProgress = false;
+                })
+                    .catch((error) => {
+                    logger.warn("Status update failed", { error });
+                    statusUpdateInProgress = false;
+                });
+            }
             // Emit incremental update to parent (for live streaming)
             if (shouldEmit) {
                 logger.debug("[SUBAGENT-ACCUMULATION] Emitting incremental update", {