@axiom-lattice/core 2.1.46 → 2.1.47

package/dist/index.mjs

@@ -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}`);
     }
@@ -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")}
 
 `;
@@ -9959,14 +9712,18 @@ ${currentSystemPrompt}` : dateContext;
 }
 
 // src/agent_lattice/builders/commonMiddleware.ts
-async function createCommonMiddlewares(middlewareConfigs, filesystemBackend) {
+async function createCommonMiddlewares(middlewareConfigs, filesystemBackend, fsIsExised) {
   const middlewares = [];
   middlewares.push(createUnknownToolHandlerMiddleware());
   middlewares.push(createModelSelectorMiddleware());
   const filesystemConfig = middlewareConfigs.find((m) => m.type === "filesystem");
-  if (filesystemConfig?.enabled && filesystemBackend) {
-    const options = { backend: filesystemBackend };
-    middlewares.push(createFilesystemMiddleware(options));
+  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;
@@ -10014,12 +9771,14 @@ async function createCommonMiddlewares(middlewareConfigs, filesystemBackend) {
         break;
       case "claw":
         if (filesystemBackend) {
-          const clawConfig = config.config;
+          const clawMiddlewareConfig = config.config;
           middlewares.push(createClawMiddleware({
             backend: filesystemBackend,
-            injectBootstrapFiles: clawConfig.injectBootstrapFiles ?? true,
-            bootstrapFiles: clawConfig.bootstrapFiles ?? {}
+            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":
@@ -10027,45 +9786,516 @@ async function createCommonMiddlewares(middlewareConfigs, filesystemBackend) {
         break;
     }
   }
-  return middlewares;
-}
+  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/ReActAgentGraphBuilder.ts
-var ReActAgentGraphBuilder = class {
-  createFilesystemBackendFactory(middlewareConfigs, agentLattice) {
-    const filesystemConfig = middlewareConfigs.find((m) => m.type === "filesystem");
-    if (!filesystemConfig || !filesystemConfig.enabled) {
-      return void 0;
+// 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 || !filesystemConfig.enabled) {
+    return void 0;
+  }
+  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";
     }
-    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}`;
-        }
+    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 new SandboxFilesystem({
-        sandboxInstance: await sandboxManager.createSandbox(sandboxName),
-        workingDirectory
-      });
+      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 {
   async createMiddlewares(middlewareConfigs) {
     return await createCommonMiddlewares(middlewareConfigs);
   }
@@ -10083,7 +10313,7 @@ var ReActAgentGraphBuilder = class {
     }).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,
@@ -11731,186 +11961,6 @@ var FilesystemBackend = class {
   }
 };
 
-// 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/deep_agent_new/backends/memory.ts
 var MemoryBackend = class {
   constructor(files) {
@@ -12382,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
    *
@@ -12460,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,