@townco/agent 0.1.107 → 0.1.109

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

@@ -1,3 +1,4 @@
+import * as path from "node:path";
 import { createLogger } from "../logger.js";
 import { getSessionContext, hasSessionContext } from "./session-context";
 const logger = createLogger("e2b-sandbox-manager");
@@ -9,16 +10,64 @@ const sandboxActivity = new Map();
 const cleanupTimeouts = new Map();
 // Sandbox timeout in milliseconds (default: 15 minutes)
 const SANDBOX_TIMEOUT_MS = 15 * 60 * 1000;
+/**
+ * Collect environment variables that should be passed to E2B sandbox
+ * for tool usage (image generation, etc.)
+ */
+function collectToolEnvironmentVars() {
+    const envs = {};
+    // Gemini API key for image generation
+    if (process.env.GEMINI_API_KEY) {
+        envs.GEMINI_API_KEY = process.env.GEMINI_API_KEY;
+        logger.debug("GEMINI_API_KEY configured for sandbox", {
+            keyLength: process.env.GEMINI_API_KEY.length,
+        });
+    }
+    else {
+        logger.warn("GEMINI_API_KEY not set - image generation will fail");
+    }
+    return envs;
+}
+/**
+ * Get SessionStorage instance for the current session.
+ * Returns null if session storage is not available.
+ */
+function getSessionStorage() {
+    if (!hasSessionContext()) {
+        logger.debug("No session context available for SessionStorage");
+        return null;
+    }
+    const { sessionDir, sessionId } = getSessionContext();
+    // Derive agentDir from sessionDir
+    // sessionDir = <agentDir>/.sessions/<sessionId>
+    // so agentDir = dirname(dirname(sessionDir))
+    const agentDir = path.dirname(path.dirname(sessionDir));
+    // Extract agent name from agentDir (last path component)
+    const agentName = path.basename(agentDir);
+    // Import SessionStorage dynamically to avoid circular dependency
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { SessionStorage: SessionStorageClass, } = require("../acp-server/session-storage");
+        const storage = new SessionStorageClass(agentDir, agentName);
+        logger.debug("Created SessionStorage", { sessionId, agentDir, agentName });
+        return storage;
+    }
+    catch (error) {
+        logger.error("Failed to create SessionStorage", { error, sessionId });
+        return null;
+    }
+}
 /**
  * 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.
  */
 export async function getSessionSandbox(apiKey) {
     if (!hasSessionContext()) {
         throw new Error("E2B tools require session context");
     }
     const { sessionId } = getSessionContext();
-    // Check for existing sandbox
+    // Check for existing in-memory sandbox
     let sandbox = sessionSandboxes.get(sessionId);
     if (sandbox) {
         // Update activity timestamp and reschedule cleanup
@@ -27,10 +76,91 @@ export async function getSessionSandbox(apiKey) {
         logger.debug("Reusing existing sandbox", { sessionId });
         return sandbox;
     }
+    // Try to reconnect to persisted sandbox
+    const storage = getSessionStorage();
+    const persistedSandboxId = storage?.getSandboxId(sessionId);
+    if (persistedSandboxId) {
+        logger.info("Attempting to reconnect to persisted sandbox", {
+            sessionId,
+            sandboxId: persistedSandboxId,
+        });
+        try {
+            const { Sandbox: SandboxClass } = await import("@e2b/code-interpreter");
+            sandbox = await SandboxClass.connect(persistedSandboxId, { apiKey });
+            logger.info("Successfully reconnected to sandbox", {
+                sessionId,
+                sandboxId: persistedSandboxId,
+            });
+            // Store in memory and set up activity tracking
+            sessionSandboxes.set(sessionId, sandbox);
+            sandboxActivity.set(sessionId, Date.now());
+            scheduleCleanup(sessionId);
+            return sandbox;
+        }
+        catch (error) {
+            logger.warn("Failed to reconnect to persisted sandbox, will create new one", {
+                sessionId,
+                sandboxId: persistedSandboxId,
+                error,
+            });
+            // Clear the stale sandboxId from storage
+            if (storage) {
+                try {
+                    await storage.updateSandboxId(sessionId, undefined);
+                }
+                catch (updateError) {
+                    logger.warn("Failed to clear stale sandboxId", {
+                        sessionId,
+                        updateError,
+                    });
+                }
+            }
+        }
+    }
     // Create new sandbox - dynamic import to avoid loading if not used
     logger.info("Creating new E2B sandbox", { sessionId });
     const { Sandbox: SandboxClass } = await import("@e2b/code-interpreter");
-    sandbox = await SandboxClass.create({ apiKey });
+    const envs = collectToolEnvironmentVars();
+    // Use custom template with pre-installed packages (google-generativeai, etc.)
+    const templateId = process.env.E2B_TEMPLATE_ID;
+    const config = {
+        apiKey,
+        envVars: envs,
+    };
+    if (templateId) {
+        config.template = templateId;
+        logger.info("Using custom E2B template", { templateId });
+    }
+    sandbox = await SandboxClass.create(config);
+    logger.info("Created new sandbox", {
+        sessionId,
+        sandboxId: sandbox.sandboxId,
+    });
+    // Persist the sandboxId for future reconnection
+    if (storage) {
+        try {
+            await storage.updateSandboxId(sessionId, sandbox.sandboxId);
+            logger.info("Persisted sandboxId to storage", {
+                sessionId,
+                sandboxId: sandbox.sandboxId,
+            });
+        }
+        catch (error) {
+            logger.error("Failed to persist sandboxId", { sessionId, error });
+        }
+    }
+    else {
+        logger.warn("No storage available to persist sandboxId", { sessionId });
+    }
+    // Configure Python logging to output to stderr by default
+    await sandbox.runCode(`
+import logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(levelname)s - %(name)s - %(message)s',
+    stream=__import__('sys').stderr
+)
+`.trim(), { language: "python" });
     sessionSandboxes.set(sessionId, sandbox);
     sandboxActivity.set(sessionId, Date.now());
     // Set up auto-cleanup timeout
@@ -39,6 +169,7 @@ export async function getSessionSandbox(apiKey) {
 }
 /**
  * Explicitly destroy a session's sandbox (called on session end).
+ * Also clears the persisted sandboxId from storage.
  */
 export async function destroySessionSandbox(sessionId) {
     const sandbox = sessionSandboxes.get(sessionId);
@@ -58,6 +189,22 @@ 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 });
+        }
     }
 }
 /**
@@ -91,6 +238,20 @@ function rescheduleCleanup(sessionId) {
 export function hasSessionSandbox(sessionId) {
     return sessionSandboxes.has(sessionId);
 }
+/**
+ * Get an existing sandbox by sessionId without creating a new one.
+ * Returns undefined if no sandbox exists for this session.
+ * Used by HTTP endpoints that don't have session context.
+ */
+export function getExistingSandbox(sessionId) {
+    const sandbox = sessionSandboxes.get(sessionId);
+    if (sandbox) {
+        // Update activity timestamp and reschedule cleanup
+        sandboxActivity.set(sessionId, Date.now());
+        rescheduleCleanup(sessionId);
+    }
+    return sandbox;
+}
 /**
  * Get the number of active sandboxes (for debugging/monitoring).
  */

package/dist/runner/hooks/predefined/compaction-tool.js

@@ -14,6 +14,7 @@ export const compactionTool = async (ctx) => {
     // Read settings from callbackSetting
     const settings = ctx.callbackSetting;
     const threshold = settings?.threshold ?? 80;
+    const forceCompact = settings?.forceCompact ?? false;
     // Calculate effective token usage including pending tool response if present
     const toolResponseTokens = ctx.toolResponse?.outputTokens ?? 0;
     const estimatedTokens = ctx.currentTokens + toolResponseTokens;
@@ -21,7 +22,8 @@ export const compactionTool = async (ctx) => {
     const paddedTokens = applyTokenPadding(estimatedTokens);
     const effectivePercentage = (paddedTokens / ctx.maxTokens) * 100;
     // Check if we should run based on context percentage (including tool response)
-    if (effectivePercentage < threshold) {
+    // Skip threshold check if forceCompact is true (used for error recovery)
+    if (!forceCompact && effectivePercentage < threshold) {
         logger.debug("Context below threshold, skipping compaction", {
             currentTokens: ctx.currentTokens,
             toolResponseTokens,
@@ -40,6 +42,15 @@ export const compactionTool = async (ctx) => {
             },
         };
     }
+    // Log if force compaction was triggered
+    if (forceCompact) {
+        logger.info("Force compaction triggered (bypassing threshold check)", {
+            currentTokens: ctx.currentTokens,
+            toolResponseTokens,
+            effectivePercentage: `${effectivePercentage.toFixed(2)}%`,
+            threshold,
+        });
+    }
     logger.info("Compaction tool triggered", {
         currentTokens: ctx.currentTokens,
         toolResponseTokens,
@@ -192,44 +203,46 @@ Please provide your summary based on the conversation above, following this stru
             const kgMatch = summaryText.match(/<knowledge_graph_analysis_needed>(yes|no)<\/knowledge_graph_analysis_needed>/i);
             needsKnowledgeGraphAnalysis = kgMatch?.[1]?.toLowerCase() === "yes";
             logger.info(`Knowledge graph analysis decision: needsAnalysis=${needsKnowledgeGraphAnalysis}, matchFound=${!!kgMatch}`);
-            if (needsKnowledgeGraphAnalysis) {
-                const apiUrl = process.env.LIBRARY_API_URL;
-                const apiKey = process.env.LIBRARY_ROOT_API_KEY;
-                logger.info("Attempting to dispatch to Library API", {
-                    hasApiUrl: !!apiUrl,
-                    hasApiKey: !!apiKey,
-                });
-                if (apiUrl && apiKey) {
-                    const serviceUrl = `${apiUrl}/compaction_analysis`;
-                    // Fire-and-forget - don't block compaction on external service
-                    fetch(serviceUrl, {
-                        method: "POST",
-                        headers: {
-                            "Content-Type": "application/json",
-                            Authorization: `Bearer ${apiKey}`,
-                        },
-                        body: JSON.stringify({
-                            conversation_text: conversationText,
-                            timestamp: Date.now(),
-                        }),
-                    })
-                        .then((response) => {
-                        logger.info("Library API response received", {
-                            status: response.status,
-                            ok: response.ok,
-                        });
-                    })
-                        .catch((error) => logger.error("Failed to send compaction for analysis", {
-                        error: error instanceof Error ? error.message : String(error),
-                    }));
-                }
-                else {
-                    logger.warn("Skipping Library API dispatch - missing config", {
-                        hasApiUrl: !!apiUrl,
-                        hasApiKey: !!apiKey,
-                    });
-                }
-            }
+            // TODO: Re-enable graph analysis dispatch when ready
+            // if (needsKnowledgeGraphAnalysis) {
+            //   const apiUrl = process.env.LIBRARY_API_URL;
+            //   const apiKey = process.env.LIBRARY_API_KEY;
+            //   logger.info("Attempting to dispatch to Library API", {
+            //     hasApiUrl: !!apiUrl,
+            //     hasApiKey: !!apiKey,
+            //   });
+            //   if (apiUrl && apiKey) {
+            //     const serviceUrl = `${apiUrl}/compaction_analysis`;
+            //     // Fire-and-forget - don't block compaction on external service
+            //     fetch(serviceUrl, {
+            //       method: "POST",
+            //       headers: {
+            //         "Content-Type": "application/json",
+            //         Authorization: `Bearer ${apiKey}`,
+            //       },
+            //       body: JSON.stringify({
+            //         conversation_text: conversationText,
+            //         timestamp: Date.now(),
+            //       }),
+            //     })
+            //       .then((response) => {
+            //         logger.info("Library API response received", {
+            //           status: response.status,
+            //           ok: response.ok,
+            //         });
+            //       })
+            //       .catch((error) =>
+            //         logger.error("Failed to send compaction for analysis", {
+            //           error: error instanceof Error ? error.message : String(error),
+            //         }),
+            //       );
+            //   } else {
+            //     logger.warn("Skipping Library API dispatch - missing config", {
+            //       hasApiUrl: !!apiUrl,
+            //       hasApiKey: !!apiKey,
+            //     });
+            //   }
+            // }
         }
         return {
             newContextEntry,

package/dist/runner/index.d.ts

@@ -1,5 +1,5 @@
-import { type AgentRunner } from "./agent-runner";
-export type { AgentRunner };
+import { type AgentRunner, type SessionUpdateNotification } from "./agent-runner";
+export type { AgentRunner, SessionUpdateNotification };
 export declare const makeRunnerFromDefinition: (definition: {
     displayName?: string | undefined;
     version?: string | undefined;

package/dist/runner/index.js

@@ -1,4 +1,4 @@
-import { zAgentRunnerParams } from "./agent-runner";
+import { zAgentRunnerParams, } from "./agent-runner";
 import { LangchainAgent } from "./langchain";
 export const makeRunnerFromDefinition = (definition) => {
     const agentRunnerParams = zAgentRunnerParams.safeParse(definition);

package/dist/runner/langchain/index.js

@@ -5,21 +5,19 @@ import { context, propagation, trace } from "@opentelemetry/api";
 import { ensureAuthenticated } from "@townco/core/auth";
 import { AIMessageChunk, createAgent, ToolMessage, tool, } from "langchain";
 import { z } from "zod";
-import { SUBAGENT_MODE_KEY } from "../../acp-server/adapter";
+import { ContextOverflowError, SUBAGENT_MODE_KEY, } from "../../acp-server/adapter";
 import { createLogger } from "../../logger.js";
 import { telemetry } from "../../telemetry/index.js";
 import { calculateContextSize } from "../../utils/context-size-calculator.js";
 import { getModelContextWindow } from "../hooks/constants.js";
-import { bindGeneratorToAbortSignal, bindGeneratorToSessionContext, getAbortSignal, runWithAbortSignal, } from "../session-context";
+import { isContextOverflowError } from "../hooks/predefined/context-validator.js";
+import { bindGeneratorToAbortSignal, bindGeneratorToEmitUpdate, bindGeneratorToSessionContext, getAbortSignal, runWithAbortSignal, } from "../session-context";
 import { loadCustomToolModule, } from "../tool-loader.js";
 import { createModelFromString, detectProvider } from "./model-factory.js";
 import { makeOtelCallbacks } from "./otel-callbacks.js";
-import { makeArtifactsTools } from "./tools/artifacts";
 import { makeBrowserTools } from "./tools/browser";
 import { makeDocumentExtractTool } from "./tools/document_extract";
 import { makeTownE2BTools } from "./tools/e2b";
-import { makeFilesystemTools } from "./tools/filesystem";
-import { makeGenerateImageTool, makeTownGenerateImageTool, } from "./tools/generate_image";
 import { SUBAGENT_TOOL_NAME } from "./tools/subagent";
 import { hashQuery, queryToToolCallId, subagentEvents, } from "./tools/subagent-connections";
 import { makeTodoWriteTool, TODO_WRITE_TOOL_NAME } from "./tools/todo";
@@ -37,17 +35,13 @@ getWeather.prettyName = "Get Weather";
 // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
 getWeather.icon = "Cloud";
 export const TOOL_REGISTRY = {
-    artifacts: () => makeArtifactsTools(),
     todo_write: () => makeTodoWriteTool(), // Factory function to create fresh instance per invocation
     get_weather: getWeather, // TODO: Convert to factory function for full concurrency safety
     web_search: () => makeWebSearchTools(),
     town_web_search: () => makeTownWebSearchTools(),
-    filesystem: () => makeFilesystemTools(),
-    generate_image: () => makeGenerateImageTool(),
-    town_generate_image: () => makeTownGenerateImageTool(),
     browser: () => makeBrowserTools(),
     document_extract: () => makeDocumentExtractTool(),
-    code_sandbox: () => makeTownE2BTools(),
+    code_sandbox: makeTownE2BTools,
 };
 // ============================================================================
 // Custom tool loading
@@ -92,6 +86,10 @@ export class LangchainAgent {
         if (req.abortSignal) {
             generator = bindGeneratorToAbortSignal(req.abortSignal, generator);
         }
+        // Bind emitUpdate callback if available (for file change events)
+        if (req.emitUpdate) {
+            generator = bindGeneratorToEmitUpdate(req.emitUpdate, generator);
+        }
         // Set up session context for session-scoped file storage
         // This allows tools to access getSessionContext() / getToolOutputDir()
         if (req.agentDir && req.sessionId) {
@@ -290,16 +288,6 @@ export class LangchainAgent {
                         typeof t.modulePath === "string") {
                         customToolPaths.push(t.modulePath);
                     }
-                    else if (type === "filesystem") {
-                        // Note: working_directory is ignored - filesystem tools now use session context
-                        const fsTools = makeFilesystemTools();
-                        // Tag filesystem tools with their group name for tool override filtering
-                        for (const fsTool of fsTools) {
-                            // biome-ignore lint/suspicious/noExplicitAny: Need to add custom property for tool grouping
-                            fsTool.__groupName = "filesystem";
-                        }
-                        enabledTools.push(...fsTools);
-                    }
                     else if (type === "direct") {
                         // Handle direct tool objects (imported in code)
                         // biome-ignore lint/suspicious/noExplicitAny: mlai unsure how to best type this
@@ -320,6 +308,31 @@ export class LangchainAgent {
             for (const name of builtInNames) {
                 const entry = TOOL_REGISTRY[name];
                 if (!entry) {
+                    // Provide helpful error messages for removed tools
+                    // Cast to string to allow checking against removed tool names
+                    const nameStr = name;
+                    if (nameStr === "filesystem") {
+                        throw new Error(`The "filesystem" tool has been removed. Use "code_sandbox" instead.\n\n` +
+                            `Migration:\n` +
+                            `- Change tools: ["filesystem"] to tools: ["code_sandbox"]\n` +
+                            `- Read files: Use Sandbox_ReadFile\n` +
+                            `- Write files: Use Sandbox_WriteFile\n` +
+                            `- Search files: Use Sandbox_RunBash with grep/find commands`);
+                    }
+                    if (nameStr === "artifacts") {
+                        throw new Error(`The "artifacts" tool has been removed. Use "code_sandbox" with Sandbox_Share instead.\n\n` +
+                            `Migration:\n` +
+                            `- Change tools: ["artifacts"] to tools: ["code_sandbox"]\n` +
+                            `- Share files: Use Sandbox_Share to upload sandbox files to Supabase Storage`);
+                    }
+                    if (nameStr === "generate_image" ||
+                        nameStr === "town_generate_image") {
+                        throw new Error(`The "${nameStr}" tool has been removed. Use "code_sandbox" with Sandbox_GenerateImage instead.\n\n` +
+                            `Migration:\n` +
+                            `- Change tools: ["${nameStr}"] to tools: ["code_sandbox"]\n` +
+                            `- Generate images: Use Sandbox_GenerateImage (runs in sandbox)\n` +
+                            `- Share images: Use Sandbox_Share to make images accessible`);
+                    }
                     throw new Error(`Unknown built-in tool "${name}"`);
                 }
                 const tagTool = (tool) => {
@@ -1127,10 +1140,6 @@ export class LangchainAgent {
                             continue; // Skip the rest of the processing for this chunk
                         }
                         if (typeof aiMessage.content === "string") {
-                            console.log("[DEBUG] Yielding agent_message_chunk (string)", {
-                                content: aiMessage.content.slice(0, 100),
-                                hasTokenUsage: !!messageTokenUsage,
-                            });
                             const msgToYield = messageTokenUsage
                                 ? {
                                     sessionUpdate: "agent_message_chunk",
@@ -1152,16 +1161,8 @@ export class LangchainAgent {
                             yield msgToYield;
                         }
                         else if (Array.isArray(aiMessage.content)) {
-                            console.log("[DEBUG] Processing array content", {
-                                partCount: aiMessage.content.length,
-                                partTypes: aiMessage.content.map((p) => p.type),
-                            });
                             for (const part of aiMessage.content) {
                                 if (part.type === "text" && typeof part.text === "string") {
-                                    console.log("[DEBUG] Yielding agent_message_chunk (array text)", {
-                                        text: part.text.slice(0, 100),
-                                        hasTokenUsage: !!messageTokenUsage,
-                                    });
                                     const msgToYield = messageTokenUsage
                                         ? {
                                             sessionUpdate: "agent_message_chunk",
@@ -1339,6 +1340,15 @@ export class LangchainAgent {
             subagentEvents.off("messages", onSubagentMessages);
             // Clean up any remaining iteration span
             otelCallbacks?.cleanup();
+            // Check if this is a context overflow error - wrap it for retry handling
+            if (isContextOverflowError(error)) {
+                telemetry.log("warn", "Context overflow detected - will attempt compaction and retry", {
+                    error: error instanceof Error ? error.message : String(error),
+                    sessionId: req.sessionId,
+                });
+                telemetry.endSpan(invocationSpan);
+                throw new ContextOverflowError(error instanceof Error ? error : new Error(String(error)));
+            }
             // Log error and end span with error status
             telemetry.log("error", "Agent invocation failed", {
                 error: error instanceof Error ? error.message : String(error),
@@ -1572,12 +1582,7 @@ export function getToolGroupChildren(toolName) {
  */
 function wrapToolWithTracing(originalTool, getIterationContext, sessionId) {
     // Check if this tool needs session_id injection
-    const TOOLS_NEEDING_SESSION_ID = [
-        "artifacts_cp",
-        "artifacts_del",
-        "artifacts_ls",
-        "artifacts_url",
-    ];
+    const TOOLS_NEEDING_SESSION_ID = [];
     const needsSessionId = TOOLS_NEEDING_SESSION_ID.includes(originalTool.name);
     const wrappedFunc = async (input) => {
         // Capture the abort signal from the current context BEFORE LangChain breaks AsyncLocalStorage

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

@@ -1,4 +1,8 @@
 import { z } from "zod";
+/**
+ * Get E2B API key from Town proxy (with caching).
+ */
+export declare function getTownE2BApiKey(): Promise<string>;
 /**
  * Create E2B tools using Town proxy authentication.
  * Fetches E2B API key from Town server using user credentials.
@@ -51,4 +55,10 @@ export declare function makeTownE2BTools(): readonly [import("langchain").Dynami
     document_id: string;
 }, {
     document_id: string;
+}, string>, import("langchain").DynamicStructuredTool<z.ZodObject<{
+    prompt: z.ZodString;
+}, z.core.$strip>, {
+    prompt: string;
+}, {
+    prompt: string;
 }, string>];