@townco/agent 0.1.140 → 0.1.142

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

@@ -9,14 +9,22 @@ import type { Sandbox } from "@e2b/code-interpreter";
  */
 export declare function getSessionSandbox(apiKey: string): Promise<Sandbox>;
 /**
- * Explicitly destroy a session's sandbox (called on session end).
- * Also clears the persisted sandboxId from storage.
+ * Pause a session's sandbox (called on session end or cleanup).
+ * The sandbox can be resumed later using the persisted sandboxId.
+ * State is preserved for up to 30 days.
  */
 export declare function destroySessionSandbox(sessionId: string): Promise<void>;
 /**
  * Check if a session has an active sandbox.
  */
 export declare function hasSessionSandbox(sessionId: string): boolean;
+/**
+ * Clear the in-memory sandbox reference for a session.
+ * Call this when a sandbox operation fails due to the sandbox being
+ * paused/expired (e.g., "sandbox is probably not running anymore").
+ * The next call to getSessionSandbox() will attempt to reconnect.
+ */
+export declare function clearStaleSandbox(sessionId: string): void;
 /**
  * Get an existing sandbox by sessionId without creating a new one.
  * Returns undefined if no sandbox exists for this session.

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

@@ -10,8 +10,8 @@ const sandboxActivity = new Map();
 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;
+// Sandbox timeout in milliseconds (default: 24 hours)
+const SANDBOX_TIMEOUT_MS = 24 * 60 * 60 * 1000;
 /**
  * Collect environment variables that should be passed to E2B sandbox
  * for tool usage (image generation, etc.)
@@ -76,6 +76,7 @@ async function createSandboxForSession(sessionId, apiKey) {
             const { Sandbox: SandboxClass } = await import("@e2b/code-interpreter");
             const sandbox = await SandboxClass.connect(persistedSandboxId, {
                 apiKey,
+                timeoutMs: SANDBOX_TIMEOUT_MS,
             });
             logger.info("Successfully reconnected to sandbox", {
                 sessionId,
@@ -121,7 +122,11 @@ async function createSandboxForSession(sessionId, apiKey) {
         config.template = templateId;
         logger.info("Using custom E2B template", { templateId });
     }
-    const sandbox = await SandboxClass.create(config);
+    const sandbox = await SandboxClass.betaCreate({
+        ...config,
+        autoPause: true,
+        timeoutMs: SANDBOX_TIMEOUT_MS,
+    });
     logger.info("Created new sandbox", {
         sessionId,
         sandboxId: sandbox.sandboxId,
@@ -197,18 +202,23 @@ export async function getSessionSandbox(apiKey) {
     }
 }
 /**
- * Explicitly destroy a session's sandbox (called on session end).
- * Also clears the persisted sandboxId from storage.
+ * Pause a session's sandbox (called on session end or cleanup).
+ * The sandbox can be resumed later using the persisted sandboxId.
+ * State is preserved for up to 30 days.
  */
 export async function destroySessionSandbox(sessionId) {
     const sandbox = sessionSandboxes.get(sessionId);
     if (sandbox) {
-        logger.info("Destroying sandbox", { sessionId });
+        logger.info("Pausing sandbox", { sessionId, sandboxId: sandbox.sandboxId });
         try {
-            await sandbox.kill();
+            await sandbox.betaPause();
+            logger.info("Sandbox paused successfully", {
+                sessionId,
+                sandboxId: sandbox.sandboxId,
+            });
         }
         catch (error) {
-            logger.error("Error killing sandbox", { sessionId, error });
+            logger.error("Error pausing sandbox", { sessionId, error });
         }
         sessionSandboxes.delete(sessionId);
         sandboxActivity.delete(sessionId);
@@ -218,22 +228,7 @@ export async function destroySessionSandbox(sessionId) {
             clearTimeout(timeout);
             cleanupTimeouts.delete(sessionId);
         }
-        // Clear persisted sandboxId from storage
-        // We do this without requiring session context since this can be called
-        // from HTTP endpoints that don't have session context
-        try {
-            // Try to get storage if we have context, but don't fail if we don't
-            if (hasSessionContext()) {
-                const storage = getSessionStorage();
-                if (storage) {
-                    await storage.updateSandboxId(sessionId, undefined);
-                    logger.debug("Cleared persisted sandboxId", { sessionId });
-                }
-            }
-        }
-        catch (error) {
-            logger.warn("Failed to clear persisted sandboxId", { sessionId, error });
-        }
+        // Note: We intentionally keep the sandboxId in storage so we can resume later
     }
 }
 /**
@@ -267,6 +262,22 @@ function rescheduleCleanup(sessionId) {
 export function hasSessionSandbox(sessionId) {
     return sessionSandboxes.has(sessionId);
 }
+/**
+ * Clear the in-memory sandbox reference for a session.
+ * Call this when a sandbox operation fails due to the sandbox being
+ * paused/expired (e.g., "sandbox is probably not running anymore").
+ * The next call to getSessionSandbox() will attempt to reconnect.
+ */
+export function clearStaleSandbox(sessionId) {
+    logger.info("Clearing stale sandbox reference", { sessionId });
+    sessionSandboxes.delete(sessionId);
+    sandboxActivity.delete(sessionId);
+    const timeout = cleanupTimeouts.get(sessionId);
+    if (timeout) {
+        clearTimeout(timeout);
+        cleanupTimeouts.delete(sessionId);
+    }
+}
 /**
  * Get an existing sandbox by sessionId without creating a new one.
  * Returns undefined if no sandbox exists for this session.

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

@@ -4,7 +4,7 @@ import { getShedAuth } from "@townco/core/auth";
 import { tool } from "langchain";
 import { z } from "zod";
 import { createLogger } from "../../../logger.js";
-import { getSessionSandbox } from "../../e2b-sandbox-manager";
+import { clearStaleSandbox, getSessionSandbox, } from "../../e2b-sandbox-manager";
 import { getEmitUpdate, getSessionContext, getToolOutputDir, hasSessionContext, } from "../../session-context";
 const logger = createLogger("e2b-tools");
 // Cached API key from Town proxy
@@ -48,6 +48,45 @@ export async function getTownE2BApiKey() {
         _apiKeyFetchPromise = null;
     }
 }
+/**
+ * Check if an error indicates the sandbox is stale (paused/expired).
+ * E2B throws this when the sandbox was auto-paused or timed out.
+ */
+function isStaleSandboxError(error) {
+    if (error instanceof Error) {
+        const msg = error.message.toLowerCase();
+        return (msg.includes("sandbox is probably not running") ||
+            msg.includes("sandbox not found") ||
+            msg.includes("not running anymore"));
+    }
+    return false;
+}
+/**
+ * Execute a sandbox operation with automatic retry on stale sandbox errors.
+ * If the sandbox was auto-paused by E2B, this clears the stale reference
+ * and reconnects before retrying.
+ */
+async function withSandboxRetry(getSandbox, operation) {
+    let sandbox = await getSandbox();
+    try {
+        return await operation(sandbox);
+    }
+    catch (error) {
+        if (isStaleSandboxError(error)) {
+            logger.info("Sandbox appears stale (auto-paused), clearing and reconnecting...");
+            // Clear the stale sandbox reference
+            if (hasSessionContext()) {
+                const { sessionId } = getSessionContext();
+                clearStaleSandbox(sessionId);
+            }
+            // Get a fresh sandbox (will reconnect/resume the paused sandbox)
+            sandbox = await getSandbox();
+            // Retry the operation
+            return await operation(sandbox);
+        }
+        throw error;
+    }
+}
 /**
  * Helper to save image artifacts from code execution results.
  */
@@ -73,9 +112,8 @@ async function saveImageArtifact(base64Data, format) {
 function makeE2BToolsInternal(getSandbox) {
     // Tool 1: Run Code (Python or JavaScript)
     const runCode = tool(async ({ code, language = "python" }) => {
-        const sandbox = await getSandbox();
         try {
-            const result = await sandbox.runCode(code, { language });
+            const result = await withSandboxRetry(getSandbox, (sandbox) => sandbox.runCode(code, { language }));
             // Format output
             let output = "";
             if (result.logs?.stdout && result.logs.stdout.length > 0) {
@@ -174,9 +212,8 @@ function makeE2BToolsInternal(getSandbox) {
     };
     // Tool 2: Run Bash Command
     const runBash = tool(async ({ command }) => {
-        const sandbox = await getSandbox();
         try {
-            const result = await sandbox.commands.run(command);
+            const result = await withSandboxRetry(getSandbox, (sandbox) => sandbox.commands.run(command));
             let output = "";
             if (result.stdout) {
                 output += result.stdout;
@@ -244,9 +281,8 @@ function makeE2BToolsInternal(getSandbox) {
     };
     // Tool 3: Read File from Sandbox
     const readSandboxFile = tool(async ({ path: filePath }) => {
-        const sandbox = await getSandbox();
         try {
-            const content = await sandbox.files.read(filePath);
+            const content = await withSandboxRetry(getSandbox, (sandbox) => sandbox.files.read(filePath));
             return content;
         }
         catch (error) {
@@ -267,9 +303,8 @@ function makeE2BToolsInternal(getSandbox) {
     readSandboxFile.icon = "FileText";
     // Tool 4: Write File to Sandbox
     const writeSandboxFile = tool(async ({ path: filePath, content }) => {
-        const sandbox = await getSandbox();
         try {
-            await sandbox.files.write(filePath, content);
+            await withSandboxRetry(getSandbox, (sandbox) => sandbox.files.write(filePath, content));
             // Emit file change notification
             const emitUpdate = getEmitUpdate();
             if (emitUpdate) {
@@ -312,13 +347,12 @@ function makeE2BToolsInternal(getSandbox) {
         if (!hasSessionContext()) {
             throw new Error("Sandbox_Share requires session context");
         }
-        const sandbox = await getSandbox();
         const { sessionId } = getSessionContext();
         const toolOutputDir = getToolOutputDir("E2B");
         try {
             // Step 1: Download from sandbox to local artifacts
             // Use base64 encoding to safely transfer binary data
-            const result = await sandbox.commands.run(`base64 ${sandboxPath}`);
+            const result = await withSandboxRetry(getSandbox, (sandbox) => sandbox.commands.run(`base64 ${sandboxPath}`));
             if (result.exitCode !== 0) {
                 throw new Error(`Failed to read file: ${result.stderr}`);
             }
@@ -405,13 +439,19 @@ function makeE2BToolsInternal(getSandbox) {
     shareSandboxFile.icon = "Share";
     // 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;
             const libraryApiKey = process.env.LIBRARY_API_KEY;
             if (!libraryApiUrl || !libraryApiKey) {
                 throw new Error("LIBRARY_API_URL and LIBRARY_API_KEY environment variables are required");
             }
+            // Get sandbox (with retry in case it was auto-paused) to ensure it's active
+            // The library API needs the sandbox to be running to upload files
+            const sandbox = await withSandboxRetry(getSandbox, async (s) => {
+                // Run a simple command to verify the sandbox is actually running
+                await s.commands.run("true");
+                return s;
+            });
             const response = await fetch(`${libraryApiUrl}/sandbox/upload_documents_to_sandbox`, {
                 method: "POST",
                 headers: {
@@ -475,7 +515,6 @@ function makeE2BToolsInternal(getSandbox) {
     };
     // Tool 7: Generate Image in Sandbox
     const generateImage = tool(async ({ prompt }) => {
-        const sandbox = await getSandbox();
         try {
             // JavaScript script to call Gemini API using @google/genai
             const escapedPrompt = prompt
@@ -566,10 +605,13 @@ async function generateImage() {
 
 generateImage();
 `;
-            await sandbox.files.write("/home/user/gen_img.js", script);
-            // Install @google/genai if not already installed (should be pre-installed in template)
-            await sandbox.commands.run("cd /home/user && npm install @google/genai");
-            const result = await sandbox.commands.run("cd /home/user && node gen_img.js");
+            // Run all sandbox operations with retry support
+            const result = await withSandboxRetry(getSandbox, async (sandbox) => {
+                await sandbox.files.write("/home/user/gen_img.js", script);
+                // Install @google/genai if not already installed (should be pre-installed in template)
+                await sandbox.commands.run("cd /home/user && npm install @google/genai");
+                return sandbox.commands.run("cd /home/user && node gen_img.js");
+            });
             logger.info("Image generation command result", {
                 exitCode: result.exitCode,
                 stdout: result.stdout,

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

@@ -110,6 +110,31 @@ function getSourceName(url) {
  */
 function extractSourcesFromToolOutput(toolName, rawOutput, toolCallId, sourceCounter) {
     const sources = [];
+    // Check for pre-extracted sources from runner (extracted before compaction)
+    // These preserve URLs that may be stripped during LLM compaction
+    if (rawOutput._compactionMeta &&
+        typeof rawOutput._compactionMeta === "object") {
+        const meta = rawOutput._compactionMeta;
+        if (meta.preExtractedSources && meta.preExtractedSources.length > 0) {
+            logger.info("Using pre-extracted sources from runner", {
+                toolName,
+                toolCallId,
+                sourcesCount: meta.preExtractedSources.length,
+            });
+            for (const s of meta.preExtractedSources) {
+                sources.push({
+                    id: s.id,
+                    url: s.url,
+                    title: s.title,
+                    toolCallId,
+                    ...(s.snippet && { snippet: s.snippet }),
+                    ...(s.favicon && { favicon: s.favicon }),
+                    ...(s.sourceName && { sourceName: s.sourceName }),
+                });
+            }
+            return sources;
+        }
+    }
     // Parse the actual output from the wrapper
     // The runner wraps results as { content: JSON.stringify(actualResult) }
     let actualOutput = rawOutput;