@townco/agent 0.1.118 → 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/artifacts.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Supabase Storage-backed artifacts tool for agent backend
+ *
+ * Provides file storage capabilities using Supabase Storage with the following operations:
+ * - artifacts_cp: Copy files to/from Supabase Storage
+ * - artifacts_del: Delete files from Supabase Storage
+ * - artifacts_ls: List files in Supabase Storage
+ * - artifacts_url: Generate signed URLs
+ *
+ * Storage keys are scoped by: <deploying_user>/<agent_name>/<session_id>/<file_path>
+ */
+import { z } from "zod";
+/**
+ * Factory function to create the artifacts tools
+ * Returns an array of all four artifact management tools
+ */
+export declare function makeArtifactsTools(): (import("langchain").DynamicStructuredTool<z.ZodObject<{
+    session_id: z.ZodOptional<z.ZodString>;
+    source: z.ZodString;
+    destination: z.ZodString;
+    direction: z.ZodEnum<{
+        download: "download";
+        upload: "upload";
+    }>;
+}, z.core.$strip>, {
+    session_id: string;
+    source: string;
+    destination: string;
+    direction: "download" | "upload";
+}, {
+    session_id?: string | undefined;
+    source: string;
+    destination: string;
+    direction: "download" | "upload";
+}, string> | import("langchain").DynamicStructuredTool<z.ZodObject<{
+    session_id: z.ZodOptional<z.ZodString>;
+    path: z.ZodString;
+}, z.core.$strip>, {
+    session_id: string;
+    path: string;
+}, {
+    session_id?: string | undefined;
+    path: string;
+}, string> | import("langchain").DynamicStructuredTool<z.ZodObject<{
+    session_id: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    recursive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, {
+    session_id: string;
+    path?: string;
+    recursive?: boolean;
+}, {
+    session_id?: string | undefined;
+    path?: string | undefined;
+    recursive?: boolean | undefined;
+}, string> | import("langchain").DynamicStructuredTool<z.ZodObject<{
+    session_id: z.ZodOptional<z.ZodString>;
+    path: z.ZodString;
+    expires_in: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, {
+    session_id: string;
+    path: string;
+    expires_in?: number;
+}, {
+    session_id?: string | undefined;
+    path: string;
+    expires_in?: number | undefined;
+}, string>)[];