@townco/agent 0.1.106 → 0.1.108

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

@@ -31,7 +31,16 @@ export interface CitationSource {
  */
 export declare class MidTurnRestartError extends Error {
     newContextEntry: ContextEntry;
-    constructor(message: string, newContextEntry: ContextEntry);
+    hookId: string;
+    constructor(message: string, newContextEntry: ContextEntry, hookId: string);
+}
+/**
+ * Error thrown when the Claude API returns "prompt is too long" error.
+ * The adapter catches this error, forces context compaction, and retries.
+ */
+export declare class ContextOverflowError extends Error {
+    originalError: Error;
+    constructor(originalError: Error);
 }
 /** Adapts an Agent to speak the ACP protocol */
 export declare class AgentAcpAdapter implements acp.Agent {
@@ -104,6 +113,7 @@ export declare class AgentAcpAdapter implements acp.Agent {
     setSessionMode(_params: acp.SetSessionModeRequest): Promise<acp.SetSessionModeResponse>;
     prompt(params: acp.PromptRequest): Promise<acp.PromptResponse>;
     private _promptImpl;
+    private forceCompaction;
     private executeHooksIfConfigured;
     private _executeHooksImpl;
     cancel(params: acp.CancelNotification): Promise<void>;

package/dist/acp-server/adapter.js

@@ -20,10 +20,24 @@ export const SUBAGENT_MODE_KEY = "town.com/isSubagent";
  */
 export class MidTurnRestartError extends Error {
     newContextEntry;
-    constructor(message, newContextEntry) {
+    hookId;
+    constructor(message, newContextEntry, hookId) {
         super(message);
         this.name = "MidTurnRestartError";
         this.newContextEntry = newContextEntry;
+        this.hookId = hookId;
+    }
+}
+/**
+ * Error thrown when the Claude API returns "prompt is too long" error.
+ * The adapter catches this error, forces context compaction, and retries.
+ */
+export class ContextOverflowError extends Error {
+    originalError;
+    constructor(originalError) {
+        super(`Context overflow: ${originalError.message}`);
+        this.name = "ContextOverflowError";
+        this.originalError = originalError;
     }
 }
 /**
@@ -179,15 +193,6 @@ export class AgentAcpAdapter {
                     ...(tool.icon ? { icon: tool.icon } : {}),
                 };
             }
-            else if (tool.type === "filesystem") {
-                // Filesystem is a tool group - dynamically get children
-                const children = getToolGroupChildren("filesystem");
-                return {
-                    name: "filesystem",
-                    description: "File system access tools",
-                    ...(children ? { children } : {}),
-                };
-            }
             else if (tool.type === "custom") {
                 // Custom tools from module paths - extract name from path
                 const pathParts = tool.modulePath.split("/");
@@ -1221,6 +1226,17 @@ export class AgentAcpAdapter {
                     }
                     : null,
             });
+            // Create emitUpdate callback for tools to emit session updates
+            const emitUpdate = (update) => {
+                logger.debug("Adapter emitting session update", {
+                    sessionId: params.sessionId,
+                    updateType: update?.sessionUpdate,
+                });
+                this.connection.sessionUpdate({
+                    sessionId: params.sessionId,
+                    update: update,
+                });
+            };
             const invokeParams = {
                 prompt: params.prompt,
                 sessionId: params.sessionId,
@@ -1231,6 +1247,8 @@ export class AgentAcpAdapter {
                 contextMessages,
                 // Pass abort signal for cancellation
                 abortSignal: session.pendingPrompt?.signal,
+                // Pass emitUpdate callback for file change events
+                emitUpdate,
             };
             // Only add sessionMeta if it's defined
             if (session.requestParams._meta) {
@@ -1664,6 +1682,26 @@ export class AgentAcpAdapter {
                                             tokensSaved: hookResult.metadata.tokensSaved,
                                             summaryTokens: hookResult.metadata.summaryTokens,
                                         });
+                                        // Generate hookId for the notification pair
+                                        const hookId = `hook_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+                                        // Send hook_triggered notification immediately to show "Compacting Context..."
+                                        // This uses the same visualization as regular context compaction
+                                        this.connection.sessionUpdate({
+                                            sessionId: params.sessionId,
+                                            update: {
+                                                sessionUpdate: "hook_notification",
+                                                id: hookId,
+                                                notification: {
+                                                    type: "hook_triggered",
+                                                    hookType: "context_size",
+                                                    callback: "compaction_tool",
+                                                    metadata: {
+                                                        midTurn: true,
+                                                    },
+                                                    triggeredAt: Date.now(),
+                                                },
+                                            },
+                                        });
                                         // Store the pending tool output in session for replay after restart
                                         // We'll include this as part of the compacted context
                                         session.pendingToolOutput = {
@@ -1673,7 +1711,8 @@ export class AgentAcpAdapter {
                                         };
                                         // Throw an error to abort the current turn
                                         // The handlePrompt method will catch this and restart
-                                        throw new MidTurnRestartError("Context compacted mid-turn, restart required", hookResult.newContextEntry);
+                                        // Pass the hookId so the catch block can send the hook_completed notification
+                                        throw new MidTurnRestartError("Context compacted mid-turn, restart required", hookResult.newContextEntry, hookId);
                                     }
                                 }
                             }
@@ -1946,14 +1985,26 @@ export class AgentAcpAdapter {
                 });
                 // Clear the pending tool output since it's now part of the context
                 delete session.pendingToolOutput;
-                // Notify UI that a restart is happening
+                // Send hook_completed notification to mark compaction as done
+                // The hook_triggered notification was already sent before the error was thrown
+                const summaryTokens = err.newContextEntry.context_size?.totalEstimated ?? 0;
                 this.connection.sessionUpdate({
                     sessionId: params.sessionId,
                     update: {
-                        sessionUpdate: "agent_message_chunk",
-                        content: {
-                            type: "text",
-                            text: "\n\n---\n*Context compacted mid-turn. Continuing from summary...*\n\n",
+                        sessionUpdate: "hook_notification",
+                        id: err.hookId,
+                        notification: {
+                            type: "hook_completed",
+                            hookType: "context_size",
+                            callback: "compaction_tool",
+                            metadata: {
+                                action: "compacted",
+                                midTurn: true,
+                                messagesRemoved: err.newContextEntry.compactedUpTo ?? 0,
+                                summaryTokens,
+                                summaryGenerated: true,
+                            },
+                            completedAt: Date.now(),
                         },
                     },
                 });
@@ -1961,6 +2012,35 @@ export class AgentAcpAdapter {
                 // _promptImpl will resolve the updated context from session.context
                 return this._promptImpl(params);
             }
+            // Handle context overflow with compaction and retry
+            if (err instanceof ContextOverflowError) {
+                // Track retry count to prevent infinite loops (max 3 retries)
+                const retryCount = session
+                    ._overflowRetryCount ?? 0;
+                if (retryCount >= 3) {
+                    logger.error("Max overflow retry count reached - giving up", {
+                        sessionId: params.sessionId,
+                        retryCount,
+                    });
+                    throw err.originalError;
+                }
+                session._overflowRetryCount = retryCount + 1;
+                logger.warn("Context overflow detected - forcing compaction and retry", {
+                    sessionId: params.sessionId,
+                    retryAttempt: retryCount + 1,
+                });
+                // Force compaction
+                const compactionResult = await this.forceCompaction(session, params.sessionId);
+                if (compactionResult.success) {
+                    // Retry with compacted context
+                    return this._promptImpl(params);
+                }
+                // Compaction failed - throw original error
+                logger.error("Force compaction failed", {
+                    sessionId: params.sessionId,
+                });
+                throw err.originalError;
+            }
             throw err;
         }
         // Store the complete assistant response in session messages
@@ -2035,6 +2115,79 @@ export class AgentAcpAdapter {
             stopReason: "end_turn",
         };
     }
+    /**
+     * Force compaction of the session context.
+     * Used for error recovery when the Claude API returns "prompt is too long".
+     * This bypasses the normal threshold check and always compacts.
+     */
+    async forceCompaction(session, sessionId) {
+        logger.info("Force compaction started", {
+            sessionId,
+            messageCount: session.messages.length,
+            contextEntries: session.context.length,
+        });
+        try {
+            // Create a hook configuration that forces compaction
+            // Using callbacks array which accepts Record<string, unknown> for settings
+            const forceCompactionHook = {
+                type: "context_size",
+                callbacks: [
+                    {
+                        name: "compaction_tool",
+                        setting: {
+                            forceCompact: true,
+                        },
+                    },
+                ],
+            };
+            // Create notification callback
+            const sendHookNotification = (notification) => {
+                this.connection.sessionUpdate({
+                    sessionId,
+                    update: {
+                        sessionUpdate: "hook_notification",
+                        id: `hook_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
+                        notification,
+                    },
+                });
+            };
+            // Create hook executor with force compaction settings
+            const hookExecutor = new HookExecutor([forceCompactionHook], this.agent.definition.model, (callbackRef) => loadHookCallback(callbackRef, this.agentDir), sendHookNotification, this.agent.definition);
+            // Create read-only session view for hooks
+            const readonlySession = {
+                messages: session.messages,
+                context: session.context,
+                requestParams: session.requestParams,
+            };
+            // Get current token estimate - use a high value to ensure compaction triggers
+            const latestContext = session.context.length > 0
+                ? session.context[session.context.length - 1]
+                : undefined;
+            const currentTokens = latestContext?.context_size.totalEstimated ?? 0;
+            // Execute hooks
+            const hookResult = await hookExecutor.executeHooks(readonlySession, currentTokens);
+            // Apply new context entries
+            if (hookResult.newContextEntries.length > 0) {
+                session.context.push(...hookResult.newContextEntries);
+                logger.info("Force compaction succeeded", {
+                    sessionId,
+                    newContextEntries: hookResult.newContextEntries.length,
+                });
+                return { success: true };
+            }
+            logger.warn("Force compaction produced no new context entries", {
+                sessionId,
+            });
+            return { success: false };
+        }
+        catch (error) {
+            logger.error("Force compaction error", {
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return { success: false };
+        }
+    }
     /**
      * Execute hooks if configured for this agent
      * Returns new context entries that should be appended to session.context

package/dist/acp-server/http.js

@@ -9,6 +9,7 @@ import { cors } from "hono/cors";
 import { streamSSE } from "hono/streaming";
 import { createLogger, isSubagent } from "../logger.js";
 import { makeRunnerFromDefinition } from "../runner";
+import { destroySessionSandbox, getExistingSandbox, hasSessionSandbox, } from "../runner/e2b-sandbox-manager";
 import { AgentAcpAdapter } from "./adapter";
 import { SessionStorage } from "./session-storage";
 const logger = createLogger("http");
@@ -510,6 +511,151 @@ export function createAcpHttpApp(agent, agentDir, agentName) {
             }, 500);
         }
     });
+    // Sandbox file listing endpoints
+    app.get("/sandbox/status", async (c) => {
+        const sessionId = c.req.query("sessionId");
+        if (!sessionId || typeof sessionId !== "string") {
+            return c.json({ error: "sessionId required" }, 400);
+        }
+        try {
+            const status = hasSessionSandbox(sessionId) ? "ready" : "none";
+            return c.json({ status });
+        }
+        catch (error) {
+            logger.error("Error checking sandbox status", { error, sessionId });
+            return c.json({ error: "Failed to check sandbox status" }, 500);
+        }
+    });
+    app.get("/sandbox/files", async (c) => {
+        const sessionId = c.req.query("sessionId");
+        const path = c.req.query("path") || "/home/user";
+        if (!sessionId || typeof sessionId !== "string") {
+            return c.json({ error: "sessionId required" }, 400);
+        }
+        try {
+            // Check if sandbox exists
+            if (!hasSessionSandbox(sessionId)) {
+                return c.json({ files: [] }); // No sandbox yet
+            }
+            // Get existing sandbox by sessionId
+            const sandbox = getExistingSandbox(sessionId);
+            if (!sandbox) {
+                return c.json({ files: [] }); // Sandbox no longer exists
+            }
+            // List directory using find command with detailed info
+            const result = await sandbox.commands.run(`find "${path}" -maxdepth 1 -printf '%p\\t%s\\t%T@\\t%y\\n' 2>/dev/null || echo ""`);
+            if (result.exitCode !== 0 && result.stderr) {
+                logger.warn("Error listing sandbox files", {
+                    sessionId,
+                    path,
+                    stderr: result.stderr,
+                });
+                return c.json({ files: [] });
+            }
+            // Parse output
+            const files = result.stdout
+                .split("\n")
+                .filter((line) => line.trim())
+                .map((line) => {
+                const [fullPath, size, mtime, type] = line.split("\t");
+                // Skip if any required field is missing
+                if (!fullPath || !size || !mtime || !type)
+                    return null;
+                const name = fullPath.split("/").pop() || "";
+                // Skip . and .. entries, hidden files (starting with .), and the root path itself
+                if (name === "." ||
+                    name === ".." ||
+                    name.startsWith(".") ||
+                    fullPath === path)
+                    return null;
+                return {
+                    name,
+                    path: fullPath,
+                    type: type === "d" ? "dir" : "file",
+                    size: Number.parseInt(size, 10) || 0,
+                    lastModified: Number.parseFloat(mtime) * 1000,
+                };
+            })
+                .filter(Boolean); // Remove null entries
+            return c.json({ files });
+        }
+        catch (error) {
+            // Handle NotFoundError - sandbox no longer exists on E2B
+            if (error &&
+                typeof error === "object" &&
+                "name" in error &&
+                error.name === "NotFoundError") {
+                logger.warn("Sandbox not found on E2B, cleaning up local reference", {
+                    sessionId,
+                });
+                // Remove stale sandbox from local cache
+                await destroySessionSandbox(sessionId);
+                return c.json({ files: [] });
+            }
+            logger.error("Error listing sandbox files", { error, sessionId, path });
+            return c.json({ error: "Failed to list sandbox files" }, 500);
+        }
+    });
+    // Download file content from sandbox
+    app.get("/sandbox/download", async (c) => {
+        const sessionId = c.req.query("sessionId");
+        const filePath = c.req.query("path");
+        if (!sessionId || typeof sessionId !== "string") {
+            return c.json({ error: "sessionId required" }, 400);
+        }
+        if (!filePath || typeof filePath !== "string") {
+            return c.json({ error: "path required" }, 400);
+        }
+        try {
+            // Check if sandbox exists
+            if (!hasSessionSandbox(sessionId)) {
+                return c.json({ error: "Sandbox not found" }, 404);
+            }
+            // Get existing sandbox by sessionId
+            const sandbox = getExistingSandbox(sessionId);
+            if (!sandbox) {
+                return c.json({ error: "Sandbox no longer exists" }, 404);
+            }
+            // Read file content using cat command
+            const result = await sandbox.commands.run(`cat "${filePath}"`);
+            if (result.exitCode !== 0) {
+                logger.warn("Error reading sandbox file", {
+                    sessionId,
+                    filePath,
+                    stderr: result.stderr,
+                });
+                return c.json({ error: "Failed to read file" }, 500);
+            }
+            const fileName = filePath.split("/").pop() || "download";
+            // Return the file content
+            return new Response(result.stdout, {
+                headers: {
+                    "Content-Type": "application/octet-stream",
+                    "Content-Disposition": `attachment; filename="${fileName}"`,
+                },
+            });
+        }
+        catch (error) {
+            // Handle NotFoundError - sandbox no longer exists on E2B
+            if (error &&
+                typeof error === "object" &&
+                "name" in error &&
+                error.name === "NotFoundError") {
+                logger.warn("Sandbox not found on E2B, cleaning up local reference", {
+                    sessionId,
+                });
+                // Remove stale sandbox from local cache
+                await destroySessionSandbox(sessionId);
+                return c.json({ error: "Sandbox not found" }, 404);
+            }
+            logger.error("Error downloading sandbox file", {
+                error,
+                sessionId,
+                filePath,
+            });
+            return c.json({ error: "Failed to download file" }, 500);
+        }
+    });
     // Serve static files from agent directory (for generated images, etc.)
     if (agentDir) {
         app.get("/static/*", async (c) => {

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

@@ -136,6 +136,8 @@ export interface SessionMetadata {
     createdAt: string;
     updatedAt: string;
     agentName: string;
+    /** E2B sandbox ID for persistent sandbox reconnection */
+    sandboxId?: string | undefined;
 }
 /**
  * Complete session data stored in JSON files
@@ -237,4 +239,13 @@ export declare class SessionStorage {
      * Check if original content exists for a tool call
      */
     hasToolOriginal(sessionId: string, toolName: string, toolCallId: string): boolean;
+    /**
+     * Update sandbox ID for a session
+     * Used when creating/reconnecting to E2B sandboxes
+     */
+    updateSandboxId(sessionId: string, sandboxId: string | undefined): Promise<void>;
+    /**
+     * Get sandbox ID for a session
+     */
+    getSandboxId(sessionId: string): string | undefined;
 }

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

@@ -131,6 +131,7 @@ const sessionMetadataSchema = z.object({
     createdAt: z.string(),
     updatedAt: z.string(),
     agentName: z.string(),
+    sandboxId: z.string().optional(),
 });
 const storedSessionSchema = z.object({
     sessionId: z.string(),
@@ -404,4 +405,48 @@ export class SessionStorage {
     hasToolOriginal(sessionId, toolName, toolCallId) {
         return existsSync(this.getToolOriginalPath(sessionId, toolName, toolCallId));
     }
+    /**
+     * Update sandbox ID for a session
+     * Used when creating/reconnecting to E2B sandboxes
+     */
+    async updateSandboxId(sessionId, sandboxId) {
+        const session = this.loadSessionSync(sessionId);
+        if (!session) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        // Update metadata with new sandboxId and save the session
+        const updatedSession = {
+            ...session,
+            metadata: {
+                ...session.metadata,
+                sandboxId,
+                updatedAt: new Date().toISOString(),
+            },
+        };
+        // Use atomic write (write to temp file, then rename)
+        this.ensureSessionDir(sessionId);
+        const sessionPath = this.getSessionPath(sessionId);
+        const tempPath = `${sessionPath}.tmp`;
+        try {
+            writeFileSync(tempPath, JSON.stringify(updatedSession, null, 2), "utf-8");
+            if (existsSync(sessionPath)) {
+                unlinkSync(sessionPath);
+            }
+            writeFileSync(sessionPath, readFileSync(tempPath, "utf-8"), "utf-8");
+            unlinkSync(tempPath);
+        }
+        catch (error) {
+            if (existsSync(tempPath)) {
+                unlinkSync(tempPath);
+            }
+            throw new Error(`Failed to update sandboxId for session ${sessionId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Get sandbox ID for a session
+     */
+    getSandboxId(sessionId) {
+        const session = this.loadSessionSync(sessionId);
+        return session?.metadata.sandboxId;
+    }
 }

package/dist/runner/agent-runner.d.ts

@@ -9,12 +9,9 @@ export declare const zAgentRunnerParams: z.ZodObject<{
     suggestedPrompts: z.ZodOptional<z.ZodArray<z.ZodString>>;
     systemPrompt: z.ZodNullable<z.ZodString>;
     model: z.ZodString;
-    tools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"artifacts">, z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">, z.ZodLiteral<"town_web_search">, z.ZodLiteral<"filesystem">, z.ZodLiteral<"generate_image">, z.ZodLiteral<"town_generate_image">, z.ZodLiteral<"browser">, z.ZodLiteral<"document_extract">, z.ZodLiteral<"code_sandbox">]>, z.ZodObject<{
+    tools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">, z.ZodLiteral<"town_web_search">, z.ZodLiteral<"browser">, z.ZodLiteral<"document_extract">, z.ZodLiteral<"code_sandbox">]>, z.ZodObject<{
         type: z.ZodLiteral<"custom">;
         modulePath: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"filesystem">;
-        working_directory: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"direct">;
         name: z.ZodString;
@@ -81,6 +78,16 @@ export interface SessionMessage {
     content: ContentBlock[];
     timestamp: string;
 }
+export interface SandboxFilesChangedNotification {
+    sessionUpdate: "sandbox_files_changed";
+    paths?: string[];
+    _meta?: {
+        source?: "tool" | "poll";
+        toolName?: string;
+        isReplay?: boolean;
+    };
+}
+export type SessionUpdateNotification = SandboxFilesChangedNotification;
 export interface ConfigOverrides {
     model?: string;
     systemPrompt?: string;
@@ -97,6 +104,8 @@ export type InvokeRequest = Omit<PromptRequest, "_meta"> & {
     abortSignal?: AbortSignal;
     /** Selected prompt parameters for this message. Maps parameter ID to selected option ID. */
     promptParameters?: Record<string, string>;
+    /** Callback for tools to emit session updates (e.g., file changes) */
+    emitUpdate?: (update: SessionUpdateNotification) => void;
 };
 export interface TokenUsage {
     inputTokens?: number;

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

@@ -2,16 +2,24 @@ 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.
  */
 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.
  */
 export declare function destroySessionSandbox(sessionId: string): Promise<void>;
 /**
  * Check if a session has an active sandbox.
  */
 export declare function hasSessionSandbox(sessionId: string): boolean;
+/**
+ * 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 declare function getExistingSandbox(sessionId: string): Sandbox | undefined;
 /**
  * Get the number of active sandboxes (for debugging/monitoring).
  */