@axiom-lattice/core 2.1.45 → 2.1.47

package/dist/index.mjs

@@ -648,11 +648,11 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
    * @param key Lattice键名
    * @param tool 已有的StructuredTool实例
    */
-  registerExistingTool(key, tool50) {
+  registerExistingTool(key, tool51) {
     const config = {
-      name: tool50.name,
-      description: tool50.description,
-      schema: tool50.schema,
+      name: tool51.name,
+      description: tool51.description,
+      schema: tool51.schema,
       // StructuredTool的schema已经是Zod兼容的
       needUserApprove: false
       // MCP工具默认不需要用户批准
@@ -660,7 +660,7 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
     const toolLattice = {
       key,
       config,
-      client: tool50
+      client: tool51
     };
     this.register(key, toolLattice);
   }
@@ -686,7 +686,7 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
 };
 var toolLatticeManager = ToolLatticeManager.getInstance();
 var registerToolLattice = (key, config, executor) => toolLatticeManager.registerLattice(key, config, executor);
-var registerExistingTool = (key, tool50) => toolLatticeManager.registerExistingTool(key, tool50);
+var registerExistingTool = (key, tool51) => toolLatticeManager.registerExistingTool(key, tool51);
 var getToolLattice = (key) => toolLatticeManager.getToolLattice(key);
 var getToolDefinition = (key) => toolLatticeManager.getToolDefinition(key);
 var getToolClient = (key) => toolLatticeManager.getToolClient(key);
@@ -4649,516 +4649,241 @@ var createReactAgentSchema = (schema) => {
 // src/agent_lattice/builders/ReActAgentGraphBuilder.ts
 import { createAgent } from "langchain";
 
-// src/deep_agent_new/backends/sandboxFiles.ts
-import { SandboxClient as SandboxClient2 } from "@agent-infra/sandbox";
-import * as path2 from "path";
-var SandboxFilesystem = class {
-  /**
-   * Create a new SandboxFilesystem instance.
-   *
-   * @param options - Configuration options
-   * @param options.baseURL - Base URL of the sandbox service (default: 'http://localhost:8080')
-   * @param options.maxFileSizeMb - Maximum file size in MB (default: 10)
-   * @param options.sandboxInstance - Optional Sandbox instance (if provided, baseURL is ignored)
-   */
-  constructor(options = {}) {
-    const {
-      baseURL = "http://localhost:8080",
-      workingDirectory = "/",
-      maxFileSizeMb = 10,
-      sandboxInstance
-    } = options;
-    this.sandbox = sandboxInstance || new SandboxClient2({ baseUrl: baseURL, environment: "" });
-    this.sandbox.mcp.listMcpServers().then((servers) => {
-    });
-    this.sandbox.mcp.listMcpTools("browser").then((tools) => {
+// src/middlewares/codeEvalMiddleware.ts
+import { createMiddleware } from "langchain";
+
+// src/middlewares/contextSchema.ts
+import z40 from "zod";
+var contextSchema = z40.object({
+  runConfig: z40.any()
+});
+
+// src/middlewares/codeEvalMiddleware.ts
+function createCodeEvalMiddleware(params = { isolatedLevel: "global" }) {
+  const codeEvalTool = createCodeEvalTool({ isolatedLevel: params.isolatedLevel });
+  const codeExecuteFileTool = createCodeExecuteFileTool({ isolatedLevel: params.isolatedLevel });
+  return createMiddleware({
+    name: "codeEvalMiddleware",
+    contextSchema,
+    tools: [codeEvalTool, codeExecuteFileTool, getToolClient("convert_to_markdown")]
+  });
+}
+
+// src/middlewares/browserMiddleware.ts
+import { createMiddleware as createMiddleware2 } from "langchain";
+function createBrowserMiddleware(params = { isolatedLevel: "global" }) {
+  const isolatedLevel = params.isolatedLevel || "global";
+  const tools = [
+    createBrowserNavigateTool({ isolatedLevel }),
+    createBrowserClickTool({ isolatedLevel }),
+    createBrowserGetTextTool({ isolatedLevel }),
+    createBrowserGetMarkdownTool({ isolatedLevel }),
+    createBrowserEvaluateTool({ isolatedLevel }),
+    createBrowserScreenshotTool({ isolatedLevel }),
+    createBrowserScrollTool({ isolatedLevel }),
+    createBrowserFormInputFillTool({ isolatedLevel }),
+    createBrowserSelectTool({ isolatedLevel }),
+    createBrowserHoverTool({ isolatedLevel }),
+    createBrowserGoBackTool({ isolatedLevel }),
+    createBrowserGoForwardTool({ isolatedLevel }),
+    createBrowserNewTabTool({ isolatedLevel }),
+    createBrowserTabListTool({ isolatedLevel }),
+    createBrowserSwitchTabTool({ isolatedLevel }),
+    createBrowserCloseTabTool({ isolatedLevel }),
+    createBrowserCloseTool({ isolatedLevel }),
+    createBrowserPressKeyTool({ isolatedLevel }),
+    createBrowserReadLinksTool({ isolatedLevel }),
+    createBrowserGetClickableElementsTool({ isolatedLevel }),
+    createBrowserGetDownloadListTool({ isolatedLevel }),
+    createBrowserGetInfoTool({ isolatedLevel })
+  ];
+  return createMiddleware2({
+    name: "browserMiddleware",
+    contextSchema,
+    tools
+  });
+}
+
+// src/middlewares/sqlMiddleware.ts
+import { createMiddleware as createMiddleware3 } from "langchain";
+function createSqlMiddleware(params) {
+  const { databaseKeys, databaseDescriptions } = params;
+  if (!databaseKeys || databaseKeys.length === 0) {
+    return createMiddleware3({
+      name: "sqlMiddleware",
+      tools: []
     });
-    this.baseURL = baseURL;
-    this.maxFileSizeBytes = maxFileSizeMb * 1024 * 1024;
-    this.workingDirectory = workingDirectory;
-    this.homeDir = "/home/gem";
-  }
-  resolvePath(virtualPath) {
-    return path2.join(this.homeDir, this.workingDirectory, virtualPath);
   }
-  /**
-   * Convert a real filesystem path to a virtual path.
-   *
-   * @param realPath - Real filesystem path
-   * @returns Virtual path starting with /
-   */
-  toVirtualPath(realPath) {
-    const rootPath = path2.join(this.homeDir, this.workingDirectory);
-    const relative4 = path2.relative(rootPath, realPath);
-    const normalized = relative4.split(path2.sep).join("/");
-    return "/" + normalized;
+  const toolParams = {
+    databaseKeys,
+    databaseDescriptions
+  };
+  return createMiddleware3({
+    name: "sqlMiddleware",
+    contextSchema,
+    tools: [
+      createListTablesSqlTool(toolParams),
+      createInfoSqlTool(toolParams),
+      createQueryCheckerSqlTool(toolParams),
+      createQuerySqlTool(toolParams)
+    ]
+  });
+}
+
+// src/middlewares/skillMiddleware.ts
+import { createMiddleware as createMiddleware4 } from "langchain";
+
+// src/store_lattice/InMemoryThreadStore.ts
+var InMemoryThreadStore = class {
+  constructor() {
+    // Map<tenantId, Map<assistantId, Map<threadId, Thread>>>
+    this.threads = /* @__PURE__ */ new Map();
   }
   /**
-   * List files and directories in the specified directory (non-recursive).
-   *
-   * @param dirPath - Virtual directory path (must start with /)
-   * @returns List of FileInfo objects for files and directories directly in the directory.
-   *          Directories have a trailing / in their path and is_dir=true.
+   * Get all threads for a specific tenant and assistant
    */
-  async lsInfo(dirPath) {
-    try {
-      const resolvedPath = this.resolvePath(dirPath);
-      const result = await this.sandbox.file.listPath({
-        path: resolvedPath,
-        recursive: false,
-        show_hidden: false,
-        max_depth: 0,
-        include_size: false,
-        include_permissions: false,
-        sort_by: "name",
-        sort_desc: false
-      });
-      if (!result.ok) {
-        throw result.error;
-      }
-      const files = result.body?.data?.files?.map((file) => ({
-        path: this.toVirtualPath(file.path),
-        is_dir: file.is_directory,
-        size: file.size,
-        modified_at: file.modified_time
-      })) || [];
-      return files;
-    } catch (e) {
-      console.error(`Error listing files in ${dirPath}:`, e);
+  async getThreadsByAssistantId(tenantId, assistantId, metadataFilter) {
+    const tenantThreads = this.threads.get(tenantId);
+    if (!tenantThreads) {
+      return [];
+    }
+    const assistantThreads = tenantThreads.get(assistantId);
+    if (!assistantThreads) {
       return [];
     }
+    let threads = Array.from(assistantThreads.values());
+    if (metadataFilter && Object.keys(metadataFilter).length > 0) {
+      threads = threads.filter(
+        (thread) => Object.entries(metadataFilter).every(
+          ([key, value]) => thread.metadata?.[key] === value
+        )
+      );
+    }
+    return threads;
   }
   /**
-   * Read file content with line numbers.
-   *
-   * @param filePath - Virtual file path (must start with /)
-   * @param offset - Line offset to start reading from (0-indexed)
-   * @param limit - Maximum number of lines to read
-   * @returns Formatted file content with line numbers, or error message
+   * Get a thread by ID for a specific tenant
    */
-  async read(filePath, offset = 0, limit = 1e4) {
-    try {
-      const resolvedPath = this.resolvePath(filePath);
-      let content;
-      const result = await this.sandbox.file.readFile({
-        file: resolvedPath,
-        start_line: offset,
-        end_line: limit
-      });
-      if (!result.ok) {
-        throw result.error;
+  async getThreadById(tenantId, threadId) {
+    const tenantThreads = this.threads.get(tenantId);
+    if (!tenantThreads) {
+      return void 0;
+    }
+    for (const assistantThreads of tenantThreads.values()) {
+      const thread = assistantThreads.get(threadId);
+      if (thread) {
+        return thread;
       }
-      content = result.body?.data?.content || "";
-      return content;
-    } catch (e) {
-      return `Error: File '${filePath}' not found`;
     }
+    return void 0;
   }
   /**
-   * Read file content as raw FileData.
-   *
-   * @param filePath - Virtual file path (must start with /)
-   * @returns Raw file content as FileData
+   * Create a new thread for a tenant and assistant
    */
-  async readRaw(filePath) {
-    try {
-      const content = await this.read(filePath);
-      return {
-        content: content.split("\n"),
-        created_at: (/* @__PURE__ */ new Date()).toISOString(),
-        modified_at: (/* @__PURE__ */ new Date()).toISOString()
-      };
-    } catch (e) {
-      throw new Error(`Error reading file '${filePath}': ${e.message}`);
+  async createThread(tenantId, assistantId, threadId, data) {
+    const now = /* @__PURE__ */ new Date();
+    const thread = {
+      id: threadId,
+      tenantId,
+      assistantId,
+      metadata: data.metadata || {},
+      createdAt: now,
+      updatedAt: now
+    };
+    if (!this.threads.has(tenantId)) {
+      this.threads.set(tenantId, /* @__PURE__ */ new Map());
+    }
+    const tenantThreads = this.threads.get(tenantId);
+    if (!tenantThreads.has(assistantId)) {
+      tenantThreads.set(assistantId, /* @__PURE__ */ new Map());
     }
+    const assistantThreads = tenantThreads.get(assistantId);
+    assistantThreads.set(threadId, thread);
+    return thread;
   }
   /**
-   * Create a new file with content.
-   * Returns WriteResult. External storage sets filesUpdate=null.
-   *
-   * @param filePath - Virtual file path (must start with /)
-   * @param content - File content as string
-   * @returns WriteResult with error populated on failure
+   * Update an existing thread
    */
-  async write(filePath, content) {
-    try {
-      const resolvedPath = this.resolvePath(filePath);
-      const result = await this.sandbox.file.writeFile({
-        file: resolvedPath,
-        content,
-        "encoding": "utf-8",
-        "append": false
-        // sudo: true
-      });
-      if (!result.ok) {
-        console.error(result.error);
-        throw result.error;
+  async updateThread(tenantId, threadId, updates) {
+    const tenantThreads = this.threads.get(tenantId);
+    if (!tenantThreads) {
+      return null;
+    }
+    for (const assistantThreads of tenantThreads.values()) {
+      const existing = assistantThreads.get(threadId);
+      if (existing) {
+        const updated = {
+          ...existing,
+          metadata: {
+            ...existing.metadata,
+            ...updates.metadata || {}
+          },
+          updatedAt: /* @__PURE__ */ new Date()
+        };
+        assistantThreads.set(threadId, updated);
+        return updated;
       }
-      return {
-        path: filePath,
-        filesUpdate: {
-          [filePath]: {
-            content: content.split("\n"),
-            created_at: (/* @__PURE__ */ new Date()).toISOString(),
-            modified_at: (/* @__PURE__ */ new Date()).toISOString()
-          }
-        }
-      };
-    } catch (e) {
-      throw new Error(`Error writing file '${filePath}': ${e.message}`);
     }
+    return null;
   }
   /**
-   * Edit a file by replacing string occurrences.
-   * Returns EditResult. External storage sets filesUpdate=null.
-   *
-   * @param filePath - Virtual file path (must start with /)
-   * @param oldString - String to find and replace
-   * @param newString - Replacement string
-   * @param replaceAll - If true, replace all occurrences (default: false)
-   * @returns EditResult with error, path, filesUpdate, and occurrences
+   * Delete a thread by ID
    */
-  async edit(filePath, oldString, newString, replaceAll = false) {
-    try {
-      const resolvedPath = this.resolvePath(filePath);
-      const result = await this.sandbox.file.strReplaceEditor({
-        command: "str_replace",
-        path: resolvedPath,
-        old_str: oldString,
-        new_str: newString,
-        replace_mode: replaceAll ? "ALL" : "FIRST"
-      });
-      if (!result.ok) {
-        throw result.error;
+  async deleteThread(tenantId, threadId) {
+    const tenantThreads = this.threads.get(tenantId);
+    if (!tenantThreads) {
+      return false;
+    }
+    for (const assistantThreads of tenantThreads.values()) {
+      if (assistantThreads.has(threadId)) {
+        return assistantThreads.delete(threadId);
       }
-      return {
-        path: filePath,
-        filesUpdate: null
-      };
-    } catch (e) {
-      throw new Error(`Error editing file '${filePath}': ${e.message}`);
     }
+    return false;
   }
   /**
-   * Structured search results or error string for invalid input.
-   *
-   * Searches file contents for a regex pattern within the sandbox.
-   *
-   * @param pattern - Regex pattern to search for
-   * @param searchPath - Base path to search from (default: "/")
-   * @param glob - Optional glob pattern to filter files (e.g., "*.py")
-   * @returns List of GrepMatch objects or error string for invalid regex
+   * Check if thread exists
    */
-  async grepRaw(pattern, searchPath = "/", glob = null) {
-    let baseFull;
-    baseFull = this.resolvePath(searchPath || "/");
-    const result = await this.sandbox.file.findFiles({
-      path: baseFull,
-      glob: glob || "**/*"
-    });
-    if (!result.ok) {
-      throw result.error;
+  async hasThread(tenantId, threadId) {
+    const tenantThreads = this.threads.get(tenantId);
+    if (!tenantThreads) {
+      return false;
     }
-    const filePaths = result.body?.data?.files || [];
-    const matches = [];
-    for (const absolutePath of filePaths) {
-      const fileData = await this.sandbox.file.searchInFile({
-        file: absolutePath,
-        regex: pattern
-      });
-      if (!fileData.ok) {
-        continue;
+    for (const assistantThreads of tenantThreads.values()) {
+      if (assistantThreads.has(threadId)) {
+        return true;
       }
-      const matchesData = fileData.body?.data?.matches || [];
-      const matchLines = fileData.body?.data?.line_numbers || [];
-      matchesData.forEach((match, index) => {
-        matches.push({
-          path: this.toVirtualPath(absolutePath),
-          line: matchLines[index],
-          text: match
-        });
-      });
     }
-    return matches;
+    return false;
   }
   /**
-   * Structured glob matching returning FileInfo objects.
-   *
-   * @param pattern - Glob pattern (e.g., `*.py`, `**\/*.ts`)
-   * @param searchPath - Base path to search from (default: "/")
-   * @returns List of FileInfo objects matching the pattern
+   * Clear all threads for a tenant (useful for testing)
    */
-  async globInfo(pattern, searchPath = "/") {
-    if (pattern.startsWith("/")) {
-      pattern = pattern.substring(1);
-    }
-    const resolvedSearchPath = this.resolvePath(searchPath);
-    const result = await this.sandbox.file.findFiles({
-      path: resolvedSearchPath,
-      glob: pattern || "**/*"
-    });
-    if (!result.ok) {
-      throw result.error;
+  clear(tenantId) {
+    if (tenantId) {
+      this.threads.delete(tenantId);
+    } else {
+      this.threads.clear();
     }
-    const results = [];
-    for (const filePath of result.body?.data?.files || []) {
-      const fileInfo = await this.sandbox.file.listPath({
-        path: filePath,
-        recursive: false,
-        show_hidden: false,
-        max_depth: 1,
-        include_size: false,
-        include_permissions: false
-      });
-      if (!fileInfo.ok) {
-        continue;
+  }
+  /**
+   * Get all threads for all assistants (useful for debugging)
+   */
+  getAllThreads() {
+    const allThreads = [];
+    for (const tenantThreads of this.threads.values()) {
+      for (const assistantThreads of tenantThreads.values()) {
+        allThreads.push(...Array.from(assistantThreads.values()));
       }
-      results.push({
-        path: this.toVirtualPath(filePath),
-        is_dir: false,
-        size: fileInfo.body?.data?.files?.[0]?.size,
-        modified_at: fileInfo.body?.data?.files?.[0]?.modified_time
-      });
     }
-    return results;
+    return allThreads;
   }
 };
 
-// src/middlewares/codeEvalMiddleware.ts
-import { createMiddleware } from "langchain";
-
-// src/middlewares/contextSchema.ts
-import z40 from "zod";
-var contextSchema = z40.object({
-  runConfig: z40.any()
-});
-
-// src/middlewares/codeEvalMiddleware.ts
-function createCodeEvalMiddleware(params = { isolatedLevel: "global" }) {
-  const codeEvalTool = createCodeEvalTool({ isolatedLevel: params.isolatedLevel });
-  const codeExecuteFileTool = createCodeExecuteFileTool({ isolatedLevel: params.isolatedLevel });
-  return createMiddleware({
-    name: "codeEvalMiddleware",
-    contextSchema,
-    tools: [codeEvalTool, codeExecuteFileTool, getToolClient("convert_to_markdown")]
-  });
-}
-
-// src/middlewares/browserMiddleware.ts
-import { createMiddleware as createMiddleware2 } from "langchain";
-function createBrowserMiddleware(params = { isolatedLevel: "global" }) {
-  const isolatedLevel = params.isolatedLevel || "global";
-  const tools = [
-    createBrowserNavigateTool({ isolatedLevel }),
-    createBrowserClickTool({ isolatedLevel }),
-    createBrowserGetTextTool({ isolatedLevel }),
-    createBrowserGetMarkdownTool({ isolatedLevel }),
-    createBrowserEvaluateTool({ isolatedLevel }),
-    createBrowserScreenshotTool({ isolatedLevel }),
-    createBrowserScrollTool({ isolatedLevel }),
-    createBrowserFormInputFillTool({ isolatedLevel }),
-    createBrowserSelectTool({ isolatedLevel }),
-    createBrowserHoverTool({ isolatedLevel }),
-    createBrowserGoBackTool({ isolatedLevel }),
-    createBrowserGoForwardTool({ isolatedLevel }),
-    createBrowserNewTabTool({ isolatedLevel }),
-    createBrowserTabListTool({ isolatedLevel }),
-    createBrowserSwitchTabTool({ isolatedLevel }),
-    createBrowserCloseTabTool({ isolatedLevel }),
-    createBrowserCloseTool({ isolatedLevel }),
-    createBrowserPressKeyTool({ isolatedLevel }),
-    createBrowserReadLinksTool({ isolatedLevel }),
-    createBrowserGetClickableElementsTool({ isolatedLevel }),
-    createBrowserGetDownloadListTool({ isolatedLevel }),
-    createBrowserGetInfoTool({ isolatedLevel })
-  ];
-  return createMiddleware2({
-    name: "browserMiddleware",
-    contextSchema,
-    tools
-  });
-}
-
-// src/middlewares/sqlMiddleware.ts
-import { createMiddleware as createMiddleware3 } from "langchain";
-function createSqlMiddleware(params) {
-  const { databaseKeys, databaseDescriptions } = params;
-  if (!databaseKeys || databaseKeys.length === 0) {
-    return createMiddleware3({
-      name: "sqlMiddleware",
-      tools: []
-    });
-  }
-  const toolParams = {
-    databaseKeys,
-    databaseDescriptions
-  };
-  return createMiddleware3({
-    name: "sqlMiddleware",
-    contextSchema,
-    tools: [
-      createListTablesSqlTool(toolParams),
-      createInfoSqlTool(toolParams),
-      createQueryCheckerSqlTool(toolParams),
-      createQuerySqlTool(toolParams)
-    ]
-  });
-}
-
-// src/middlewares/skillMiddleware.ts
-import { createMiddleware as createMiddleware4 } from "langchain";
-
-// src/store_lattice/InMemoryThreadStore.ts
-var InMemoryThreadStore = class {
+// src/store_lattice/InMemoryAssistantStore.ts
+var InMemoryAssistantStore = class {
   constructor() {
-    // Map<tenantId, Map<assistantId, Map<threadId, Thread>>>
-    this.threads = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Get all threads for a specific tenant and assistant
-   */
-  async getThreadsByAssistantId(tenantId, assistantId, metadataFilter) {
-    const tenantThreads = this.threads.get(tenantId);
-    if (!tenantThreads) {
-      return [];
-    }
-    const assistantThreads = tenantThreads.get(assistantId);
-    if (!assistantThreads) {
-      return [];
-    }
-    let threads = Array.from(assistantThreads.values());
-    if (metadataFilter && Object.keys(metadataFilter).length > 0) {
-      threads = threads.filter(
-        (thread) => Object.entries(metadataFilter).every(
-          ([key, value]) => thread.metadata?.[key] === value
-        )
-      );
-    }
-    return threads;
-  }
-  /**
-   * Get a thread by ID for a specific tenant
-   */
-  async getThreadById(tenantId, threadId) {
-    const tenantThreads = this.threads.get(tenantId);
-    if (!tenantThreads) {
-      return void 0;
-    }
-    for (const assistantThreads of tenantThreads.values()) {
-      const thread = assistantThreads.get(threadId);
-      if (thread) {
-        return thread;
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Create a new thread for a tenant and assistant
-   */
-  async createThread(tenantId, assistantId, threadId, data) {
-    const now = /* @__PURE__ */ new Date();
-    const thread = {
-      id: threadId,
-      tenantId,
-      assistantId,
-      metadata: data.metadata || {},
-      createdAt: now,
-      updatedAt: now
-    };
-    if (!this.threads.has(tenantId)) {
-      this.threads.set(tenantId, /* @__PURE__ */ new Map());
-    }
-    const tenantThreads = this.threads.get(tenantId);
-    if (!tenantThreads.has(assistantId)) {
-      tenantThreads.set(assistantId, /* @__PURE__ */ new Map());
-    }
-    const assistantThreads = tenantThreads.get(assistantId);
-    assistantThreads.set(threadId, thread);
-    return thread;
-  }
-  /**
-   * Update an existing thread
-   */
-  async updateThread(tenantId, threadId, updates) {
-    const tenantThreads = this.threads.get(tenantId);
-    if (!tenantThreads) {
-      return null;
-    }
-    for (const assistantThreads of tenantThreads.values()) {
-      const existing = assistantThreads.get(threadId);
-      if (existing) {
-        const updated = {
-          ...existing,
-          metadata: {
-            ...existing.metadata,
-            ...updates.metadata || {}
-          },
-          updatedAt: /* @__PURE__ */ new Date()
-        };
-        assistantThreads.set(threadId, updated);
-        return updated;
-      }
-    }
-    return null;
-  }
-  /**
-   * Delete a thread by ID
-   */
-  async deleteThread(tenantId, threadId) {
-    const tenantThreads = this.threads.get(tenantId);
-    if (!tenantThreads) {
-      return false;
-    }
-    for (const assistantThreads of tenantThreads.values()) {
-      if (assistantThreads.has(threadId)) {
-        return assistantThreads.delete(threadId);
-      }
-    }
-    return false;
-  }
-  /**
-   * Check if thread exists
-   */
-  async hasThread(tenantId, threadId) {
-    const tenantThreads = this.threads.get(tenantId);
-    if (!tenantThreads) {
-      return false;
-    }
-    for (const assistantThreads of tenantThreads.values()) {
-      if (assistantThreads.has(threadId)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  /**
-   * Clear all threads for a tenant (useful for testing)
-   */
-  clear(tenantId) {
-    if (tenantId) {
-      this.threads.delete(tenantId);
-    } else {
-      this.threads.clear();
-    }
-  }
-  /**
-   * Get all threads for all assistants (useful for debugging)
-   */
-  getAllThreads() {
-    const allThreads = [];
-    for (const tenantThreads of this.threads.values()) {
-      for (const assistantThreads of tenantThreads.values()) {
-        allThreads.push(...Array.from(assistantThreads.values()));
-      }
-    }
-    return allThreads;
-  }
-};
-
-// src/store_lattice/InMemoryAssistantStore.ts
-var InMemoryAssistantStore = class {
-  constructor() {
-    this.assistants = /* @__PURE__ */ new Map();
+    this.assistants = /* @__PURE__ */ new Map();
   }
   /**
    * Get all assistants for a tenant
@@ -5250,7 +4975,7 @@ var InMemoryAssistantStore = class {
 
 // src/store_lattice/FileSystemSkillStore.ts
 import * as fs from "fs/promises";
-import * as path3 from "path";
+import * as path2 from "path";
 
 // src/skill_lattice/skillNameValidator.ts
 var SKILL_NAME_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
@@ -5423,10 +5148,10 @@ var FileSystemSkillStore = class {
   constructor(options = {}) {
     const defaultPath = "lattice_store/skills";
     const providedPath = options.rootDir || defaultPath;
-    if (path3.isAbsolute(providedPath)) {
+    if (path2.isAbsolute(providedPath)) {
       this.rootDir = providedPath;
     } else {
-      this.rootDir = path3.resolve(process.cwd(), providedPath);
+      this.rootDir = path2.resolve(process.cwd(), providedPath);
     }
     this.ensureDirectoryExists().catch((error) => {
       console.error("Failed to initialize FileSystemSkillStore:", error);
@@ -5450,14 +5175,14 @@ var FileSystemSkillStore = class {
     if (name.includes("..") || name.includes("/") || name.includes("\\")) {
       throw new Error(`Invalid skill name: ${name} (contains invalid characters)`);
     }
-    return path3.join(this.rootDir, name);
+    return path2.join(this.rootDir, name);
   }
   /**
    * Get file path for a skill name
    * File is always named SKILL.md inside the name directory
    */
   getSkillFilePath(name) {
-    return path3.join(this.getSkillDirectoryPath(name), "SKILL.md");
+    return path2.join(this.getSkillDirectoryPath(name), "SKILL.md");
   }
   /**
    * Read skill from file
@@ -5744,14 +5469,14 @@ ${body}` : `${frontmatter}
    */
   async listSkillResources(_tenantId, skillName) {
     const skillDir = this.getSkillDirectoryPath(skillName);
-    const resourcesDir = path3.join(skillDir, "resources");
+    const resourcesDir = path2.join(skillDir, "resources");
     try {
       const entries = await fs.readdir(resourcesDir, { withFileTypes: true, recursive: true });
       const resources = [];
       for (const entry of entries) {
         if (!entry.isDirectory()) {
-          const fullPath = path3.join(entry.path, entry.name);
-          const relativePath = path3.relative(resourcesDir, fullPath);
+          const fullPath = path2.join(entry.path, entry.name);
+          const relativePath = path2.relative(resourcesDir, fullPath);
           resources.push(relativePath.replace(/\\/g, "/"));
         }
       }
@@ -5772,10 +5497,10 @@ ${body}` : `${frontmatter}
    */
   async loadSkillResource(_tenantId, skillName, resourcePath) {
     const skillDir = this.getSkillDirectoryPath(skillName);
-    const resourcesDir = path3.join(skillDir, "resources");
-    const fullPath = path3.join(resourcesDir, resourcePath);
-    const resolvedPath = path3.resolve(fullPath);
-    const resolvedResourcesDir = path3.resolve(resourcesDir);
+    const resourcesDir = path2.join(skillDir, "resources");
+    const fullPath = path2.join(resourcesDir, resourcePath);
+    const resolvedPath = path2.resolve(fullPath);
+    const resolvedResourcesDir = path2.resolve(resourcesDir);
     if (!resolvedPath.startsWith(resolvedResourcesDir)) {
       throw new Error(`Invalid resource path: ${resourcePath}`);
     }
@@ -9239,7 +8964,7 @@ function createShowWidgetTool() {
     },
     {
       name: "show_widget",
-      description: "Render an interactive HTML widget or SVG diagram visible to the user. Use for: charts, dashboards, calculators, forms, diagrams, timers, games, visualizations. The widget appears in a panel next to the chat. Users can interact with it and send data back via window.sendToAgent(data). IMPORTANT: Always call load_guidelines before your first show_widget.",
+      description: "Render an interactive HTML widget or SVG diagram visible to the user. Use for: charts, dashboards, calculators, forms, diagrams, timers, games, visualizations. The widget appears in a panel next to the chat. Users can interact with it and send data back via window.sendPrompt(data). IMPORTANT: Always call load_guidelines before your first show_widget.",
       schema: ShowWidgetInputSchema
     }
   );
@@ -9311,22 +9036,19 @@ import { createMiddleware as createMiddleware10 } from "langchain";
 
 // src/deep_agent_new/middleware/AGENTS_MD.ts
 var AGENTS_MD = `
-# AGENTS.md - Your Workspace
-
-This folder is home. Treat it that way.
 
 ## First Run
 
-If \`BOOTSTRAP.md\` exists, that's your birth certificate. Follow it, figure out who you are, then delete it. You won't need it again.
+If \`/agent/BOOTSTRAP.md\` exists, that's your birth certificate. Follow it, figure out who you are, then delete it. You won't need it again.
 
 ## Every Session
 
 Before doing anything else:
 
-1. Read \`SOUL.md\` \u2014 this is who you are
-2. Read \`USER.md\` \u2014 this is who you're helping
+1. Read \`/agent/SOUL.md\` \u2014 this is who you are
+2. Read \`/agent/USER.md\` \u2014 this is who you're helping
 3. Read \`memory/YYYY-MM-DD.md\` (today + yesterday) for recent context
-4. **If in MAIN SESSION** (direct chat with your human): Also read \`MEMORY.md\`
+4. **If in MAIN SESSION** (direct chat with your human): Also read \`/agent/MEMORY.md\`
 
 Don't ask permission. Just do it.
 
@@ -9334,17 +9056,18 @@ Don't ask permission. Just do it.
 
 You wake up fresh each session. These files are your continuity:
 
-- **Daily notes:** \`memory/YYYY-MM-DD.md\` (create \`memory/\` if needed) \u2014 raw logs of what happened
-- **Long-term:** \`MEMORY.md\` \u2014 your curated memories, like a human's long-term memory
+- **agent Long-term:** \`/agent/MEMORY.md\` \u2014 your curated memories, like a human's long-term memory
+- **Project Memory**: \`/PROJECT.md\` - Loaded from project root if available - Project-specific instructions
+- **Daily Project notes:** \`/daily/YYYY-MM-DD.md\` (create \`daily/\` if needed) \u2014 raw logs of what happened
 
 Capture what matters. Decisions, context, things to remember. Skip the secrets unless asked to keep them.
 
-### \u{1F9E0} MEMORY.md - Your Long-Term Memory
+### \u{1F9E0} /agent/MEMORY.md - Your Long-Term Memory
 
 - **ONLY load in main session** (direct chats with your human)
 - **DO NOT load in shared contexts** (Discord, group chats, sessions with other people)
 - This is for **security** \u2014 contains personal context that shouldn't leak to strangers
-- You can **read, edit, and update** MEMORY.md freely in main sessions
+- You can **read, edit, and update** /agent/MEMORY.md freely in main sessions
 - Write significant events, thoughts, decisions, opinions, lessons learned
 - This is your curated memory \u2014 the distilled essence, not raw logs
 - Over time, review your daily files and update MEMORY.md with what's worth keeping
@@ -9353,11 +9076,42 @@ Capture what matters. Decisions, context, things to remember. Skip the secrets u
 
 - **Memory is limited** \u2014 if you want to remember something, WRITE IT TO A FILE
 - "Mental notes" don't survive session restarts. Files do.
-- When someone says "remember this" \u2192 update \`memory/YYYY-MM-DD.md\` or relevant file
-- When you learn a lesson \u2192 update AGENTS.md, TOOLS.md, or the relevant skill
+- When someone says "remember this" \u2192 update \`/daily/YYYY-MM-DD.md\` or relevant file
+- When you learn a lesson \u2192 update /agent/AGENTS.md, /agent/TOOLS.md, or the relevant skill
 - When you make a mistake \u2192 document it so future-you doesn't repeat it
 - **Text > Brain** \u{1F4DD}
 
+### Project Memory File: \`/PROJECT.md\`
+\u2192 Describes **how this specific project works** and **how the agent should behave here only.**
+
+**Store here:**
+- Project-specific architecture and design patterns
+- Coding conventions specific to this codebase
+- Project structure and organization
+- Testing strategies for this project
+- Deployment processes and workflows
+- Team conventions and guidelines
+
+**Examples:**
+- "This project uses FastAPI with SQLAlchemy"
+- "Tests go in tests/ directory mirroring src/ structure"
+- "All API changes require updating OpenAPI spec"
+
+### Project Memory Files: \`{project_deepagents_dir}/*.md\`
+\u2192 Use for **project-specific reference information** and structured notes.
+
+**Store here:**
+- API design documentation
+- Architecture decisions and rationale
+- Deployment procedures
+- Common debugging patterns
+- Onboarding information
+
+**Examples:**
+- \`{project_deepagents_dir}/api-design.md\` - REST API patterns used
+- \`{project_deepagents_dir}/architecture.md\` - System architecture overview
+- \`{project_deepagents_dir}/deployment.md\` - How to deploy this project
+
 ## Safety
 
 - Don't exfiltrate private data. Ever.
@@ -9529,10 +9283,10 @@ Offer suggestions if they're stuck. Have fun with it.
 
 Update these files with what you learned:
 
-- \`IDENTITY.md\` \u2014 your name, creature, vibe, emoji
-- \`USER.md\` \u2014 their name, how to address them, timezone, notes
+- \`/agent/IDENTITY.md\` \u2014 your name, creature, vibe, emoji
+- \`/agent/USER.md\` \u2014 their name, how to address them, timezone, notes
 
-Then open \`SOUL.md\` together and talk about:
+Then open \`/agent/SOUL.md\` together and talk about:
 
 - What matters to them
 - How they want you to behave
@@ -9665,12 +9419,12 @@ async function getBackend2(backend, stateAndStore) {
   return backend;
 }
 var BOOTSTRAP_FILE_NAMES = {
-  agents: "AGENTS.md",
-  soul: "SOUL.md",
-  identity: "IDENTITY.md",
-  user: "USER.md",
-  tools: "TOOLS.md",
-  bootstrap: "BOOTSTRAP.md"
+  agents: "/agent/AGENTS.md",
+  soul: "/agent/SOUL.md",
+  identity: "/agent/IDENTITY.md",
+  user: "/agent/USER.md",
+  tools: "/agent/TOOLS.md",
+  bootstrap: "/agent/BOOTSTRAP.md"
 };
 var BOOTSTRAP_SECTION_HEADERS = {
   agents: "## Operating Instructions",
@@ -9693,14 +9447,14 @@ Document available tools and their usage notes here.`,
 async function createBootstrapFiles(config, backend, stateAndStore) {
   const resolvedBackend = await getBackend2(backend, stateAndStore);
   try {
-    const agentsContent = await resolvedBackend.read("/AGENTS.md", 0, 1);
+    const agentsContent = await resolvedBackend.read("/agent/AGENTS.md", 0, 1);
     if (!agentsContent.includes("Error:")) {
       return;
     }
   } catch (error) {
   }
   for (const [key, filename] of Object.entries(BOOTSTRAP_FILE_NAMES)) {
-    const filePath = "/" + filename;
+    const filePath = filename;
     try {
       const content = config[key] || DEFAULT_BOOTSTRAP_CONTENT[key];
       await resolvedBackend.write(filePath, content);
@@ -9714,7 +9468,7 @@ async function buildBootstrapPromptSections(backend, stateAndStore) {
   const sections = [];
   const fileOrder = ["agents", "soul", "identity", "user", "tools", "bootstrap"];
   for (const key of fileOrder) {
-    const filePath = "/" + BOOTSTRAP_FILE_NAMES[key];
+    const filePath = BOOTSTRAP_FILE_NAMES[key];
     try {
       const content = await resolvedBackend.read(filePath);
       if (content && !content.includes("Error:") && content.trim()) {
@@ -9750,14 +9504,13 @@ function createClawMiddleware(options = {}) {
       if (injectBootstrapFiles && backend) {
         const stateAndStore = {
           state: request.state || {},
-          store: request.store
+          store: request.store,
+          ...request.runtime.context.runConfig
         };
         const bootstrapSections = await buildBootstrapPromptSections(backend, stateAndStore);
         if (bootstrapSections.length > 0) {
           const bootstrapContext = `
 
-
-
 ${bootstrapSections.join("\n\n")}
 
 `;
@@ -9767,113 +9520,782 @@ ${bootstrapSections.join("\n\n")}
       }
       return handler(request);
     }
-  });
-}
+  });
+}
+
+// src/middlewares/unknownToolHandlerMiddleware.ts
+import { createMiddleware as createMiddleware11 } from "langchain";
+import { AIMessage as AIMessage2, ToolMessage as ToolMessage3 } from "@langchain/core/messages";
+function createUnknownToolHandlerMiddleware(config = {}) {
+  const {
+    strategy = "error",
+    errorMessageTemplate = (name, tools) => `Error: Tool "${name}" does not exist.
+
+Available tools:
+` + tools.map((t) => `  - ${t}`).join("\n") + `
+
+Please select a valid tool from the list above.`
+  } = config;
+  return createMiddleware11({
+    name: "UnknownToolHandlerMiddleware",
+    /**
+     * wrapModelCall hook
+     *
+     * The only place to access request.tools (all available tools).
+     * Identifies unknown tools and stores error info in metadata.
+     *
+     * Key: Preserve all tool_calls in original AIMessage, including unknown ones.
+     * This allows the model to see what it selected in the next round.
+     */
+    wrapModelCall: async (request, handler) => {
+      const availableTools = request.tools || [];
+      const availableToolNames = availableTools.map((t) => t.name);
+      const availableToolSet = new Set(availableToolNames);
+      const aiResponse = await handler(request);
+      if (!aiResponse.tool_calls || aiResponse.tool_calls.length === 0) {
+        return aiResponse;
+      }
+      const unknownToolCalls = [];
+      for (const toolCall of aiResponse.tool_calls) {
+        if (!availableToolSet.has(toolCall.name)) {
+          unknownToolCalls.push(toolCall);
+        }
+      }
+      if (unknownToolCalls.length === 0) {
+        return aiResponse;
+      }
+      if (strategy === "strict") {
+        const unknownNames = unknownToolCalls.map((t) => t.name).join(", ");
+        throw new Error(
+          `Unknown tools detected: ${unknownNames}. Available tools: ${availableToolNames.join(", ")}`
+        );
+      }
+      const unknownToolErrors = unknownToolCalls.map((toolCall) => ({
+        toolName: toolCall.name,
+        toolCallId: toolCall.id,
+        errorMessage: errorMessageTemplate(toolCall.name, availableToolNames)
+      }));
+      const modifiedResponse = new AIMessage2({
+        content: aiResponse.content,
+        tool_calls: aiResponse.tool_calls,
+        // Key: preserve all tool_calls, don't delete unknown
+        response_metadata: {
+          ...aiResponse.response_metadata,
+          _unknownToolErrors: unknownToolErrors
+        }
+      });
+      if (aiResponse.id) {
+        modifiedResponse.id = aiResponse.id;
+      }
+      return modifiedResponse;
+    },
+    /**
+     * afterModel hook
+     *
+     * Processes unknown tool errors stored in metadata.
+     * Generates error ToolMessages and jumps back to model.
+     *
+     * Key: Uses jumpTo: "model" to form agent loop.
+     * Without jumpTo, the graph would end after ToolNode without returning to model.
+     */
+    afterModel: {
+      canJumpTo: ["model"],
+      hook: async (state) => {
+        const { messages } = state;
+        if (!messages || messages.length === 0) {
+          return;
+        }
+        const lastMessage = messages[messages.length - 1];
+        if (!AIMessage2.isInstance(lastMessage)) {
+          return;
+        }
+        const unknownToolErrors = lastMessage.response_metadata?._unknownToolErrors;
+        if (!unknownToolErrors || !Array.isArray(unknownToolErrors) || unknownToolErrors.length === 0) {
+          return;
+        }
+        const errorToolMessages = unknownToolErrors.map(
+          (error) => new ToolMessage3({
+            content: error.errorMessage,
+            name: error.toolName,
+            tool_call_id: error.toolCallId,
+            status: "error"
+          })
+        );
+        delete lastMessage.response_metadata._unknownToolErrors;
+        return {
+          messages: errorToolMessages,
+          jumpTo: "model"
+        };
+      }
+    }
+  });
+}
+
+// src/deep_agent_new/middleware/date.ts
+import { createMiddleware as createMiddleware12, tool as tool46 } from "langchain";
+import { z as z47 } from "zod";
+function formatCurrentDate(timezone = "UTC") {
+  const now = /* @__PURE__ */ new Date();
+  let validTimezone = timezone;
+  try {
+    Intl.DateTimeFormat(void 0, { timeZone: timezone });
+  } catch {
+    validTimezone = "UTC";
+  }
+  const dateFormatOptions = {
+    timeZone: validTimezone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  };
+  return new Intl.DateTimeFormat("en-US", dateFormatOptions).format(now);
+}
+function generateDateContext(timezone = "UTC") {
+  const formattedDate = formatCurrentDate(timezone);
+  if (timezone === "UTC") {
+    return `Current Date: ${formattedDate}`;
+  }
+  const utcDate = formatCurrentDate("UTC");
+  return `Current Date: ${formattedDate} (UTC: ${utcDate})`;
+}
+function createDateMiddleware(options = {}) {
+  const timezone = options.timezone || "UTC";
+  const dateContext = generateDateContext(timezone);
+  return createMiddleware12({
+    name: "DateMiddleware",
+    tools: [
+      tool46(
+        async () => {
+          const now = /* @__PURE__ */ new Date();
+          let validTimezone = timezone;
+          try {
+            Intl.DateTimeFormat(void 0, { timeZone: timezone });
+          } catch {
+            validTimezone = "UTC";
+          }
+          const localTimeOptions = {
+            timeZone: validTimezone,
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            second: "2-digit",
+            hour12: false
+          };
+          const localTime = new Intl.DateTimeFormat("en-US", localTimeOptions).format(now);
+          return JSON.stringify({
+            local_time: `${localTime} (${validTimezone})`,
+            iso_date: now.toISOString().split("T")[0],
+            timestamp: now.toISOString(),
+            timezone: validTimezone
+          });
+        },
+        {
+          name: "get_current_date_time",
+          description: "Get the exact current date and time at the moment of invocation. Use this when the user asks about the current time (e.g., 'what time is it', '\u51E0\u70B9\u4E86', '\u73B0\u5728\u51E0\u70B9'), or when you need to know the precise time for scheduling, deadlines, or time-sensitive operations.",
+          schema: z47.object({})
+        }
+      )
+    ],
+    wrapModelCall: async (request, handler) => {
+      const currentSystemPrompt = request.systemPrompt || "";
+      const newSystemPrompt = currentSystemPrompt ? `${dateContext}
+
+${currentSystemPrompt}` : dateContext;
+      return handler({
+        ...request,
+        systemPrompt: newSystemPrompt
+      });
+    }
+  });
+}
+
+// src/agent_lattice/builders/commonMiddleware.ts
+async function createCommonMiddlewares(middlewareConfigs, filesystemBackend, fsIsExised) {
+  const middlewares = [];
+  middlewares.push(createUnknownToolHandlerMiddleware());
+  middlewares.push(createModelSelectorMiddleware());
+  const filesystemConfig = middlewareConfigs.find((m) => m.type === "filesystem");
+  const clawConfig = middlewareConfigs.find((m) => m.type === "claw");
+  const needsFilesystemBackend = filesystemConfig?.enabled || clawConfig?.enabled;
+  if (needsFilesystemBackend && filesystemBackend) {
+    if (!fsIsExised) {
+      const options = { backend: filesystemBackend };
+      middlewares.push(createFilesystemMiddleware(options));
+    }
+  }
+  for (const config of middlewareConfigs) {
+    if (!config.enabled || config.type === "filesystem") continue;
+    switch (config.type) {
+      case "code_eval":
+        middlewares.push(createCodeEvalMiddleware(config.config));
+        break;
+      case "browser":
+        middlewares.push(createBrowserMiddleware(config.config));
+        break;
+      case "sql":
+        {
+          const sqlConfig = config.config;
+          if (sqlConfig.databaseKeys && sqlConfig.databaseKeys.length > 0) {
+            const databaseConfigs = global.__DATABASE_CONFIGS__ || [];
+            const descriptions = {};
+            for (const db of databaseConfigs) {
+              if (db.key && sqlConfig.databaseKeys.includes(db.key)) {
+                descriptions[db.key] = db.description || db.name || "";
+              }
+            }
+            middlewares.push(createSqlMiddleware({
+              databaseKeys: sqlConfig.databaseKeys,
+              databaseDescriptions: descriptions
+            }));
+          }
+        }
+        break;
+      case "skill":
+        middlewares.push(createSkillMiddleware(config.config));
+        break;
+      case "metrics":
+        {
+          const metricsConfig = config.config;
+          if (metricsConfig.connectAll || metricsConfig.serverKeys && metricsConfig.serverKeys.length > 0) {
+            middlewares.push(createMetricsMiddleware(metricsConfig));
+          }
+        }
+        break;
+      case "ask_user_to_clarify":
+        middlewares.push(createAskUserClarifyMiddleware());
+        break;
+      case "widget":
+        middlewares.push(createWidgetMiddleware());
+        break;
+      case "claw":
+        if (filesystemBackend) {
+          const clawMiddlewareConfig = config.config;
+          middlewares.push(createClawMiddleware({
+            backend: filesystemBackend,
+            injectBootstrapFiles: clawMiddlewareConfig.injectBootstrapFiles ?? true,
+            bootstrapFiles: clawMiddlewareConfig.bootstrapFiles ?? {}
+          }));
+        } else {
+          console.warn("[claw middleware] Filesystem backend not available. Claw middleware requires filesystem backend to function.");
+        }
+        break;
+      case "date":
+        middlewares.push(createDateMiddleware(config.config));
+        break;
+    }
+  }
+  return middlewares;
+}
+
+// src/deep_agent_new/backends/sandboxFiles.ts
+import { SandboxClient as SandboxClient2 } from "@agent-infra/sandbox";
+import * as path3 from "path";
+var SandboxFilesystem = class {
+  /**
+   * Create a new SandboxFilesystem instance.
+   *
+   * @param options - Configuration options
+   * @param options.baseURL - Base URL of the sandbox service (default: 'http://localhost:8080')
+   * @param options.maxFileSizeMb - Maximum file size in MB (default: 10)
+   * @param options.sandboxInstance - Optional Sandbox instance (if provided, baseURL is ignored)
+   */
+  constructor(options = {}) {
+    const {
+      baseURL = "http://localhost:8080",
+      workingDirectory = "/",
+      maxFileSizeMb = 10,
+      sandboxInstance
+    } = options;
+    this.sandbox = sandboxInstance || new SandboxClient2({ baseUrl: baseURL, environment: "" });
+    this.sandbox.mcp.listMcpServers().then((servers) => {
+    });
+    this.sandbox.mcp.listMcpTools("browser").then((tools) => {
+    });
+    this.baseURL = baseURL;
+    this.maxFileSizeBytes = maxFileSizeMb * 1024 * 1024;
+    this.workingDirectory = workingDirectory;
+    this.homeDir = "/home/gem";
+  }
+  resolvePath(virtualPath) {
+    return path3.join(this.homeDir, this.workingDirectory, virtualPath);
+  }
+  /**
+   * Convert a real filesystem path to a virtual path.
+   *
+   * @param realPath - Real filesystem path
+   * @returns Virtual path starting with /
+   */
+  toVirtualPath(realPath) {
+    const rootPath = path3.join(this.homeDir, this.workingDirectory);
+    const relative4 = path3.relative(rootPath, realPath);
+    const normalized = relative4.split(path3.sep).join("/");
+    return "/" + normalized;
+  }
+  /**
+   * List files and directories in the specified directory (non-recursive).
+   *
+   * @param dirPath - Virtual directory path (must start with /)
+   * @returns List of FileInfo objects for files and directories directly in the directory.
+   *          Directories have a trailing / in their path and is_dir=true.
+   */
+  async lsInfo(dirPath) {
+    try {
+      const resolvedPath = this.resolvePath(dirPath);
+      const result = await this.sandbox.file.listPath({
+        path: resolvedPath,
+        recursive: false,
+        show_hidden: false,
+        max_depth: 0,
+        include_size: false,
+        include_permissions: false,
+        sort_by: "name",
+        sort_desc: false
+      });
+      if (!result.ok) {
+        throw result.error;
+      }
+      const files = result.body?.data?.files?.map((file) => ({
+        path: this.toVirtualPath(file.path),
+        is_dir: file.is_directory,
+        size: file.size,
+        modified_at: file.modified_time
+      })) || [];
+      return files;
+    } catch (e) {
+      console.error(`Error listing files in ${dirPath}:`, e);
+      return [];
+    }
+  }
+  /**
+   * Read file content with line numbers.
+   *
+   * @param filePath - Virtual file path (must start with /)
+   * @param offset - Line offset to start reading from (0-indexed)
+   * @param limit - Maximum number of lines to read
+   * @returns Formatted file content with line numbers, or error message
+   */
+  async read(filePath, offset = 0, limit = 1e4) {
+    try {
+      const resolvedPath = this.resolvePath(filePath);
+      let content;
+      const result = await this.sandbox.file.readFile({
+        file: resolvedPath,
+        start_line: offset,
+        end_line: limit
+      });
+      if (!result.ok) {
+        throw result.error;
+      }
+      content = result.body?.data?.content || "";
+      return content;
+    } catch (e) {
+      return `Error: File '${filePath}' not found`;
+    }
+  }
+  /**
+   * Read file content as raw FileData.
+   *
+   * @param filePath - Virtual file path (must start with /)
+   * @returns Raw file content as FileData
+   */
+  async readRaw(filePath) {
+    try {
+      const content = await this.read(filePath);
+      return {
+        content: content.split("\n"),
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        modified_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (e) {
+      throw new Error(`Error reading file '${filePath}': ${e.message}`);
+    }
+  }
+  /**
+   * Create a new file with content.
+   * Returns WriteResult. External storage sets filesUpdate=null.
+   *
+   * @param filePath - Virtual file path (must start with /)
+   * @param content - File content as string
+   * @returns WriteResult with error populated on failure
+   */
+  async write(filePath, content) {
+    try {
+      const resolvedPath = this.resolvePath(filePath);
+      const result = await this.sandbox.file.writeFile({
+        file: resolvedPath,
+        content,
+        "encoding": "utf-8",
+        "append": false
+        // sudo: true
+      });
+      if (!result.ok) {
+        console.error(result.error);
+        throw result.error;
+      }
+      return {
+        path: filePath,
+        filesUpdate: {
+          [filePath]: {
+            content: content.split("\n"),
+            created_at: (/* @__PURE__ */ new Date()).toISOString(),
+            modified_at: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        }
+      };
+    } catch (e) {
+      throw new Error(`Error writing file '${filePath}': ${e.message}`);
+    }
+  }
+  /**
+   * Edit a file by replacing string occurrences.
+   * Returns EditResult. External storage sets filesUpdate=null.
+   *
+   * @param filePath - Virtual file path (must start with /)
+   * @param oldString - String to find and replace
+   * @param newString - Replacement string
+   * @param replaceAll - If true, replace all occurrences (default: false)
+   * @returns EditResult with error, path, filesUpdate, and occurrences
+   */
+  async edit(filePath, oldString, newString, replaceAll = false) {
+    try {
+      const resolvedPath = this.resolvePath(filePath);
+      const result = await this.sandbox.file.strReplaceEditor({
+        command: "str_replace",
+        path: resolvedPath,
+        old_str: oldString,
+        new_str: newString,
+        replace_mode: replaceAll ? "ALL" : "FIRST"
+      });
+      if (!result.ok) {
+        throw result.error;
+      }
+      return {
+        path: filePath,
+        filesUpdate: null
+      };
+    } catch (e) {
+      throw new Error(`Error editing file '${filePath}': ${e.message}`);
+    }
+  }
+  /**
+   * Structured search results or error string for invalid input.
+   *
+   * Searches file contents for a regex pattern within the sandbox.
+   *
+   * @param pattern - Regex pattern to search for
+   * @param searchPath - Base path to search from (default: "/")
+   * @param glob - Optional glob pattern to filter files (e.g., "*.py")
+   * @returns List of GrepMatch objects or error string for invalid regex
+   */
+  async grepRaw(pattern, searchPath = "/", glob = null) {
+    let baseFull;
+    baseFull = this.resolvePath(searchPath || "/");
+    const result = await this.sandbox.file.findFiles({
+      path: baseFull,
+      glob: glob || "**/*"
+    });
+    if (!result.ok) {
+      throw result.error;
+    }
+    const filePaths = result.body?.data?.files || [];
+    const matches = [];
+    for (const absolutePath of filePaths) {
+      const fileData = await this.sandbox.file.searchInFile({
+        file: absolutePath,
+        regex: pattern
+      });
+      if (!fileData.ok) {
+        continue;
+      }
+      const matchesData = fileData.body?.data?.matches || [];
+      const matchLines = fileData.body?.data?.line_numbers || [];
+      matchesData.forEach((match, index) => {
+        matches.push({
+          path: this.toVirtualPath(absolutePath),
+          line: matchLines[index],
+          text: match
+        });
+      });
+    }
+    return matches;
+  }
+  /**
+   * Structured glob matching returning FileInfo objects.
+   *
+   * @param pattern - Glob pattern (e.g., `*.py`, `**\/*.ts`)
+   * @param searchPath - Base path to search from (default: "/")
+   * @returns List of FileInfo objects matching the pattern
+   */
+  async globInfo(pattern, searchPath = "/") {
+    if (pattern.startsWith("/")) {
+      pattern = pattern.substring(1);
+    }
+    const resolvedSearchPath = this.resolvePath(searchPath);
+    const result = await this.sandbox.file.findFiles({
+      path: resolvedSearchPath,
+      glob: pattern || "**/*"
+    });
+    if (!result.ok) {
+      throw result.error;
+    }
+    const results = [];
+    for (const filePath of result.body?.data?.files || []) {
+      const fileInfo = await this.sandbox.file.listPath({
+        path: filePath,
+        recursive: false,
+        show_hidden: false,
+        max_depth: 1,
+        include_size: false,
+        include_permissions: false
+      });
+      if (!fileInfo.ok) {
+        continue;
+      }
+      results.push({
+        path: this.toVirtualPath(filePath),
+        is_dir: false,
+        size: fileInfo.body?.data?.files?.[0]?.size,
+        modified_at: fileInfo.body?.data?.files?.[0]?.modified_time
+      });
+    }
+    return results;
+  }
+};
+
+// src/deep_agent_new/backends/composite.ts
+var CompositeBackend = class {
+  constructor(defaultBackend, routes) {
+    this.default = defaultBackend;
+    this.routes = routes;
+    this.sortedRoutes = Object.entries(routes).sort(
+      (a, b) => b[0].length - a[0].length
+    );
+  }
+  /**
+   * Determine which backend handles this key and strip prefix.
+   *
+   * @param key - Original file path
+   * @returns Tuple of [backend, stripped_key] where stripped_key has the route
+   *          prefix removed (but keeps leading slash).
+   */
+  getBackendAndKey(key) {
+    for (const [prefix, backend] of this.sortedRoutes) {
+      if (key.startsWith(prefix)) {
+        const suffix = key.substring(prefix.length);
+        const strippedKey = suffix ? "/" + suffix : "/";
+        return [backend, strippedKey];
+      }
+    }
+    return [this.default, key];
+  }
+  /**
+   * List files and directories in the specified directory (non-recursive).
+   *
+   * @param path - Absolute path to directory
+   * @returns List of FileInfo objects with route prefixes added, for files and directories
+   *          directly in the directory. Directories have a trailing / in their path and is_dir=true.
+   */
+  async lsInfo(path5) {
+    for (const [routePrefix, backend] of this.sortedRoutes) {
+      if (path5.startsWith(routePrefix.replace(/\/$/, ""))) {
+        const suffix = path5.substring(routePrefix.length);
+        const searchPath = suffix ? "/" + suffix : "/";
+        const infos = await backend.lsInfo(searchPath);
+        const prefixed = [];
+        for (const fi of infos) {
+          prefixed.push({
+            ...fi,
+            path: routePrefix.slice(0, -1) + fi.path
+          });
+        }
+        return prefixed;
+      }
+    }
+    if (path5 === "/") {
+      const results = [];
+      const defaultInfos = await this.default.lsInfo(path5);
+      results.push(...defaultInfos);
+      for (const [routePrefix] of this.sortedRoutes) {
+        results.push({
+          path: routePrefix,
+          is_dir: true,
+          size: 0,
+          modified_at: ""
+        });
+      }
+      results.sort((a, b) => a.path.localeCompare(b.path));
+      return results;
+    }
+    return await this.default.lsInfo(path5);
+  }
+  /**
+   * Read file content, routing to appropriate backend.
+   *
+   * @param filePath - Absolute file path
+   * @param offset - Line offset to start reading from (0-indexed)
+   * @param limit - Maximum number of lines to read
+   * @returns Formatted file content with line numbers, or error message
+   */
+  async read(filePath, offset = 0, limit = 2e3) {
+    const [backend, strippedKey] = this.getBackendAndKey(filePath);
+    return await backend.read(strippedKey, offset, limit);
+  }
+  /**
+   * Read file content as raw FileData.
+   *
+   * @param filePath - Absolute file path
+   * @returns Raw file content as FileData
+   */
+  async readRaw(filePath) {
+    const [backend, strippedKey] = this.getBackendAndKey(filePath);
+    return await backend.readRaw(strippedKey);
+  }
+  /**
+   * Structured search results or error string for invalid input.
+   */
+  async grepRaw(pattern, path5 = "/", glob = null) {
+    for (const [routePrefix, backend] of this.sortedRoutes) {
+      if (path5.startsWith(routePrefix.replace(/\/$/, ""))) {
+        const searchPath = path5.substring(routePrefix.length - 1);
+        const raw = await backend.grepRaw(pattern, searchPath || "/", glob);
+        if (typeof raw === "string") {
+          return raw;
+        }
+        return raw.map((m) => ({
+          ...m,
+          path: routePrefix.slice(0, -1) + m.path
+        }));
+      }
+    }
+    const allMatches = [];
+    const rawDefault = await this.default.grepRaw(pattern, path5, glob);
+    if (typeof rawDefault === "string") {
+      return rawDefault;
+    }
+    allMatches.push(...rawDefault);
+    for (const [routePrefix, backend] of Object.entries(this.routes)) {
+      const raw = await backend.grepRaw(pattern, "/", glob);
+      if (typeof raw === "string") {
+        return raw;
+      }
+      allMatches.push(
+        ...raw.map((m) => ({
+          ...m,
+          path: routePrefix.slice(0, -1) + m.path
+        }))
+      );
+    }
+    return allMatches;
+  }
+  /**
+   * Structured glob matching returning FileInfo objects.
+   */
+  async globInfo(pattern, path5 = "/") {
+    const results = [];
+    for (const [routePrefix, backend] of this.sortedRoutes) {
+      if (path5.startsWith(routePrefix.replace(/\/$/, ""))) {
+        const searchPath = path5.substring(routePrefix.length - 1);
+        const infos = await backend.globInfo(pattern, searchPath || "/");
+        return infos.map((fi) => ({
+          ...fi,
+          path: routePrefix.slice(0, -1) + fi.path
+        }));
+      }
+    }
+    const defaultInfos = await this.default.globInfo(pattern, path5);
+    results.push(...defaultInfos);
+    for (const [routePrefix, backend] of Object.entries(this.routes)) {
+      const infos = await backend.globInfo(pattern, "/");
+      results.push(
+        ...infos.map((fi) => ({
+          ...fi,
+          path: routePrefix.slice(0, -1) + fi.path
+        }))
+      );
+    }
+    results.sort((a, b) => a.path.localeCompare(b.path));
+    return results;
+  }
+  /**
+   * Create a new file, routing to appropriate backend.
+   *
+   * @param filePath - Absolute file path
+   * @param content - File content as string
+   * @returns WriteResult with path or error
+   */
+  async write(filePath, content) {
+    const [backend, strippedKey] = this.getBackendAndKey(filePath);
+    return await backend.write(strippedKey, content);
+  }
+  /**
+   * Edit a file, routing to appropriate backend.
+   *
+   * @param filePath - Absolute file path
+   * @param oldString - String to find and replace
+   * @param newString - Replacement string
+   * @param replaceAll - If true, replace all occurrences
+   * @returns EditResult with path, occurrences, or error
+   */
+  async edit(filePath, oldString, newString, replaceAll = false) {
+    const [backend, strippedKey] = this.getBackendAndKey(filePath);
+    return await backend.edit(strippedKey, oldString, newString, replaceAll);
+  }
+};
 
-// src/agent_lattice/builders/commonMiddleware.ts
-async function createCommonMiddlewares(middlewareConfigs, filesystemBackend) {
-  const middlewares = [];
-  middlewares.push(createModelSelectorMiddleware());
+// src/agent_lattice/builders/filesystemBackend.ts
+function createFilesystemBackendFactory(middlewareConfigs, defualtRootLevel = "project", routesLevelConfig = {
+  "/agent/": "agent"
+  //默认配置 agent目录就是agent级别的
+}) {
   const filesystemConfig = middlewareConfigs.find((m) => m.type === "filesystem");
-  if (filesystemConfig?.enabled && filesystemBackend) {
-    const options = { backend: filesystemBackend };
-    middlewares.push(createFilesystemMiddleware(options));
+  if (!filesystemConfig || !filesystemConfig.enabled) {
+    return void 0;
   }
-  for (const config of middlewareConfigs) {
-    if (!config.enabled || config.type === "filesystem") continue;
-    switch (config.type) {
-      case "code_eval":
-        middlewares.push(createCodeEvalMiddleware(config.config));
-        break;
-      case "browser":
-        middlewares.push(createBrowserMiddleware(config.config));
-        break;
-      case "sql":
-        {
-          const sqlConfig = config.config;
-          if (sqlConfig.databaseKeys && sqlConfig.databaseKeys.length > 0) {
-            const databaseConfigs = global.__DATABASE_CONFIGS__ || [];
-            const descriptions = {};
-            for (const db of databaseConfigs) {
-              if (db.key && sqlConfig.databaseKeys.includes(db.key)) {
-                descriptions[db.key] = db.description || db.name || "";
-              }
-            }
-            middlewares.push(createSqlMiddleware({
-              databaseKeys: sqlConfig.databaseKeys,
-              databaseDescriptions: descriptions
-            }));
-          }
-        }
-        break;
-      case "skill":
-        middlewares.push(createSkillMiddleware(config.config));
-        break;
-      case "metrics":
-        {
-          const metricsConfig = config.config;
-          if (metricsConfig.connectAll || metricsConfig.serverKeys && metricsConfig.serverKeys.length > 0) {
-            middlewares.push(createMetricsMiddleware(metricsConfig));
-          }
-        }
-        break;
-      case "ask_user_to_clarify":
-        middlewares.push(createAskUserClarifyMiddleware());
-        break;
-      case "widget":
-        middlewares.push(createWidgetMiddleware());
-        break;
-      case "claw":
-        if (filesystemBackend) {
-          const clawConfig = config.config;
-          middlewares.push(createClawMiddleware({
-            backend: filesystemBackend,
-            injectBootstrapFiles: clawConfig.injectBootstrapFiles ?? true,
-            bootstrapFiles: clawConfig.bootstrapFiles ?? {}
-          }));
-        }
-        break;
+  const isolatedLevel = filesystemConfig.config?.isolatedLevel || "global";
+  return async (stateAndStore) => {
+    const { tenantId, workspaceId, projectId, assistant_id } = stateAndStore;
+    let sandboxName = "global";
+    if (isolatedLevel === "agent") {
+      sandboxName = "agent";
+    } else if (isolatedLevel === "thread") {
+      sandboxName = "thread";
     }
-  }
-  return middlewares;
+    const sandboxManager = sandboxLatticeManager.getSandboxLattice("default");
+    if (!sandboxManager) {
+      throw new Error("Sandbox manager not found");
+    }
+    const getWS = (rootLevel) => {
+      let workingDirectory = `/tenants/${tenantId}`;
+      if (assistant_id && rootLevel === "agent") {
+        workingDirectory = `/tenants/${tenantId}/agents/${assistant_id}`;
+      } else if (workspaceId && projectId && rootLevel === "project") {
+        workingDirectory = `/tenants/${tenantId}/workspaces/${workspaceId}/${projectId}`;
+      }
+      return workingDirectory;
+    };
+    const sandboxInstance = await sandboxManager.createSandbox(sandboxName);
+    const sandboxfs = new SandboxFilesystem({
+      sandboxInstance,
+      workingDirectory: getWS(defualtRootLevel)
+    });
+    const routers = Object.keys(routesLevelConfig).reduce((pre, curr) => ({
+      ...pre,
+      [curr]: new SandboxFilesystem({
+        sandboxInstance,
+        workingDirectory: getWS(routesLevelConfig[curr])
+      })
+    }), {});
+    const compositeBackend = new CompositeBackend(sandboxfs, {
+      ...routers
+    });
+    return compositeBackend;
+  };
 }
 
 // src/agent_lattice/builders/ReActAgentGraphBuilder.ts
 var ReActAgentGraphBuilder = class {
-  createFilesystemBackendFactory(middlewareConfigs, agentLattice) {
-    const filesystemConfig = middlewareConfigs.find((m) => m.type === "filesystem");
-    if (!filesystemConfig || !filesystemConfig.enabled) {
-      return void 0;
-    }
-    const isolatedLevel = filesystemConfig.config?.isolatedLevel || "global";
-    const agentTenantId = agentLattice.config.tenantId;
-    return async (stateAndStore) => {
-      const { tenantId: runtimeTenantId, workspaceId, projectId } = stateAndStore;
-      const tenantId = runtimeTenantId || agentTenantId;
-      let sandboxName = "global";
-      if (isolatedLevel === "agent") {
-        sandboxName = "agent";
-      } else if (isolatedLevel === "thread") {
-        sandboxName = "thread";
-      }
-      const sandboxManager = sandboxLatticeManager.getSandboxLattice("default");
-      if (!sandboxManager) {
-        throw new Error("Sandbox manager not found");
-      }
-      let workingDirectory = "/";
-      if (workspaceId && projectId) {
-        if (tenantId) {
-          workingDirectory = `/tenants/${tenantId}/workspaces/${workspaceId}/${projectId}`;
-        } else {
-          workingDirectory = `/${workspaceId}/${projectId}`;
-        }
-      }
-      return new SandboxFilesystem({
-        sandboxInstance: await sandboxManager.createSandbox(sandboxName),
-        workingDirectory
-      });
-    };
-  }
   async createMiddlewares(middlewareConfigs) {
     return await createCommonMiddlewares(middlewareConfigs);
   }
@@ -9886,12 +10308,12 @@ var ReActAgentGraphBuilder = class {
    */
   async build(agentLattice, params) {
     const tools = params.tools.map((t) => {
-      const tool50 = getToolClient(t.key);
-      return tool50;
-    }).filter((tool50) => tool50 !== void 0);
+      const tool51 = getToolClient(t.key);
+      return tool51;
+    }).filter((tool51) => tool51 !== void 0);
     const stateSchema2 = createReactAgentSchema(params.stateSchema);
     const middlewareConfigs = params.middleware || [];
-    const filesystemBackend = this.createFilesystemBackendFactory(middlewareConfigs, agentLattice);
+    const filesystemBackend = createFilesystemBackendFactory(middlewareConfigs);
     const middlewares = await createCommonMiddlewares(middlewareConfigs, filesystemBackend);
     return createAgent({
       model: params.model,
@@ -9914,12 +10336,12 @@ import {
 } from "langchain";
 
 // src/deep_agent_new/middleware/subagents.ts
-import { z as z47 } from "zod/v3";
+import { z as z48 } from "zod/v3";
 import {
-  createMiddleware as createMiddleware11,
+  createMiddleware as createMiddleware13,
   createAgent as createAgent2,
-  tool as tool46,
-  ToolMessage as ToolMessage3,
+  tool as tool47,
+  ToolMessage as ToolMessage4,
   humanInTheLoopMiddleware
 } from "langchain";
 import { Command as Command2, getCurrentTaskInput as getCurrentTaskInput2, GraphInterrupt as GraphInterrupt3 } from "@langchain/langgraph";
@@ -10490,7 +10912,7 @@ function returnCommandWithStateUpdate(result, toolCallId) {
     update: {
       ...stateUpdate,
       messages: [
-        new ToolMessage3({
+        new ToolMessage4({
           content: lastMessage?.content || "Task Failed to complete",
           tool_call_id: toolCallId,
           name: "task"
@@ -10572,7 +10994,7 @@ function createTaskTool(options) {
     generalPurposeAgent
   });
   const finalTaskDescription = taskDescription ? taskDescription : getTaskToolDescription(subagentDescriptions);
-  return tool46(
+  return tool47(
     async (input, config) => {
       const { description, subagent_type } = input;
       let assistant_id = subagent_type;
@@ -10626,7 +11048,7 @@ function createTaskTool(options) {
         return new Command2({
           update: {
             messages: [
-              new ToolMessage3({
+              new ToolMessage4({
                 content: error instanceof Error ? error.message : "Task Failed to complete",
                 tool_call_id: config.toolCall.id,
                 name: "task"
@@ -10639,9 +11061,9 @@ function createTaskTool(options) {
     {
       name: "task",
       description: finalTaskDescription,
-      schema: z47.object({
-        description: z47.string().describe("The task to execute with the selected agent"),
-        subagent_type: z47.string().describe(
+      schema: z48.object({
+        description: z48.string().describe("The task to execute with the selected agent"),
+        subagent_type: z48.string().describe(
           `Name of the agent to use. Available: ${Object.keys(
             subagentGraphs
           ).join(", ")}`
@@ -10670,7 +11092,7 @@ function createSubAgentMiddleware(options) {
     generalPurposeAgent,
     taskDescription
   });
-  return createMiddleware11({
+  return createMiddleware13({
     name: "subAgentMiddleware",
     tools: [taskTool],
     wrapModelCall: async (request, handler) => {
@@ -10691,14 +11113,14 @@ ${systemPrompt}` : systemPrompt;
 
 // src/deep_agent_new/middleware/patch_tool_calls.ts
 import {
-  createMiddleware as createMiddleware12,
-  ToolMessage as ToolMessage4,
-  AIMessage as AIMessage2
+  createMiddleware as createMiddleware14,
+  ToolMessage as ToolMessage5,
+  AIMessage as AIMessage3
 } from "langchain";
 import { RemoveMessage } from "@langchain/core/messages";
 import { REMOVE_ALL_MESSAGES } from "@langchain/langgraph";
 function createPatchToolCallsMiddleware() {
-  return createMiddleware12({
+  return createMiddleware14({
     name: "patchToolCallsMiddleware",
     beforeAgent: async (state) => {
       const messages = state.messages;
@@ -10709,15 +11131,15 @@ function createPatchToolCallsMiddleware() {
       for (let i = 0; i < messages.length; i++) {
         const msg = messages[i];
         patchedMessages.push(msg);
-        if (AIMessage2.isInstance(msg) && msg.tool_calls != null) {
+        if (AIMessage3.isInstance(msg) && msg.tool_calls != null) {
           for (const toolCall of msg.tool_calls) {
             const correspondingToolMsg = messages.slice(i).find(
-              (m) => ToolMessage4.isInstance(m) && m.tool_call_id === toolCall.id
+              (m) => ToolMessage5.isInstance(m) && m.tool_call_id === toolCall.id
             );
             if (!correspondingToolMsg) {
               const toolMsg = `Tool call ${toolCall.name} with id ${toolCall.id} was cancelled - another message came in before it could be completed.`;
               patchedMessages.push(
-                new ToolMessage4({
+                new ToolMessage5({
                   content: toolMsg,
                   name: toolCall.name,
                   tool_call_id: toolCall.id
@@ -11462,261 +11884,81 @@ var FilesystemBackend = class {
               virtPath = fp;
             }
             if (!results[virtPath]) {
-              results[virtPath] = [];
-            }
-            results[virtPath].push([i + 1, line]);
-          }
-        }
-      } catch {
-        continue;
-      }
-    }
-    return results;
-  }
-  /**
-   * Structured glob matching returning FileInfo objects.
-   */
-  async globInfo(pattern, searchPath = "/") {
-    if (pattern.startsWith("/")) {
-      pattern = pattern.substring(1);
-    }
-    const resolvedSearchPath = searchPath === "/" ? this.cwd : this.resolvePath(searchPath);
-    try {
-      const stat3 = await fs2.stat(resolvedSearchPath);
-      if (!stat3.isDirectory()) {
-        return [];
-      }
-    } catch {
-      return [];
-    }
-    const results = [];
-    try {
-      const matches = await fg(pattern, {
-        cwd: resolvedSearchPath,
-        absolute: true,
-        onlyFiles: true,
-        dot: true
-      });
-      for (const matchedPath of matches) {
-        try {
-          const stat3 = await fs2.stat(matchedPath);
-          if (!stat3.isFile()) continue;
-          const normalizedPath = matchedPath.split("/").join(path4.sep);
-          if (!this.virtualMode) {
-            results.push({
-              path: normalizedPath,
-              is_dir: false,
-              size: stat3.size,
-              modified_at: stat3.mtime.toISOString()
-            });
-          } else {
-            const cwdStr = this.cwd.endsWith(path4.sep) ? this.cwd : this.cwd + path4.sep;
-            let relativePath;
-            if (normalizedPath.startsWith(cwdStr)) {
-              relativePath = normalizedPath.substring(cwdStr.length);
-            } else if (normalizedPath.startsWith(this.cwd)) {
-              relativePath = normalizedPath.substring(this.cwd.length).replace(/^[/\\]/, "");
-            } else {
-              relativePath = normalizedPath;
-            }
-            relativePath = relativePath.split(path4.sep).join("/");
-            const virt = "/" + relativePath;
-            results.push({
-              path: virt,
-              is_dir: false,
-              size: stat3.size,
-              modified_at: stat3.mtime.toISOString()
-            });
-          }
-        } catch {
-          continue;
-        }
-      }
-    } catch {
-    }
-    results.sort((a, b) => a.path.localeCompare(b.path));
-    return results;
-  }
-};
-
-// src/deep_agent_new/backends/composite.ts
-var CompositeBackend = class {
-  constructor(defaultBackend, routes) {
-    this.default = defaultBackend;
-    this.routes = routes;
-    this.sortedRoutes = Object.entries(routes).sort(
-      (a, b) => b[0].length - a[0].length
-    );
-  }
-  /**
-   * Determine which backend handles this key and strip prefix.
-   *
-   * @param key - Original file path
-   * @returns Tuple of [backend, stripped_key] where stripped_key has the route
-   *          prefix removed (but keeps leading slash).
-   */
-  getBackendAndKey(key) {
-    for (const [prefix, backend] of this.sortedRoutes) {
-      if (key.startsWith(prefix)) {
-        const suffix = key.substring(prefix.length);
-        const strippedKey = suffix ? "/" + suffix : "/";
-        return [backend, strippedKey];
-      }
-    }
-    return [this.default, key];
-  }
-  /**
-   * List files and directories in the specified directory (non-recursive).
-   *
-   * @param path - Absolute path to directory
-   * @returns List of FileInfo objects with route prefixes added, for files and directories
-   *          directly in the directory. Directories have a trailing / in their path and is_dir=true.
-   */
-  async lsInfo(path5) {
-    for (const [routePrefix, backend] of this.sortedRoutes) {
-      if (path5.startsWith(routePrefix.replace(/\/$/, ""))) {
-        const suffix = path5.substring(routePrefix.length);
-        const searchPath = suffix ? "/" + suffix : "/";
-        const infos = await backend.lsInfo(searchPath);
-        const prefixed = [];
-        for (const fi of infos) {
-          prefixed.push({
-            ...fi,
-            path: routePrefix.slice(0, -1) + fi.path
-          });
+              results[virtPath] = [];
+            }
+            results[virtPath].push([i + 1, line]);
+          }
         }
-        return prefixed;
-      }
-    }
-    if (path5 === "/") {
-      const results = [];
-      const defaultInfos = await this.default.lsInfo(path5);
-      results.push(...defaultInfos);
-      for (const [routePrefix] of this.sortedRoutes) {
-        results.push({
-          path: routePrefix,
-          is_dir: true,
-          size: 0,
-          modified_at: ""
-        });
+      } catch {
+        continue;
       }
-      results.sort((a, b) => a.path.localeCompare(b.path));
-      return results;
     }
-    return await this.default.lsInfo(path5);
-  }
-  /**
-   * Read file content, routing to appropriate backend.
-   *
-   * @param filePath - Absolute file path
-   * @param offset - Line offset to start reading from (0-indexed)
-   * @param limit - Maximum number of lines to read
-   * @returns Formatted file content with line numbers, or error message
-   */
-  async read(filePath, offset = 0, limit = 2e3) {
-    const [backend, strippedKey] = this.getBackendAndKey(filePath);
-    return await backend.read(strippedKey, offset, limit);
-  }
-  /**
-   * Read file content as raw FileData.
-   *
-   * @param filePath - Absolute file path
-   * @returns Raw file content as FileData
-   */
-  async readRaw(filePath) {
-    const [backend, strippedKey] = this.getBackendAndKey(filePath);
-    return await backend.readRaw(strippedKey);
+    return results;
   }
   /**
-   * Structured search results or error string for invalid input.
+   * Structured glob matching returning FileInfo objects.
    */
-  async grepRaw(pattern, path5 = "/", glob = null) {
-    for (const [routePrefix, backend] of this.sortedRoutes) {
-      if (path5.startsWith(routePrefix.replace(/\/$/, ""))) {
-        const searchPath = path5.substring(routePrefix.length - 1);
-        const raw = await backend.grepRaw(pattern, searchPath || "/", glob);
-        if (typeof raw === "string") {
-          return raw;
-        }
-        return raw.map((m) => ({
-          ...m,
-          path: routePrefix.slice(0, -1) + m.path
-        }));
-      }
-    }
-    const allMatches = [];
-    const rawDefault = await this.default.grepRaw(pattern, path5, glob);
-    if (typeof rawDefault === "string") {
-      return rawDefault;
+  async globInfo(pattern, searchPath = "/") {
+    if (pattern.startsWith("/")) {
+      pattern = pattern.substring(1);
     }
-    allMatches.push(...rawDefault);
-    for (const [routePrefix, backend] of Object.entries(this.routes)) {
-      const raw = await backend.grepRaw(pattern, "/", glob);
-      if (typeof raw === "string") {
-        return raw;
+    const resolvedSearchPath = searchPath === "/" ? this.cwd : this.resolvePath(searchPath);
+    try {
+      const stat3 = await fs2.stat(resolvedSearchPath);
+      if (!stat3.isDirectory()) {
+        return [];
       }
-      allMatches.push(
-        ...raw.map((m) => ({
-          ...m,
-          path: routePrefix.slice(0, -1) + m.path
-        }))
-      );
+    } catch {
+      return [];
     }
-    return allMatches;
-  }
-  /**
-   * Structured glob matching returning FileInfo objects.
-   */
-  async globInfo(pattern, path5 = "/") {
     const results = [];
-    for (const [routePrefix, backend] of this.sortedRoutes) {
-      if (path5.startsWith(routePrefix.replace(/\/$/, ""))) {
-        const searchPath = path5.substring(routePrefix.length - 1);
-        const infos = await backend.globInfo(pattern, searchPath || "/");
-        return infos.map((fi) => ({
-          ...fi,
-          path: routePrefix.slice(0, -1) + fi.path
-        }));
+    try {
+      const matches = await fg(pattern, {
+        cwd: resolvedSearchPath,
+        absolute: true,
+        onlyFiles: true,
+        dot: true
+      });
+      for (const matchedPath of matches) {
+        try {
+          const stat3 = await fs2.stat(matchedPath);
+          if (!stat3.isFile()) continue;
+          const normalizedPath = matchedPath.split("/").join(path4.sep);
+          if (!this.virtualMode) {
+            results.push({
+              path: normalizedPath,
+              is_dir: false,
+              size: stat3.size,
+              modified_at: stat3.mtime.toISOString()
+            });
+          } else {
+            const cwdStr = this.cwd.endsWith(path4.sep) ? this.cwd : this.cwd + path4.sep;
+            let relativePath;
+            if (normalizedPath.startsWith(cwdStr)) {
+              relativePath = normalizedPath.substring(cwdStr.length);
+            } else if (normalizedPath.startsWith(this.cwd)) {
+              relativePath = normalizedPath.substring(this.cwd.length).replace(/^[/\\]/, "");
+            } else {
+              relativePath = normalizedPath;
+            }
+            relativePath = relativePath.split(path4.sep).join("/");
+            const virt = "/" + relativePath;
+            results.push({
+              path: virt,
+              is_dir: false,
+              size: stat3.size,
+              modified_at: stat3.mtime.toISOString()
+            });
+          }
+        } catch {
+          continue;
+        }
       }
-    }
-    const defaultInfos = await this.default.globInfo(pattern, path5);
-    results.push(...defaultInfos);
-    for (const [routePrefix, backend] of Object.entries(this.routes)) {
-      const infos = await backend.globInfo(pattern, "/");
-      results.push(
-        ...infos.map((fi) => ({
-          ...fi,
-          path: routePrefix.slice(0, -1) + fi.path
-        }))
-      );
+    } catch {
     }
     results.sort((a, b) => a.path.localeCompare(b.path));
     return results;
   }
-  /**
-   * Create a new file, routing to appropriate backend.
-   *
-   * @param filePath - Absolute file path
-   * @param content - File content as string
-   * @returns WriteResult with path or error
-   */
-  async write(filePath, content) {
-    const [backend, strippedKey] = this.getBackendAndKey(filePath);
-    return await backend.write(strippedKey, content);
-  }
-  /**
-   * Edit a file, routing to appropriate backend.
-   *
-   * @param filePath - Absolute file path
-   * @param oldString - String to find and replace
-   * @param newString - Replacement string
-   * @param replaceAll - If true, replace all occurrences
-   * @returns EditResult with path, occurrences, or error
-   */
-  async edit(filePath, oldString, newString, replaceAll = false) {
-    const [backend, strippedKey] = this.getBackendAndKey(filePath);
-    return await backend.edit(strippedKey, oldString, newString, replaceAll);
-  }
 };
 
 // src/deep_agent_new/backends/memory.ts
@@ -11834,8 +12076,8 @@ var MemoryBackend = class {
 
 // src/deep_agent_new/middleware/todos.ts
 import { Command as Command3 } from "@langchain/langgraph";
-import { z as z48 } from "zod";
-import { createMiddleware as createMiddleware13, tool as tool47, ToolMessage as ToolMessage5 } from "langchain";
+import { z as z49 } from "zod";
+import { createMiddleware as createMiddleware15, tool as tool48, ToolMessage as ToolMessage6 } from "langchain";
 var WRITE_TODOS_DESCRIPTION = `Use this tool to create and manage a structured task list for your current work session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
 It also helps the user understand the progress of the task and overall progress of their requests.
 Only use this tool if you think it will be helpful in staying organized. If the user's request is trivial and takes less than 3 steps, it is better to NOT use this tool and just do the taks directly.
@@ -12062,20 +12304,20 @@ Writing todos takes time and tokens, use it when it is helpful for managing comp
 ## Important To-Do List Usage Notes to Remember
 - The \`write_todos\` tool should never be called multiple times in parallel.
 - Don't be afraid to revise the To-Do list as you go. New information may reveal new tasks that need to be done, or old tasks that are irrelevant.`;
-var TodoStatus = z48.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
-var TodoSchema = z48.object({
-  content: z48.string().describe("Content of the todo item"),
+var TodoStatus = z49.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
+var TodoSchema = z49.object({
+  content: z49.string().describe("Content of the todo item"),
   status: TodoStatus
 });
-var stateSchema = z48.object({ todos: z48.array(TodoSchema).default([]) });
+var stateSchema = z49.object({ todos: z49.array(TodoSchema).default([]) });
 function todoListMiddleware(options) {
-  const writeTodos = tool47(
+  const writeTodos = tool48(
     ({ todos }, config) => {
       return new Command3({
         update: {
           todos,
           messages: [
-            new ToolMessage5({
+            new ToolMessage6({
               content: genUIMarkdown("todo_list", todos),
               tool_call_id: config.toolCall?.id
             })
@@ -12086,12 +12328,12 @@ function todoListMiddleware(options) {
     {
       name: "write_todos",
       description: options?.toolDescription ?? WRITE_TODOS_DESCRIPTION,
-      schema: z48.object({
-        todos: z48.array(TodoSchema).describe("List of todo items to update")
+      schema: z49.object({
+        todos: z49.array(TodoSchema).describe("List of todo items to update")
       })
     }
   );
-  return createMiddleware13({
+  return createMiddleware15({
     name: "todoListMiddleware",
     stateSchema,
     tools: [writeTodos],
@@ -12190,50 +12432,8 @@ ${BASE_PROMPT}` : BASE_PROMPT;
   });
 }
 
-// src/agent_lattice/builders/filesystemBackend.ts
-function createFilesystemBackendFactory(middlewareConfigs) {
-  const filesystemConfig = middlewareConfigs.find((m) => m.type === "filesystem");
-  if (!filesystemConfig || !filesystemConfig.enabled) {
-    return void 0;
-  }
-  const isolatedLevel = filesystemConfig.config?.isolatedLevel || "global";
-  return async (stateAndStore) => {
-    const { tenantId, workspaceId, projectId } = stateAndStore;
-    let sandboxName = "global";
-    if (isolatedLevel === "agent") {
-      sandboxName = "agent";
-    } else if (isolatedLevel === "thread") {
-      sandboxName = "thread";
-    }
-    const sandboxManager = sandboxLatticeManager.getSandboxLattice("default");
-    if (!sandboxManager) {
-      throw new Error("Sandbox manager not found");
-    }
-    let workingDirectory = "/";
-    if (workspaceId && projectId) {
-      if (tenantId) {
-        workingDirectory = `/tenants/${tenantId}/workspaces/${workspaceId}/${projectId}`;
-      } else {
-        workingDirectory = `/workspaces/${workspaceId}/${projectId}`;
-      }
-    }
-    const sandboxfs = new SandboxFilesystem({
-      sandboxInstance: await sandboxManager.createSandbox(sandboxName),
-      workingDirectory
-    });
-    const compositeBackend = new CompositeBackend(sandboxfs, {});
-    return compositeBackend;
-  };
-}
-
 // src/agent_lattice/builders/DeepAgentGraphBuilder.ts
 var DeepAgentGraphBuilder = class {
-  /**
-   * 根据 middleware 配置创建 middlewares
-   */
-  async createMiddlewares(middlewareConfigs) {
-    return await createCommonMiddlewares(middlewareConfigs);
-  }
   /**
    * 构建Deep Agent Graph
    *
@@ -12245,7 +12445,7 @@ var DeepAgentGraphBuilder = class {
     const tools = params.tools.map((t) => {
       const toolClient = getToolClient(t.key);
       return toolClient;
-    }).filter((tool50) => tool50 !== void 0);
+    }).filter((tool51) => tool51 !== void 0);
     const subagents = await Promise.all(params.subAgents.map(async (sa) => {
       if (sa.client) {
         return {
@@ -12268,7 +12468,7 @@ var DeepAgentGraphBuilder = class {
     }));
     const middlewareConfigs = params.middleware || [];
     const filesystemBackend = createFilesystemBackendFactory(middlewareConfigs);
-    const middlewares = await this.createMiddlewares(middlewareConfigs);
+    const middlewares = await createCommonMiddlewares(middlewareConfigs, filesystemBackend, true);
     const deepAgent = createDeepAgent({
       tools,
       model: params.model,
@@ -12285,7 +12485,7 @@ var DeepAgentGraphBuilder = class {
 };
 
 // src/agent_team/agent_team.ts
-import { z as z51 } from "zod/v3";
+import { z as z52 } from "zod/v3";
 import { createAgent as createAgent5 } from "langchain";
 
 // src/agent_team/types.ts
@@ -12721,14 +12921,14 @@ var InMemoryMailboxStore = class {
 };
 
 // src/agent_team/middleware/team.ts
-import { z as z50 } from "zod/v3";
-import { createMiddleware as createMiddleware14, createAgent as createAgent4, tool as tool49, ToolMessage as ToolMessage7 } from "langchain";
+import { z as z51 } from "zod/v3";
+import { createMiddleware as createMiddleware16, createAgent as createAgent4, tool as tool50, ToolMessage as ToolMessage8 } from "langchain";
 import { Command as Command5, getCurrentTaskInput as getCurrentTaskInput3 } from "@langchain/langgraph";
 import { v4 as uuidv4 } from "uuid";
 
 // src/agent_team/middleware/teammate_tools.ts
-import { z as z49 } from "zod/v3";
-import { tool as tool48, ToolMessage as ToolMessage6 } from "langchain";
+import { z as z50 } from "zod/v3";
+import { tool as tool49, ToolMessage as ToolMessage7 } from "langchain";
 import { Command as Command4 } from "@langchain/langgraph";
 
 // src/agent_team/middleware/formatMessages.ts
@@ -12753,7 +12953,7 @@ ${meta}${body}`;
 // src/agent_team/middleware/teammate_tools.ts
 function createTeammateTools(options) {
   const { teamId, agentId, taskListStore, mailboxStore } = options;
-  const claimTaskTool = tool48(
+  const claimTaskTool = tool49(
     async (input) => {
       const task = await taskListStore.claimTaskById(
         teamId,
@@ -12778,12 +12978,12 @@ function createTeammateTools(options) {
     {
       name: "claim_task",
       description: "Pick a task to work on by task_id. Use check_tasks first to see all tasks; then call this with the task_id you choose. The task's assignee is set to you and you should focus on that task until you complete_task or fail_task it.",
-      schema: z49.object({
-        task_id: z49.string().describe("ID of the task to claim (e.g. task-01). Use check_tasks to see IDs.")
+      schema: z50.object({
+        task_id: z50.string().describe("ID of the task to claim (e.g. task-01). Use check_tasks to see IDs.")
       })
     }
   );
-  const completeTaskTool = tool48(
+  const completeTaskTool = tool49(
     async (input) => {
       const task = await taskListStore.completeTask(
         teamId,
@@ -12804,13 +13004,13 @@ function createTeammateTools(options) {
     {
       name: "complete_task",
       description: "Mark a claimed task as completed with a result summary. Call this after you have finished working on a task.",
-      schema: z49.object({
-        task_id: z49.string().describe("ID of the task to complete"),
-        result: z49.string().describe("Summary of the task result")
+      schema: z50.object({
+        task_id: z50.string().describe("ID of the task to complete"),
+        result: z50.string().describe("Summary of the task result")
       })
     }
   );
-  const failTaskTool = tool48(
+  const failTaskTool = tool49(
     async (input) => {
       const task = await taskListStore.failTask(
         teamId,
@@ -12831,13 +13031,13 @@ function createTeammateTools(options) {
     {
       name: "fail_task",
       description: "Mark a claimed task as failed with an error description. Call this if you cannot complete the task.",
-      schema: z49.object({
-        task_id: z49.string().describe("ID of the task to fail"),
-        error: z49.string().describe("Description of why the task failed")
+      schema: z50.object({
+        task_id: z50.string().describe("ID of the task to fail"),
+        error: z50.string().describe("Description of why the task failed")
       })
     }
   );
-  const sendMessageTool = tool48(
+  const sendMessageTool = tool49(
     async (input) => {
       await mailboxStore.sendMessage(
         teamId,
@@ -12851,11 +13051,11 @@ function createTeammateTools(options) {
     {
       name: "send_message",
       description: 'Send a message to the team lead or another teammate via the mailbox. Use "team_lead" to message the team lead. Use this to report discoveries, request guidance, or suggest new tasks.',
-      schema: z49.object({
-        to: z49.string().describe(
+      schema: z50.object({
+        to: z50.string().describe(
           'Recipient agent name (e.g. "team_lead" or a teammate name)'
         ),
-        content: z49.string().describe("Message content")
+        content: z50.string().describe("Message content")
       })
     }
   );
@@ -12875,7 +13075,7 @@ function createTeammateTools(options) {
       read: msg.read
     }));
   };
-  const readMessagesTool = tool48(
+  const readMessagesTool = tool49(
     async (input, config) => {
       const formatAndMarkAsRead = async (msgs2) => {
         for (const msg of msgs2) {
@@ -12887,7 +13087,7 @@ function createTeammateTools(options) {
       if (msgs.length > 0) {
         const formatted2 = await formatAndMarkAsRead(msgs);
         const relevantMsgs2 = await getRelevantMessagesForState();
-        const toolMessage2 = new ToolMessage6({
+        const toolMessage2 = new ToolMessage7({
           content: formatted2,
           tool_call_id: config.toolCall?.id,
           name: "read_messages"
@@ -12912,7 +13112,7 @@ function createTeammateTools(options) {
       });
       const relevantMsgs = await getRelevantMessagesForState();
       if (msgs.length === 0) {
-        const toolMessage2 = new ToolMessage6({
+        const toolMessage2 = new ToolMessage7({
           content: "No unread messages.",
           tool_call_id: config.toolCall?.id,
           name: "read_messages"
@@ -12922,7 +13122,7 @@ function createTeammateTools(options) {
         });
       }
       const formatted = await formatAndMarkAsRead(msgs);
-      const toolMessage = new ToolMessage6({
+      const toolMessage = new ToolMessage7({
         content: formatted,
         tool_call_id: config.toolCall?.id,
         name: "read_messages"
@@ -12934,10 +13134,10 @@ function createTeammateTools(options) {
     {
       name: "read_messages",
       description: "Read unread messages from the mailbox. Returns immediately if messages exist, otherwise waits for up to 3 minutes for new messages.",
-      schema: z49.object({})
+      schema: z50.object({})
     }
   );
-  const checkTasksTool = tool48(
+  const checkTasksTool = tool49(
     async () => {
       const tasks = await taskListStore.getAllTasks(teamId);
       return formatTaskSummary(tasks);
@@ -12945,10 +13145,10 @@ function createTeammateTools(options) {
     {
       name: "check_tasks",
       description: "Use this tool to get the current status of all tasks in a team. This is your primary way to monitor task progress.",
-      schema: z49.object({})
+      schema: z50.object({})
     }
   );
-  const broadcastMessageTool = tool48(
+  const broadcastMessageTool = tool49(
     async (input) => {
       const allAgents = await mailboxStore.getRegisteredAgents(teamId);
       const recipients = allAgents.filter((a) => a !== agentId);
@@ -12967,8 +13167,8 @@ function createTeammateTools(options) {
     {
       name: "broadcast_message",
       description: "Send a message to everyone in the team except yourself. Use this to share updates or information with all teammates and the team lead at once.",
-      schema: z49.object({
-        content: z49.string().describe("Message content to broadcast to others")
+      schema: z50.object({
+        content: z50.string().describe("Message content to broadcast to others")
       })
     }
   );
@@ -13202,12 +13402,12 @@ async function spawnTeammate(options) {
 function createTeamMiddleware(options) {
   const { teamConfig, taskListStore, mailboxStore, tenantId } = options;
   const defaultModel = teamConfig.model ?? "claude-sonnet-4-5-20250929";
-  const createTeamTool = tool49(
+  const createTeamTool = tool50(
     async (input, config) => {
       const state = getCurrentTaskInput3();
       if (state?.team?.teamId) {
         const existingId = state.team.teamId;
-        const msg = new ToolMessage7({
+        const msg = new ToolMessage8({
           content: `A team is already active (id: ${existingId}). Use this team_id for \`check_tasks\`, \`read_messages\`, \`add_tasks\`, \`send_message\`, \`assign_task\`, \`set_task_status\`, and \`set_task_dependencies\`. Do not call \`create_team\` again unless you need a fresh team for a new objective.`,
           tool_call_id: config.toolCall?.id,
           name: "create_team"
@@ -13296,7 +13496,7 @@ Teammates are now working in the background. Keep calling \`check_tasks\` and \`
 \`\`\`json
 ${teamJson}
 \`\`\``;
-      const toolMessage = new ToolMessage7({
+      const toolMessage = new ToolMessage8({
         content: summary,
         tool_call_id: config.toolCall?.id,
         name: "create_team"
@@ -13357,20 +13557,20 @@ After calling create_team, you MUST:
 2. When messages indicate task changes, call check_tasks to get full task status
 3. Continue until all tasks show "completed" or "failed"
 4. Do NOT assume tasks are done - always verify with check_tasks`,
-      schema: z50.object({
-        tasks: z50.array(
-          z50.object({
-            id: z50.string().describe("Task ID in format task-01, task-02, etc."),
-            title: z50.string().describe("Short task title"),
-            description: z50.string().describe("Detailed task description - what exactly needs to be done"),
-            dependencies: z50.array(z50.string()).optional().default([]).describe('Array of task IDs that must complete before this task (e.g. ["task-01"])')
+      schema: z51.object({
+        tasks: z51.array(
+          z51.object({
+            id: z51.string().describe("Task ID in format task-01, task-02, etc."),
+            title: z51.string().describe("Short task title"),
+            description: z51.string().describe("Detailed task description - what exactly needs to be done"),
+            dependencies: z51.array(z51.string()).optional().default([]).describe('Array of task IDs that must complete before this task (e.g. ["task-01"])')
           })
         ).describe("List of tasks for teammates to work on. Each task needs unique ID (task-01, task-02, etc.)."),
-        teammates: z50.array(
-          z50.object({
-            name: z50.string().describe("Teammate name (must match a pre-configured teammate type)"),
-            role: z50.string().describe("Role category (e.g. researcher, writer, coder, reviewer)"),
-            description: z50.string().describe("What this teammate will focus on - specific instructions for their work")
+        teammates: z51.array(
+          z51.object({
+            name: z51.string().describe("Teammate name (must match a pre-configured teammate type)"),
+            role: z51.string().describe("Role category (e.g. researcher, writer, coder, reviewer)"),
+            description: z51.string().describe("What this teammate will focus on - specific instructions for their work")
           })
         ).describe("Teammate agents to create. Each should have a clear role and focus.")
       })
@@ -13381,7 +13581,7 @@ After calling create_team, you MUST:
     if (state?.team?.teamId) return state.team.teamId;
     throw new Error("No team_id provided and no team in state. Call create_team first.");
   };
-  const addTasksTool = tool49(
+  const addTasksTool = tool50(
     async (input, config) => {
       const teamId = resolveTeamId();
       const created = await taskListStore.addTasks(
@@ -13395,7 +13595,7 @@ After calling create_team, you MUST:
         }))
       );
       const summary = created.map((t) => `- ${t.id}: "${t.title}"`).join("\n");
-      return new ToolMessage7({
+      return new ToolMessage8({
         content: `Added ${created.length} task(s) to team ${teamId}:
 ${summary}
 Sleeping teammates will wake up and claim these.`,
@@ -13433,33 +13633,33 @@ IMPORTANT: Dependencies
 
 IMPORTANT: Assigning to a specific teammate
 - When you need a particular teammate to do the work, set assignee to that teammate's name (e.g. assignee: "researcher"). They can then claim or see the task as assigned to them.`,
-      schema: z50.object({
-        tasks: z50.array(
-          z50.object({
-            id: z50.string().describe("Task ID in format task-01, task-02, etc. Must be unique."),
-            title: z50.string().describe("Short task title"),
-            description: z50.string().describe("Detailed task description - what needs to be done"),
-            assignee: z50.string().optional().describe("Teammate name to assign this task to (use when you need that person to do the work)"),
-            dependencies: z50.array(z50.string()).optional().default([]).describe("Array of task IDs that must complete before this task")
+      schema: z51.object({
+        tasks: z51.array(
+          z51.object({
+            id: z51.string().describe("Task ID in format task-01, task-02, etc. Must be unique."),
+            title: z51.string().describe("Short task title"),
+            description: z51.string().describe("Detailed task description - what needs to be done"),
+            assignee: z51.string().optional().describe("Teammate name to assign this task to (use when you need that person to do the work)"),
+            dependencies: z51.array(z51.string()).optional().default([]).describe("Array of task IDs that must complete before this task")
           })
         ).describe("New tasks to add to the team")
       })
     }
   );
-  const assignTaskTool = tool49(
+  const assignTaskTool = tool50(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
         assignee: input.assignee
       });
       if (!task) {
-        return new ToolMessage7({
+        return new ToolMessage8({
           content: `Task ${input.task_id} not found in team ${teamId}.`,
           tool_call_id: config.toolCall?.id,
           name: "assign_task"
         });
       }
-      return new ToolMessage7({
+      return new ToolMessage8({
         content: `Task "${task.title}" (${task.id}) assigned to ${input.assignee}.`,
         tool_call_id: config.toolCall?.id,
         name: "assign_task"
@@ -13468,26 +13668,26 @@ IMPORTANT: Assigning to a specific teammate
     {
       name: "assign_task",
       description: "Assign a task to a specific teammate. Use when you need to reassign work to a different teammate. Omit team_id to use the active team from state.",
-      schema: z50.object({
-        task_id: z50.string().describe("Task ID to assign"),
-        assignee: z50.string().describe("Teammate name to assign this task to")
+      schema: z51.object({
+        task_id: z51.string().describe("Task ID to assign"),
+        assignee: z51.string().describe("Teammate name to assign this task to")
       })
     }
   );
-  const setTaskStatusTool = tool49(
+  const setTaskStatusTool = tool50(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
         status: input.status
       });
       if (!task) {
-        return new ToolMessage7({
+        return new ToolMessage8({
           content: `Task ${input.task_id} not found in team ${teamId}.`,
           tool_call_id: config.toolCall?.id,
           name: "set_task_status"
         });
       }
-      return new ToolMessage7({
+      return new ToolMessage8({
         content: `Task "${task.title}" (${task.id}) status set to ${input.status}.`,
         tool_call_id: config.toolCall?.id,
         name: "set_task_status"
@@ -13496,26 +13696,26 @@ IMPORTANT: Assigning to a specific teammate
     {
       name: "set_task_status",
       description: "Set a task's status. Use to reopen a task (set to pending), mark as failed, or correct status. Values: pending, claimed, in_progress, completed, failed. Omit team_id to use the active team from state.",
-      schema: z50.object({
-        task_id: z50.string().describe("Task ID to update"),
-        status: z50.enum(["pending", "claimed", "in_progress", "completed", "failed"]).describe("New status for the task")
+      schema: z51.object({
+        task_id: z51.string().describe("Task ID to update"),
+        status: z51.enum(["pending", "claimed", "in_progress", "completed", "failed"]).describe("New status for the task")
       })
     }
   );
-  const setTaskDependenciesTool = tool49(
+  const setTaskDependenciesTool = tool50(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
         dependencies: input.dependencies
       });
       if (!task) {
-        return new ToolMessage7({
+        return new ToolMessage8({
           content: `Task ${input.task_id} not found in team ${teamId}.`,
           tool_call_id: config.toolCall?.id,
           name: "set_task_dependencies"
         });
       }
-      return new ToolMessage7({
+      return new ToolMessage8({
         content: `Task "${task.title}" (${task.id}) dependencies set to [${input.dependencies.join(", ")}].`,
         tool_call_id: config.toolCall?.id,
         name: "set_task_dependencies"
@@ -13524,13 +13724,13 @@ IMPORTANT: Assigning to a specific teammate
     {
       name: "set_task_dependencies",
       description: 'Set which task IDs must complete before this task can be claimed. Pass an array of task IDs (e.g. ["task-01", "task-02"]). Use to fix task order or add/remove dependencies. Omit team_id to use the active team from state.',
-      schema: z50.object({
-        task_id: z50.string().describe("Task ID to update"),
-        dependencies: z50.array(z50.string()).describe("Task IDs that must complete before this task can be claimed")
+      schema: z51.object({
+        task_id: z51.string().describe("Task ID to update"),
+        dependencies: z51.array(z51.string()).describe("Task IDs that must complete before this task can be claimed")
       })
     }
   );
-  const checkTasksTool = tool49(
+  const checkTasksTool = tool50(
     async (input, config) => {
       const teamId = resolveTeamId();
       const tasks = await taskListStore.getAllTasks(teamId);
@@ -13539,7 +13739,7 @@ IMPORTANT: Assigning to a specific teammate
         update: {
           tasks: tasksSnapshot,
           messages: [
-            new ToolMessage7({
+            new ToolMessage8({
               content: formatTaskSummary(tasks),
               tool_call_id: config.toolCall?.id,
               name: "check_tasks"
@@ -13570,12 +13770,12 @@ Task Status Values:
 - in_progress: Teammate is actively working on this task
 - completed: Task finished successfully
 - failed: Task encountered an error`,
-      schema: z50.object({
-        team_id: z50.string().optional().describe("Team ID (omit to use active team)")
+      schema: z51.object({
+        team_id: z51.string().optional().describe("Team ID (omit to use active team)")
       })
     }
   );
-  const sendMessageTool = tool49(
+  const sendMessageTool = tool50(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.sendMessage(
@@ -13585,7 +13785,7 @@ Task Status Values:
         input.content,
         "direct_message" /* DIRECT_MESSAGE */
       );
-      return new ToolMessage7({
+      return new ToolMessage8({
         content: `Message sent to ${input.to}.`,
         tool_call_id: config.toolCall?.id,
         name: "send_message"
@@ -13594,13 +13794,13 @@ Task Status Values:
     {
       name: "send_message",
       description: "Send a message to a specific teammate in the team. Omit team_id to use the active team from state.",
-      schema: z50.object({
-        to: z50.string().describe("Recipient teammate name"),
-        content: z50.string().describe("Message content")
+      schema: z51.object({
+        to: z51.string().describe("Recipient teammate name"),
+        content: z51.string().describe("Message content")
       })
     }
   );
-  const readMessagesTool = tool49(
+  const readMessagesTool = tool50(
     async (input, config) => {
       const teamId = resolveTeamId();
       const formatAndMarkAsRead = async (msgs2) => {
@@ -13628,7 +13828,7 @@ Task Status Values:
       if (msgs.length > 0) {
         const formatted2 = await formatAndMarkAsRead(msgs);
         const allTeamMessages2 = await getAllTeamMessagesForState();
-        const toolMessage2 = new ToolMessage7({
+        const toolMessage2 = new ToolMessage8({
           content: formatted2,
           tool_call_id: config.toolCall?.id,
           name: "read_messages"
@@ -13660,7 +13860,7 @@ Task Status Values:
       );
       const allTeamMessages = await getAllTeamMessagesForState();
       if (msgs.length === 0) {
-        const toolMessage2 = new ToolMessage7({
+        const toolMessage2 = new ToolMessage8({
           content: "No unread messages from teammates.",
           tool_call_id: config.toolCall?.id,
           name: "read_messages"
@@ -13670,7 +13870,7 @@ Task Status Values:
         });
       }
       const formatted = await formatAndMarkAsRead(msgs);
-      const toolMessage = new ToolMessage7({
+      const toolMessage = new ToolMessage8({
         content: formatted,
         tool_call_id: config.toolCall?.id,
         name: "read_messages"
@@ -13682,12 +13882,12 @@ Task Status Values:
     {
       name: "read_messages",
       description: "Read unread messages from teammates. Returns immediately if messages exist, otherwise waits for up to 3 minutes for new messages.",
-      schema: z50.object({
-        team_id: z50.string().optional().describe("Team ID (omit to use active team)")
+      schema: z51.object({
+        team_id: z51.string().optional().describe("Team ID (omit to use active team)")
       })
     }
   );
-  const disbandTeamTool = tool49(
+  const disbandTeamTool = tool50(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.broadcastMessage(
@@ -13697,7 +13897,7 @@ Task Status Values:
         "shutdown_request" /* SHUTDOWN_REQUEST */
       );
       await new Promise((r) => setTimeout(r, 2e3));
-      return new ToolMessage7({
+      return new ToolMessage8({
         content: `Team ${teamId} has been disbanded. All teammates notified and resources cleaned up.`,
         tool_call_id: config.toolCall?.id,
         name: "disband_team"
@@ -13708,7 +13908,7 @@ Task Status Values:
       description: "Disband a team when all work is done. Before calling: (1) Call check_tasks to verify no tasks are still pending/in_progress; (2) if any are, discuss with the team via read_messages and broadcast_message/send_message whether to continue or stop/cancel them; (3) only after alignment (all tasks completed/failed or explicitly stopped), then call this tool. This will: 1) Send a shutdown message to all teammates, 2) Wait briefly for them to clean up, 3) Clear all tasks and messages. Omit team_id to use the active team from state."
     }
   );
-  const broadcastMessageTool = tool49(
+  const broadcastMessageTool = tool50(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.broadcastMessage(
@@ -13717,7 +13917,7 @@ Task Status Values:
         input.content,
         "broadcast" /* BROADCAST */
       );
-      return new ToolMessage7({
+      return new ToolMessage8({
         content: `Broadcast message sent to all teammates.`,
         tool_call_id: config.toolCall?.id,
         name: "broadcast_message"
@@ -13726,12 +13926,12 @@ Task Status Values:
     {
       name: "broadcast_message",
       description: "Send a message to all teammates at once. Use this to communicate with everyone in the team. Omit team_id to use the active team from state.",
-      schema: z50.object({
-        content: z50.string().describe("Message content to broadcast to all teammates")
+      schema: z51.object({
+        content: z51.string().describe("Message content to broadcast to all teammates")
       })
     }
   );
-  return createMiddleware14({
+  return createMiddleware16({
     name: "teamMiddleware",
     tools: [
       createTeamTool,
@@ -13759,37 +13959,37 @@ ${TEAM_SYSTEM_PROMPT}` : TEAM_SYSTEM_PROMPT;
 }
 
 // src/agent_team/agent_team.ts
-var TeammateInfoSchema = z51.object({
-  name: z51.string().describe("Teammate name"),
-  role: z51.string().describe("Role category (e.g. research, writing, review)"),
-  description: z51.string().describe("What this teammate focuses on")
+var TeammateInfoSchema = z52.object({
+  name: z52.string().describe("Teammate name"),
+  role: z52.string().describe("Role category (e.g. research, writing, review)"),
+  description: z52.string().describe("What this teammate focuses on")
 });
-var TeamTaskInfoSchema = z51.object({
-  id: z51.string(),
-  title: z51.string(),
-  description: z51.string(),
-  status: z51.string().optional()
+var TeamTaskInfoSchema = z52.object({
+  id: z52.string(),
+  title: z52.string(),
+  description: z52.string(),
+  status: z52.string().optional()
 });
-var MailboxMessageSchema = z51.object({
-  id: z51.string().describe("Unique message identifier"),
-  from: z51.string().describe("Sender agent name"),
-  to: z51.string().describe("Recipient agent name"),
-  content: z51.string().describe("Message content"),
-  timestamp: z51.string().describe("ISO timestamp when the message was sent"),
-  type: z51.nativeEnum(MessageType).describe("Message type"),
-  read: z51.boolean().describe("Whether the recipient has read this message")
+var MailboxMessageSchema = z52.object({
+  id: z52.string().describe("Unique message identifier"),
+  from: z52.string().describe("Sender agent name"),
+  to: z52.string().describe("Recipient agent name"),
+  content: z52.string().describe("Message content"),
+  timestamp: z52.string().describe("ISO timestamp when the message was sent"),
+  type: z52.nativeEnum(MessageType).describe("Message type"),
+  read: z52.boolean().describe("Whether the recipient has read this message")
 });
-var TeamInfoSchema = z51.object({
-  teamId: z51.string().describe("Unique team identifier"),
-  teamLeadId: z51.string().default("team_lead").describe("Team lead agent ID"),
-  teammates: z51.array(TeammateInfoSchema).describe("Active teammates in this team"),
-  tasks: z51.array(TeamTaskInfoSchema).optional().describe("Initial tasks snapshot"),
-  createdAt: z51.string().optional().describe("ISO timestamp when team was created")
+var TeamInfoSchema = z52.object({
+  teamId: z52.string().describe("Unique team identifier"),
+  teamLeadId: z52.string().default("team_lead").describe("Team lead agent ID"),
+  teammates: z52.array(TeammateInfoSchema).describe("Active teammates in this team"),
+  tasks: z52.array(TeamTaskInfoSchema).optional().describe("Initial tasks snapshot"),
+  createdAt: z52.string().optional().describe("ISO timestamp when team was created")
 });
-var TEAM_STATE_SCHEMA = z51.object({
+var TEAM_STATE_SCHEMA = z52.object({
   team: TeamInfoSchema.optional().describe("Team info: teamId, teamLeadId, teammates, tasks. Set when create_team succeeds."),
-  tasks: z51.array(TeamTaskInfoSchema).optional().describe("Current tasks snapshot from check_tasks. Updated on each check."),
-  team_mailbox: z51.array(MailboxMessageSchema).optional().describe("All team mailbox messages for display")
+  tasks: z52.array(TeamTaskInfoSchema).optional().describe("Current tasks snapshot from check_tasks. Updated on each check."),
+  team_mailbox: z52.array(MailboxMessageSchema).optional().describe("All team mailbox messages for display")
 });
 var TEAM_LEAD_BASE_PROMPT = `You are a team lead that coordinates a team of specialized agents. In order to complete the objective that the user asks of you, you will need to:
 
@@ -13870,7 +14070,7 @@ var TeamAgentGraphBuilder = class {
     const tools = params.tools.map((t) => {
       const toolClient = getToolClient(t.key);
       return toolClient;
-    }).filter((tool50) => tool50 !== void 0);
+    }).filter((tool51) => tool51 !== void 0);
     const teammates = params.subAgents.map((sa) => {
       const baseConfig = sa.config;
       return {
@@ -14603,6 +14803,9 @@ var InMemoryChunkBuffer = class extends ChunkBuffer {
     buffer2.expiresAt = Date.now() + this.config.ttl;
     buffer2.status = "active" /* ACTIVE */;
   }
+  async ensureThread(threadId) {
+    this.getOrCreateBuffer(threadId);
+  }
   async completeThread(threadId) {
     const buffer2 = this.getBufferIfValid(threadId);
     if (buffer2) {
@@ -16756,10 +16959,10 @@ var McpLatticeManager = class _McpLatticeManager extends BaseLatticeManager {
     }
     const tools = await this.getAllTools();
     console.log(`[MCP] Registering ${tools.length} tools to Tool Lattice...`);
-    for (const tool50 of tools) {
-      const toolKey = prefix ? `${prefix}_${tool50.name}` : tool50.name;
-      tool50.name = toolKey;
-      toolLatticeManager.registerExistingTool(toolKey, tool50);
+    for (const tool51 of tools) {
+      const toolKey = prefix ? `${prefix}_${tool51.name}` : tool51.name;
+      tool51.name = toolKey;
+      toolLatticeManager.registerExistingTool(toolKey, tool51);
       console.log(`[MCP] Registered tool: ${toolKey}`);
     }
     console.log(`[MCP] Successfully registered ${tools.length} tools to Tool Lattice`);
@@ -17366,6 +17569,7 @@ var Agent = class {
         id: messageId
       });
     }
+    await this.chunkBuffer.ensureThread(this.thread_id);
     this.startQueueProcessorIfNeeded().catch((err) => {
       console.error("Failed to start queue processor:", err);
     });
@@ -17499,12 +17703,16 @@ var Agent = class {
   /**
    * Abort the current agent execution
    * This will cancel any ongoing invoke or stream operations
+   * and clear all queued messages (pending + processing)
    */
-  abort() {
+  async abort() {
     if (this.abortController) {
       this.abortController.abort();
       this.abortController = null;
     }
+    await this.chunkBuffer.abortThread(this.thread_id);
+    const store = this.getQueueStore();
+    await store.clearMessages(this.thread_id);
   }
   /**
    * Check if the agent is currently being aborted
@@ -17812,6 +18020,7 @@ export {
   createQueryTablesListTool,
   createTeamMiddleware,
   createTeammateTools,
+  createUnknownToolHandlerMiddleware,
   createWidgetMiddleware,
   decrypt,
   describeCronExpression,