@townco/agent 0.1.106 → 0.1.108

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

@@ -5,7 +5,7 @@ import { tool } from "langchain";
 import { z } from "zod";
 import { createLogger } from "../../../logger.js";
 import { getSessionSandbox } from "../../e2b-sandbox-manager";
-import { getSessionContext, getToolOutputDir, hasSessionContext, } from "../../session-context";
+import { getEmitUpdate, getSessionContext, getToolOutputDir, hasSessionContext, } from "../../session-context";
 const logger = createLogger("e2b-tools");
 // Cached API key from Town proxy
 let _cachedApiKey = null;
@@ -13,7 +13,7 @@ let _apiKeyFetchPromise = null;
 /**
  * Get E2B API key from Town proxy (with caching).
  */
-async function getTownE2BApiKey() {
+export async function getTownE2BApiKey() {
     if (_cachedApiKey) {
         return _cachedApiKey;
     }
@@ -89,7 +89,17 @@ function makeE2BToolsInternal(getSandbox) {
             if (result.error) {
                 if (output)
                     output += "\n";
-                output += `[error] ${result.error.name}: ${result.error.value}`;
+                // Include the full traceback if available
+                // E2B's ExecutionError has name, value, and traceback properties
+                const traceback = result.error.traceback;
+                if (traceback?.trim()) {
+                    // Traceback includes full error with line numbers
+                    output += `[error]\n${traceback}`;
+                }
+                else {
+                    // Fallback: construct a basic error message
+                    output += `[error] ${result.error.name}: ${result.error.value}`;
+                }
             }
             // Handle result value (charts, images, etc.)
             if (result.results && result.results.length > 0) {
@@ -116,6 +126,21 @@ function makeE2BToolsInternal(getSandbox) {
                     }
                 }
             }
+            // Emit file change notification (code might have created/modified files)
+            const emitUpdate = getEmitUpdate();
+            if (emitUpdate) {
+                logger.debug("Emitting sandbox_files_changed event from RunCode");
+                emitUpdate({
+                    sessionUpdate: "sandbox_files_changed",
+                    _meta: {
+                        source: "tool",
+                        toolName: "Sandbox_RunCode",
+                    },
+                });
+            }
+            else {
+                logger.warn("emitUpdate not available in RunCode - file change event not sent");
+            }
             return output.trim() || "(no output)";
         }
         catch (error) {
@@ -164,10 +189,38 @@ function makeE2BToolsInternal(getSandbox) {
             if (result.exitCode !== 0) {
                 output += `\n[exit code: ${result.exitCode}]`;
             }
+            // Emit file change notification (bash commands might have created/modified files)
+            const emitUpdate = getEmitUpdate();
+            if (emitUpdate) {
+                emitUpdate({
+                    sessionUpdate: "sandbox_files_changed",
+                    _meta: {
+                        source: "tool",
+                        toolName: "Sandbox_RunBash",
+                    },
+                });
+            }
             return output.trim() || "(no output)";
         }
         catch (error) {
             logger.error("Error executing bash command", { error });
+            // E2B may throw with stdout/stderr attached to the error
+            const e = error;
+            let output = "";
+            if (e.stdout) {
+                output += e.stdout;
+            }
+            if (e.stderr) {
+                if (output)
+                    output += "\n";
+                output += `[stderr]\n${e.stderr}`;
+            }
+            if (e.exitCode !== undefined) {
+                output += `\n[exit code: ${e.exitCode}]`;
+            }
+            if (output) {
+                return output.trim();
+            }
             return `Error executing command: ${error instanceof Error ? error.message : String(error)}`;
         }
     }, {
@@ -217,6 +270,24 @@ function makeE2BToolsInternal(getSandbox) {
         const sandbox = await getSandbox();
         try {
             await sandbox.files.write(filePath, content);
+            // Emit file change notification
+            const emitUpdate = getEmitUpdate();
+            if (emitUpdate) {
+                logger.debug("Emitting sandbox_files_changed event", { filePath });
+                emitUpdate({
+                    sessionUpdate: "sandbox_files_changed",
+                    paths: [filePath],
+                    _meta: {
+                        source: "tool",
+                        toolName: "Sandbox_WriteFile",
+                    },
+                });
+            }
+            else {
+                logger.warn("emitUpdate not available - file change event not sent", {
+                    filePath,
+                });
+            }
             return `Successfully wrote ${content.length} bytes to ${filePath}`;
         }
         catch (error) {
@@ -236,62 +307,110 @@ function makeE2BToolsInternal(getSandbox) {
     writeSandboxFile.prettyName = "Write Sandbox File";
     // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
     writeSandboxFile.icon = "Edit";
-    // Tool 5: Download File from Sandbox to Artifacts
-    const downloadFromSandbox = tool(async ({ sandboxPath, fileName }) => {
+    // Tool 5: Share File from Sandbox (download to artifacts, upload to Supabase)
+    const shareSandboxFile = tool(async ({ sandboxPath, fileName }) => {
         if (!hasSessionContext()) {
-            throw new Error("Sandbox_DownloadFile requires session context");
+            throw new Error("Sandbox_Share requires session context");
         }
         const sandbox = await getSandbox();
+        const { sessionId } = getSessionContext();
         const toolOutputDir = getToolOutputDir("E2B");
         try {
-            // Read file from sandbox
-            const content = await sandbox.files.read(sandboxPath);
-            // Determine output filename
+            // Step 1: Download from sandbox to local artifacts
+            // Use base64 encoding to safely transfer binary data
+            const result = await sandbox.commands.run(`base64 ${sandboxPath}`);
+            if (result.exitCode !== 0) {
+                throw new Error(`Failed to read file: ${result.stderr}`);
+            }
             const outputFileName = fileName || path.basename(sandboxPath);
             const outputPath = path.join(toolOutputDir, outputFileName);
-            // Ensure directory exists
             await fs.mkdir(toolOutputDir, { recursive: true });
-            // Write to artifacts
-            await fs.writeFile(outputPath, content);
-            // Generate URL for display
-            const { sessionId } = getSessionContext();
-            const port = process.env.PORT || "3100";
-            const hostname = process.env.BIND_HOST || "localhost";
-            const baseUrl = process.env.AGENT_BASE_URL || `http://${hostname}:${port}`;
-            const fileUrl = `${baseUrl}/static/.sessions/${sessionId}/artifacts/tool-E2B/${outputFileName}`;
-            return `Downloaded ${sandboxPath} to artifacts.\nURL: ${fileUrl}`;
+            // Decode base64 and write binary file
+            const fileBuffer = Buffer.from(result.stdout.trim(), "base64");
+            await fs.writeFile(outputPath, fileBuffer);
+            // Step 2: Upload to Supabase Storage
+            const shedAuth = getShedAuth();
+            if (!shedAuth) {
+                // Fallback to local URL if not authenticated
+                const port = process.env.PORT || "3100";
+                const hostname = process.env.BIND_HOST || "localhost";
+                const baseUrl = process.env.AGENT_BASE_URL || `http://${hostname}:${port}`;
+                const localUrl = `${baseUrl}/static/.sessions/${sessionId}/artifacts/tool-E2B/${outputFileName}`;
+                return `File saved locally: ${localUrl}\n\n(Login with 'town login' to enable public sharing via Supabase)`;
+            }
+            // Get signed upload URL from Shed
+            const storagePath = `shared/${outputFileName}`;
+            const uploadUrlResponse = await fetch(`${shedAuth.shedUrl}/api/artifacts/url?key=${encodeURIComponent(storagePath)}&upload=true&kind=user`, {
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-api-key": shedAuth.accessToken,
+                },
+            });
+            if (!uploadUrlResponse.ok) {
+                throw new Error(`Failed to get upload URL: ${await uploadUrlResponse.text()}`);
+            }
+            const { url: uploadUrl } = await uploadUrlResponse.json();
+            // Upload file to Supabase
+            const fileContent = await fs.readFile(outputPath);
+            const uploadResponse = await fetch(uploadUrl, {
+                method: "PUT",
+                body: fileContent,
+                headers: {
+                    "Content-Type": "application/octet-stream",
+                },
+            });
+            if (!uploadResponse.ok) {
+                throw new Error(`Upload failed: ${await uploadResponse.text()}`);
+            }
+            // Get public signed URL
+            const publicUrlResponse = await fetch(`${shedAuth.shedUrl}/api/artifacts/url?key=${encodeURIComponent(storagePath)}&kind=user`, {
+                headers: {
+                    "x-api-key": shedAuth.accessToken,
+                },
+            });
+            if (!publicUrlResponse.ok) {
+                throw new Error(`Failed to get public URL: ${await publicUrlResponse.text()}`);
+            }
+            const { url: publicUrl } = await publicUrlResponse.json();
+            return `File shared successfully!\n\nPublic URL: ${publicUrl}`;
         }
         catch (error) {
-            logger.error("Error downloading file from sandbox", {
-                error,
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const errorStack = error instanceof Error ? error.stack : undefined;
+            logger.error("Error sharing file from sandbox", {
+                error: errorMessage,
+                stack: errorStack,
                 sandboxPath,
             });
-            return `Error downloading file: ${error instanceof Error ? error.message : String(error)}`;
+            return `Error sharing file: ${errorMessage}`;
         }
     }, {
-        name: "Sandbox_DownloadFile",
-        description: "Download a file from the cloud sandbox to the session's artifacts directory. " +
-            "Use to save generated files, plots, or outputs for the user to access.",
+        name: "Sandbox_Share",
+        description: "Share a file from the sandbox by uploading to Supabase Storage. " +
+            "Returns a public URL that can be shared with others. " +
+            "Files are downloaded from sandbox to local artifacts, then uploaded to cloud storage.",
         schema: z.object({
-            sandboxPath: z.string().describe("Path to the file in the sandbox"),
+            sandboxPath: z
+                .string()
+                .describe("Path to file in sandbox (e.g., /home/user/output.png)"),
             fileName: z
                 .string()
                 .optional()
-                .describe("Optional output filename (defaults to original name)"),
+                .describe("Optional filename for shared file (defaults to original name)"),
         }),
     });
     // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
-    downloadFromSandbox.prettyName = "Download from Sandbox";
+    shareSandboxFile.prettyName = "Share from Sandbox";
     // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
-    downloadFromSandbox.icon = "Download";
+    shareSandboxFile.icon = "Share";
     // Tool 6: Upload Library Document to Sandbox
     const uploadLibraryDocument = tool(async ({ document_id }) => {
         const sandbox = await getSandbox();
         try {
             const libraryApiUrl = process.env.LIBRARY_API_URL;
-            const libraryApiKey = process.env.LIBRARY_ROOT_API_KEY;
+            const libraryApiKey = process.env.LIBRARY_API_KEY;
             if (!libraryApiUrl || !libraryApiKey) {
-                throw new Error("LIBRARY_API_URL and LIBRARY_ROOT_API_KEY environment variables are required");
+                throw new Error("LIBRARY_API_URL and LIBRARY_API_KEY environment variables are required");
             }
             const response = await fetch(`${libraryApiUrl}/sandbox/upload_document_to_sandbox`, {
                 method: "POST",
@@ -338,13 +457,185 @@ function makeE2BToolsInternal(getSandbox) {
         past: "Uploaded document {document_id}",
         paramKey: "document_id",
     };
+    // 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
+                .replace(/\\/g, "\\\\")
+                .replace(/"/g, '\\"')
+                .replace(/\n/g, "\\n");
+            const apiKey = process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY || "";
+            if (!apiKey) {
+                return "Error: GEMINI_API_KEY or GOOGLE_API_KEY environment variable is required for image generation";
+            }
+            const escapedApiKey = apiKey
+                .replace(/\\/g, "\\\\")
+                .replace(/"/g, '\\"');
+            const script = `
+const { GoogleGenAI } = require('@google/genai');
+
+async function generateImage() {
+  try {
+    const client = new GoogleGenAI({ apiKey: "${escapedApiKey}" });
+
+    const response = await client.models.generateContent({
+      model: "gemini-3-pro-image-preview",
+      contents: [{ text: "${escapedPrompt}" }],
+      config: {
+        responseModalities: ["TEXT", "IMAGE"],
+      },
+    });
+
+    if (!response.candidates || response.candidates.length === 0) {
+      console.log(JSON.stringify({ error: "No response from the model" }));
+      process.exit(1);
+    }
+
+    const candidate = response.candidates[0];
+    if (!candidate.content || !candidate.content.parts) {
+      console.log(JSON.stringify({ error: "No content parts in response" }));
+      process.exit(1);
+    }
+
+    let imageData = null;
+    let mimeType = "image/png";
+
+    // Debug: log the structure we're getting
+    console.error("DEBUG parts:", JSON.stringify(candidate.content.parts.map(p => ({
+      hasText: !!p.text,
+      hasInlineData: !!p.inlineData,
+      inlineDataKeys: p.inlineData ? Object.keys(p.inlineData) : []
+    }))));
+
+    for (const part of candidate.content.parts) {
+      if (part.inlineData && part.inlineData.data) {
+        imageData = part.inlineData.data;
+        mimeType = part.inlineData.mimeType || "image/png";
+        console.error("DEBUG found image, mimeType:", mimeType);
+        console.error("DEBUG imageData type:", typeof imageData);
+        console.error("DEBUG imageData isBuffer:", Buffer.isBuffer(imageData));
+        console.error("DEBUG imageData length:", imageData.length);
+        console.error("DEBUG first 50 chars:", imageData.toString().substring(0, 50));
+        break;
+      }
+    }
+
+    if (!imageData) {
+      console.log(JSON.stringify({
+        error: "No image in response",
+        parts: candidate.content.parts
+      }));
+      process.exit(1);
+    }
+
+    // Save image
+    const fs = require('fs');
+    const ext = mimeType === 'image/jpeg' ? 'jpg' : 'png';
+    const path = \`/home/user/generated_image.\${ext}\`;
+    const buffer = Buffer.from(imageData, 'base64');
+    fs.writeFileSync(path, buffer);
+    console.error("DEBUG wrote file, size:", buffer.length);
+
+    console.log(JSON.stringify({ success: true, path }));
+  } catch (error) {
+    console.log(JSON.stringify({
+      error: error.message,
+      stack: error.stack
+    }));
+    process.exit(1);
+  }
+}
+
+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");
+            logger.info("Image generation command result", {
+                exitCode: result.exitCode,
+                stdout: result.stdout,
+                stderr: result.stderr,
+            });
+            if (result.exitCode !== 0) {
+                // Try to parse JSON error from stderr (where our script outputs errors)
+                try {
+                    const errorOutput = JSON.parse(result.stderr);
+                    logger.error("Image generation failed (parsed)", { errorOutput });
+                    const errorMsg = errorOutput.error || "Unknown error";
+                    const traceback = errorOutput.traceback
+                        ? `\n\nTraceback:\n${errorOutput.traceback}`
+                        : "";
+                    return `Image generation failed: ${errorMsg}${traceback}`;
+                }
+                catch {
+                    // If JSON parsing fails, try stdout, then show raw output
+                    try {
+                        const errorOutput = JSON.parse(result.stdout);
+                        logger.error("Image generation failed (parsed from stdout)", {
+                            errorOutput,
+                        });
+                        return `Image generation failed: ${errorOutput.error || "Unknown error"}`;
+                    }
+                    catch {
+                        // Show raw output
+                        logger.error("Image generation failed (raw)", {
+                            stdout: result.stdout,
+                            stderr: result.stderr,
+                        });
+                        return `Image generation failed (exit code ${result.exitCode}):\nStderr: ${result.stderr}\nStdout: ${result.stdout}`;
+                    }
+                }
+            }
+            const output = JSON.parse(result.stdout);
+            if (output.error) {
+                logger.error("Image generation returned error", {
+                    error: output.error,
+                });
+                return `Image generation failed: ${output.error}`;
+            }
+            logger.info("Image generated successfully", { path: output.path });
+            return `Image generated successfully at ${output.path}. Use Sandbox_Share to download and share it.`;
+        }
+        catch (error) {
+            logger.error("Error generating image (exception)", {
+                error,
+                message: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            return `Error generating image: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }, {
+        name: "Sandbox_GenerateImage",
+        description: "Generate an image using Google Gemini in the sandbox. " +
+            "Image is saved to sandbox filesystem at /home/user/. " +
+            "Use Sandbox_Share to download and share it with the user.",
+        schema: z.object({
+            prompt: z
+                .string()
+                .describe("Detailed description of the image to generate"),
+        }),
+    });
+    // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
+    generateImage.prettyName = "Generate Image";
+    // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
+    generateImage.icon = "Image";
+    // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
+    generateImage.verbiage = {
+        active: "Generating image",
+        past: "Generated image",
+        paramKey: "prompt",
+    };
     return [
         runCode,
         runBash,
         readSandboxFile,
         writeSandboxFile,
-        downloadFromSandbox,
+        shareSandboxFile,
         uploadLibraryDocument,
+        generateImage,
     ];
 }
 /**

package/dist/runner/session-context.d.ts

@@ -1,3 +1,4 @@
+import type { SessionUpdateNotification } from "./agent-runner.js";
 /**
  * Session context available to tools during agent execution.
  * This provides deterministic, session-scoped file storage.
@@ -10,6 +11,11 @@ export interface SessionContext {
     /** Artifacts directory: <agentDir>/.sessions/<sessionId>/artifacts */
     artifactsDir: string;
 }
+/**
+ * EmitUpdate callback context for tools to emit session updates.
+ * Tools can access this to emit events like sandbox file changes.
+ */
+type EmitUpdateCallback = (update: SessionUpdateNotification) => void;
 /**
  * Run a function with an abort signal available via AsyncLocalStorage.
  * Tools can access the signal using getAbortSignal().
@@ -30,6 +36,16 @@ export declare function getAbortSignal(): AbortSignal | undefined;
  * Returns false if no abort signal is available.
  */
 export declare function isAborted(): boolean;
+/**
+ * Get the current emitUpdate callback.
+ * Returns undefined if called outside of an emitUpdate context.
+ */
+export declare function getEmitUpdate(): EmitUpdateCallback | undefined;
+/**
+ * Bind an async generator to an emitUpdate callback context so that every iteration
+ * runs with the emitUpdate callback available.
+ */
+export declare function bindGeneratorToEmitUpdate<T, R, N = unknown>(emitUpdate: EmitUpdateCallback, generator: AsyncGenerator<T, R, N>): AsyncGenerator<T, R, N>;
 /**
  * Run a function with session context available via AsyncLocalStorage.
  * Tools can access the context using getSessionContext().
@@ -58,3 +74,4 @@ export declare function hasSessionContext(): boolean;
  * @returns Absolute path to the tool's output directory
  */
 export declare function getToolOutputDir(toolName: string): string;
+export {};

package/dist/runner/session-context.js

@@ -6,6 +6,7 @@ const sessionStorage = new AsyncLocalStorage();
  * Tools can access this to check if the current operation has been cancelled.
  */
 const abortSignalStorage = new AsyncLocalStorage();
+const emitUpdateStorage = new AsyncLocalStorage();
 /**
  * Run a function with an abort signal available via AsyncLocalStorage.
  * Tools can access the signal using getAbortSignal().
@@ -55,6 +56,40 @@ export function isAborted() {
     const signal = abortSignalStorage.getStore();
     return signal?.aborted ?? false;
 }
+/**
+ * Get the current emitUpdate callback.
+ * Returns undefined if called outside of an emitUpdate context.
+ */
+export function getEmitUpdate() {
+    return emitUpdateStorage.getStore();
+}
+/**
+ * Bind an async generator to an emitUpdate callback context so that every iteration
+ * runs with the emitUpdate callback available.
+ */
+export function bindGeneratorToEmitUpdate(emitUpdate, generator) {
+    const boundNext = (value) => emitUpdateStorage.run(emitUpdate, () => generator.next(value));
+    const boundReturn = generator.return
+        ? (value) => emitUpdateStorage.run(emitUpdate, () => generator.return?.(value))
+        : undefined;
+    const boundThrow = generator.throw
+        ? (e) => emitUpdateStorage.run(emitUpdate, () => generator.throw?.(e))
+        : undefined;
+    const boundGenerator = {
+        next: boundNext,
+        return: boundReturn,
+        throw: boundThrow,
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+        [Symbol.asyncDispose]: async () => {
+            if (Symbol.asyncDispose in generator) {
+                await generator[Symbol.asyncDispose]();
+            }
+        },
+    };
+    return boundGenerator;
+}
 /**
  * Run a function with session context available via AsyncLocalStorage.
  * Tools can access the context using getSessionContext().

package/dist/runner/tools.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 /** Built-in tool types. */
-export declare const zBuiltInToolType: 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">]>;
+export declare const zBuiltInToolType: 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">]>;
 /** Subagent configuration schema for Task tools. */
 export declare const zSubagentConfig: z.ZodObject<{
     agentName: z.ZodString;
@@ -23,12 +23,9 @@ declare const zDirectTool: z.ZodObject<{
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 /** Tool type - can be a built-in tool string or custom tool object. */
-export declare const zToolType: 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<{
+export declare const zToolType: 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;

package/dist/runner/tools.js

@@ -1,14 +1,10 @@
 import { z } from "zod";
 /** Built-in tool types. */
 export const zBuiltInToolType = z.union([
-    z.literal("artifacts"),
     z.literal("todo_write"),
     z.literal("get_weather"),
     z.literal("web_search"),
     z.literal("town_web_search"),
-    z.literal("filesystem"),
-    z.literal("generate_image"),
-    z.literal("town_generate_image"),
     z.literal("browser"),
     z.literal("document_extract"),
     z.literal("code_sandbox"),
@@ -18,11 +14,6 @@ const zCustomTool = z.object({
     type: z.literal("custom"),
     modulePath: z.string(),
 });
-/** Filesystem tool schema. */
-const zFilesystemTool = z.object({
-    type: z.literal("filesystem"),
-    working_directory: z.string().optional(),
-});
 /** Subagent configuration schema for Task tools. */
 export const zSubagentConfig = z.object({
     agentName: z.string(),
@@ -42,9 +33,4 @@ const zDirectTool = z.object({
     subagentConfigs: z.array(zSubagentConfig).optional(),
 });
 /** Tool type - can be a built-in tool string or custom tool object. */
-export const zToolType = z.union([
-    zBuiltInToolType,
-    zCustomTool,
-    zFilesystemTool,
-    zDirectTool,
-]);
+export const zToolType = z.union([zBuiltInToolType, zCustomTool, zDirectTool]);