@townco/agent 0.1.141 → 0.1.143

package/dist/acp-server/adapter.d.ts

@@ -17,7 +17,7 @@ export interface SubagentModeExtension {
  */
 export interface CitationSource {
     id: string;
-    url: string;
+    url?: string | undefined;
     title: string;
     snippet?: string | undefined;
     favicon?: string | undefined;

package/dist/acp-server/adapter.js

@@ -465,7 +465,15 @@ export class AgentAcpAdapter {
                 return citationSource;
             };
             // Check if this is a search results array (library__search_keyword)
-            const results = outputContent.results ?? outputContent.documents;
+            // Results may be at top level or nested in structuredContent (MCP tool wrapper)
+            const structuredContent = typeof outputContent.structuredContent === "object" &&
+                outputContent.structuredContent !== null
+                ? outputContent.structuredContent
+                : null;
+            const results = outputContent.results ??
+                outputContent.documents ??
+                structuredContent?.results ??
+                structuredContent?.documents;
             if (Array.isArray(results)) {
                 // Handle array of search results
                 logger.debug("Processing library search results array", {

package/dist/acp-server/session-storage.d.ts

@@ -164,7 +164,7 @@ export interface StoredSession {
  */
 export interface PersistedCitationSource {
     id: string;
-    url: string;
+    url?: string | undefined;
     title: string;
     snippet?: string | undefined;
     favicon?: string | undefined;

package/dist/acp-server/session-storage.js

@@ -168,7 +168,7 @@ const sessionMetadataSchema = z.object({
 // Citation schemas - matches SourceSchema from packages/ui/src/core/schemas/source.ts
 const persistedCitationSourceSchema = z.object({
     id: z.string(),
-    url: z.string(),
+    url: z.string().optional(), // Optional for backward compatibility with sessions that have missing URLs
     title: z.string(),
     snippet: z.string().optional(),
     favicon: z.string().optional(),

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/hooks/predefined/compaction-tool.js

@@ -1,6 +1,6 @@
-import { ChatAnthropic } from "@langchain/anthropic";
 import { HumanMessage, SystemMessage } from "@langchain/core/messages";
 import { createLogger } from "../../../logger.js";
+import { createModelFromString } from "../../langchain/model-factory.js";
 import { createContextEntry, createFullMessageEntry, } from "../types";
 import { applyTokenPadding } from "./token-utils.js";
 const logger = createLogger("compaction-tool");
@@ -67,10 +67,8 @@ export const compactionTool = async (ctx) => {
     const hasLibraryMcp = ctx.agent.mcps?.some((mcp) => typeof mcp === "string" ? mcp === "library" : mcp.name === "library");
     try {
         // Create the LLM client using the same model as the agent
-        const model = new ChatAnthropic({
-            model: ctx.model,
-            temperature: 0,
-        });
+        // Use model factory to properly handle town- prefixed models (routes through shed proxy)
+        const model = await createModelFromString(ctx.model);
         // Build the conversation history to compact
         const messagesToCompact = ctx.session.messages;
         // Convert session messages to text for context, including tool calls and results

package/dist/runner/langchain/index.js

@@ -185,7 +185,15 @@ function extractSourcesBeforeCompaction(toolName, rawOutput) {
             };
         };
         // Check for results array (library__search_keyword, library__semantic_search)
-        const results = actualOutput.results ?? actualOutput.documents;
+        // Results may be at top level or nested in structuredContent (MCP tool wrapper)
+        const structuredContent = typeof actualOutput.structuredContent === "object" &&
+            actualOutput.structuredContent !== null
+            ? actualOutput.structuredContent
+            : null;
+        const results = actualOutput.results ??
+            actualOutput.documents ??
+            structuredContent?.results ??
+            structuredContent?.documents;
         if (Array.isArray(results)) {
             for (const result of results) {
                 if (result && typeof result === "object") {
@@ -202,6 +210,32 @@ function extractSourcesBeforeCompaction(toolName, rawOutput) {
                 sources.push(source);
         }
     }
+    // Handle subagent tool outputs (SubagentResult format: { text, sources })
+    const isSubagentTool = toolName === "subagent" || toolName === "Task";
+    if (isSubagentTool && Array.isArray(actualOutput.sources)) {
+        for (const source of actualOutput.sources) {
+            if (source &&
+                typeof source === "object" &&
+                typeof source.url === "string" &&
+                source.url) {
+                sourceCounter++;
+                sources.push({
+                    id: typeof source.id === "string" ? source.id : String(sourceCounter),
+                    url: source.url,
+                    title: typeof source.title === "string" ? source.title : "Untitled",
+                    snippet: typeof source.snippet === "string"
+                        ? source.snippet.slice(0, 200)
+                        : undefined,
+                    favicon: typeof source.favicon === "string"
+                        ? source.favicon
+                        : getFaviconFromUrl(source.url),
+                    sourceName: typeof source.sourceName === "string"
+                        ? source.sourceName
+                        : getSourceNameFromUrl(source.url),
+                });
+            }
+        }
+    }
     return sources;
 }
 function stableStringify(value) {
@@ -742,7 +776,41 @@ export class LangchainAgent {
                     const toolCallId = hasInflightToolCompaction
                         ? await consumeToolCallId(originalTool.name, input)
                         : `unknown_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-                    const result = await originalTool.invoke(input);
+                    let result = await originalTool.invoke(input);
+                    // Apply subagent source renumbering BEFORE extraction
+                    // This ensures pre-extracted sources have the same IDs as the text references
+                    const isSubagentToolResult = originalTool.name === SUBAGENT_TOOL_NAME &&
+                        result &&
+                        typeof result === "object" &&
+                        "sources" in result &&
+                        Array.isArray(result.sources) &&
+                        result.sources.length > 0;
+                    if (isSubagentToolResult) {
+                        const subagentResult = result;
+                        subagentCallCounter++;
+                        const baseOffset = subagentCallCounter * 1000;
+                        let sourceIndex = 0;
+                        // Create ID mapping and re-number sources with offset
+                        const idMapping = new Map();
+                        const renumberedSources = subagentResult.sources.map((source) => {
+                            sourceIndex++;
+                            const newId = String(baseOffset + sourceIndex);
+                            idMapping.set(source.id, newId);
+                            return { ...source, id: newId };
+                        });
+                        // Update citation references in the text [[oldId]] -> [[newId]]
+                        let updatedText = subagentResult.text;
+                        for (const [oldId, newId] of idMapping) {
+                            const pattern = new RegExp(`\\[\\[${oldId}\\]\\]`, "g");
+                            updatedText = updatedText.replace(pattern, `[[${newId}]]`);
+                        }
+                        _logger.info("Re-numbered subagent citation sources (in-flight)", {
+                            subagentCall: subagentCallCounter,
+                            originalCount: subagentResult.sources.length,
+                            idRange: `${baseOffset + 1}-${baseOffset + sourceIndex}`,
+                        });
+                        result = { text: updatedText, sources: renumberedSources };
+                    }
                     if (!inflightHookExecutor || !hasInflightToolCompaction) {
                         return result;
                     }
@@ -756,6 +824,7 @@ export class LangchainAgent {
                     const outputTokens = await countToolResultTokens(rawOutput);
                     // Extract citation sources BEFORE compaction to preserve URLs
                     // Compaction LLM may remove URLs as "unnecessary" during summarization
+                    // NOTE: For subagent tools, sources are already renumbered above
                     const preExtractedSources = extractSourcesBeforeCompaction(originalTool.name, rawOutput);
                     // Include current prompt as the last user message for better context.
                     const nowIso = new Date().toISOString();
@@ -899,65 +968,10 @@ export class LangchainAgent {
                         allowedToolNames.has(t.name));
                 });
             }
-            // Wrap the subagent tool to re-number citation sources
-            // This ensures sources from subagents get unique IDs that don't conflict
-            // with the parent agent's own sources or other subagent calls
-            // Each subagent call gets a unique ID range (1000+, 2000+, etc.)
-            finalTools = finalTools.map((t) => {
-                if (t.name !== SUBAGENT_TOOL_NAME) {
-                    return t;
-                }
-                const wrappedFunc = async (input) => {
-                    const result = (await t.invoke(input));
-                    // Check if result has sources to re-number
-                    if (!result ||
-                        typeof result !== "object" ||
-                        !Array.isArray(result.sources) ||
-                        result.sources.length === 0) {
-                        return result;
-                    }
-                    // Increment subagent call counter and calculate base offset
-                    subagentCallCounter++;
-                    const baseOffset = subagentCallCounter * 1000;
-                    let sourceIndex = 0;
-                    // Create ID mapping and re-number sources with offset
-                    const idMapping = new Map();
-                    const renumberedSources = result.sources.map((source) => {
-                        sourceIndex++;
-                        const newId = String(baseOffset + sourceIndex);
-                        idMapping.set(source.id, newId);
-                        return { ...source, id: newId };
-                    });
-                    // Update citation references in the text [[oldId]] -> [[newId]]
-                    let updatedText = result.text;
-                    for (const [oldId, newId] of idMapping) {
-                        const pattern = new RegExp(`\\[\\[${oldId}\\]\\]`, "g");
-                        updatedText = updatedText.replace(pattern, `[[${newId}]]`);
-                    }
-                    _logger.info("Re-numbered subagent citation sources", {
-                        subagentCall: subagentCallCounter,
-                        originalCount: result.sources.length,
-                        idRange: `${baseOffset + 1}-${baseOffset + sourceIndex}`,
-                    });
-                    return { text: updatedText, sources: renumberedSources };
-                };
-                // Create new tool with wrapped function
-                // biome-ignore lint/suspicious/noExplicitAny: Need to pass function with dynamic signature
-                const wrappedTool = tool(wrappedFunc, {
-                    name: t.name,
-                    description: t.description,
-                    // biome-ignore lint/suspicious/noExplicitAny: Accessing internal schema property
-                    schema: t.schema,
-                });
-                // Preserve metadata
-                // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
-                wrappedTool.prettyName = t.prettyName;
-                // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
-                wrappedTool.icon = t.icon;
-                // biome-ignore lint/suspicious/noExplicitAny: Need to preserve subagentConfigs for metadata
-                wrappedTool.subagentConfigs = t.subagentConfigs;
-                return wrappedTool;
-            });
+            // NOTE: Subagent source renumbering now happens earlier in the wrappedTools
+            // wrapper (around line 1050) to ensure pre-extracted sources have matching IDs.
+            // This ensures that when sources are extracted before compaction, they already
+            // have the renumbered IDs (1001+, 2001+, etc.) that match the text references.
             // Create the model instance using the factory
             // This detects the provider from the model string:
             // - "gemini-2.0-flash" → Google Generative AI

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,