@axiom-lattice/core 2.1.16 → 2.1.17

package/dist/index.mjs

@@ -503,6 +503,27 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
   getAllToolDefinitions() {
     return this.getAllLattices().map((lattice) => lattice.config);
   }
+  /**
+   * 注册已有的StructuredTool到Lattice
+   * @param key Lattice键名
+   * @param tool 已有的StructuredTool实例
+   */
+  registerExistingTool(key, tool7) {
+    const config = {
+      name: tool7.name,
+      description: tool7.description,
+      schema: tool7.schema,
+      // StructuredTool的schema已经是Zod兼容的
+      needUserApprove: false
+      // MCP工具默认不需要用户批准
+    };
+    const toolLattice = {
+      key,
+      config,
+      client: tool7
+    };
+    this.register(key, toolLattice);
+  }
   /**
    * 验证工具输入参数
    * @param key Lattice键名
@@ -525,6 +546,7 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
 };
 var toolLatticeManager = ToolLatticeManager.getInstance();
 var registerToolLattice = (key, config, executor) => toolLatticeManager.registerLattice(key, config, executor);
+var registerExistingTool = (key, tool7) => toolLatticeManager.registerExistingTool(key, tool7);
 var getToolLattice = (key) => toolLatticeManager.getToolLattice(key);
 var getToolDefinition = (key) => toolLatticeManager.getToolDefinition(key);
 var getToolClient = (key) => toolLatticeManager.getToolClient(key);
@@ -1906,88 +1928,1333 @@ storeLatticeManager.registerLattice(
   "assistant",
   defaultAssistantStore
 );
-storeLatticeManager.registerLattice("default", "skill", defaultSkillStore);
+storeLatticeManager.registerLattice("default", "skill", defaultSkillStore);
+
+// src/tool_lattice/load_skills/index.ts
+var LOAD_SKILLS_DESCRIPTION = `Load all available skills and return their metadata (name, description, license, compatibility, metadata, and subSkills) without the content. This tool returns skill information including hierarchical relationships (subSkills). Use this to discover what skills are available and their structure. Skills can have sub-skills, creating a tree structure for organizing capabilities.`;
+registerToolLattice(
+  "load_skills",
+  {
+    name: "load_skills",
+    description: LOAD_SKILLS_DESCRIPTION,
+    needUserApprove: false,
+    schema: z7.object({})
+  },
+  async () => {
+    try {
+      const storeLattice = getStoreLattice("default", "skill");
+      const skillStore = storeLattice.store;
+      const skills = await skillStore.getAllSkills();
+      const skillsMeta = skills.map((skill) => ({
+        name: skill.name,
+        description: skill.description,
+        license: skill.license,
+        compatibility: skill.compatibility,
+        metadata: skill.metadata,
+        subSkills: skill.subSkills
+      }));
+      return JSON.stringify(skillsMeta, null, 2);
+    } catch (error) {
+      return `Error loading skills: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  }
+);
+
+// src/tool_lattice/load_skill_content/index.ts
+import z8 from "zod";
+var LOAD_SKILL_CONTENT_DESCRIPTION = `Load a specific skill's content by name and return its full content including markdown body. This tool returns the complete skill content including frontmatter and markdown body. If the skill has sub-skills defined, they will be listed in the frontmatter. Use this tool to get the complete skill content for a skill that you want to use.`;
+registerToolLattice(
+  "load_skill_content",
+  {
+    name: "load_skill_content",
+    description: LOAD_SKILL_CONTENT_DESCRIPTION,
+    needUserApprove: false,
+    schema: z8.object({
+      skill_name: z8.string().describe("The name of the skill to load")
+    })
+  },
+  async (input) => {
+    try {
+      const storeLattice = getStoreLattice("default", "skill");
+      const skillStore = storeLattice.store;
+      const skill = await skillStore.getSkillById(input.skill_name);
+      if (!skill) {
+        const allSkills = await skillStore.getAllSkills();
+        const availableSkills = allSkills.map((s) => s.name).join(", ");
+        return `Skill "${input.skill_name}" not found. Available skills: ${availableSkills}`;
+      }
+      const frontmatter = ["---"];
+      frontmatter.push(`name: ${skill.name}`);
+      frontmatter.push(`description: ${skill.description}`);
+      if (skill.license) {
+        frontmatter.push(`license: ${skill.license}`);
+      }
+      if (skill.compatibility) {
+        frontmatter.push(`compatibility: ${skill.compatibility}`);
+      }
+      if (skill.metadata && Object.keys(skill.metadata).length > 0) {
+        frontmatter.push("metadata:");
+        for (const [key, value] of Object.entries(skill.metadata)) {
+          frontmatter.push(`  ${key}: ${value}`);
+        }
+      }
+      if (skill.subSkills && skill.subSkills.length > 0) {
+        frontmatter.push("subSkills:");
+        for (const subSkill of skill.subSkills) {
+          frontmatter.push(`  - ${subSkill}`);
+        }
+      }
+      frontmatter.push("---");
+      const content = skill.content || "";
+      return `${frontmatter.join("\n")}
+${content}`;
+    } catch (error) {
+      return `Error loading skill content: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  }
+);
+
+// src/tool_lattice/code_eval/index.ts
+import z9 from "zod";
+
+// src/sandbox_lattice/SandboxLatticeManager.ts
+import { SandboxClient } from "@agent-infra/sandbox";
+
+// src/sandbox_lattice/utils.ts
+function normalizeSandboxName(name) {
+  if (!name || typeof name !== "string") {
+    throw new Error("Sandbox name must be a non-empty string");
+  }
+  let normalized = name.toLowerCase();
+  normalized = normalized.replace(/_/g, "-");
+  normalized = normalized.replace(/[^a-z0-9.-]/g, "");
+  normalized = normalized.replace(/^[.-]+|[.-]+$/g, "");
+  normalized = normalized.replace(/[.-]{2,}/g, "-");
+  normalized = normalized.replace(/^[.-]+|[.-]+$/g, "");
+  if (!normalized) {
+    throw new Error(
+      `Sandbox name "${name}" cannot be normalized to a valid RFC 1123 subdomain name`
+    );
+  }
+  if (!/^[a-z0-9]/.test(normalized)) {
+    normalized = `sandbox-${normalized}`;
+  }
+  if (!/[a-z0-9]$/.test(normalized)) {
+    normalized = `${normalized}-0`;
+  }
+  const rfc1123Pattern = /^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$/;
+  if (!rfc1123Pattern.test(normalized)) {
+    normalized = normalized.replace(/[^a-z0-9-]/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
+    if (!/^[a-z0-9]/.test(normalized)) {
+      normalized = `sandbox-${normalized}`;
+    }
+    if (!/[a-z0-9]$/.test(normalized)) {
+      normalized = `${normalized}0`;
+    }
+  }
+  return normalized;
+}
+function isValidSandboxName(name) {
+  if (!name || typeof name !== "string") {
+    return false;
+  }
+  const rfc1123Pattern = /^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$/;
+  return rfc1123Pattern.test(name.toLowerCase());
+}
+
+// src/sandbox_lattice/SandboxLatticeManager.ts
+var DefaultSandboxManager = class {
+  constructor(baseURL = "http://localhost:8080") {
+    this.sandboxes = /* @__PURE__ */ new Map();
+    /**
+     * Track in-flight sandbox creation promises by normalized sandbox name.
+     * This ensures that concurrent calls with the same name share the same Promise
+     * and we do not trigger multiple creations for the same sandbox.
+     */
+    this.creatingSandboxes = /* @__PURE__ */ new Map();
+    this.baseURL = baseURL;
+  }
+  async createSandbox(sandboxName) {
+    if (sandboxName === "global") {
+      const client = new SandboxClient({ baseUrl: `${this.baseURL}/sandbox/global`, environment: "" });
+      this.sandboxes.set("global", client);
+      return client;
+    }
+    const normalizedName = normalizeSandboxName(sandboxName);
+    const existingClient = this.sandboxes.get(normalizedName);
+    if (existingClient) {
+      return existingClient;
+    }
+    const inFlight = this.creatingSandboxes.get(normalizedName);
+    if (inFlight) {
+      return inFlight;
+    }
+    const creationPromise = (async () => {
+      const response = await fetch(`${this.baseURL}/api/v1/sandbox`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          name: normalizedName,
+          image: "enterprise-public-cn-beijing.cr.volces.com/vefaas-public/all-in-one-sandbox:latest"
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to create sandbox: ${response.statusText}`);
+      }
+      const data = await response.json();
+      const sandboxURL = `${this.baseURL}/sandbox/${normalizedName}`;
+      const client = new SandboxClient({ baseUrl: sandboxURL, environment: "" });
+      this.sandboxes.set(normalizedName, client);
+      return client;
+    })();
+    this.creatingSandboxes.set(normalizedName, creationPromise);
+    creationPromise.catch(() => {
+      this.creatingSandboxes.delete(normalizedName);
+    }).then(() => {
+      this.creatingSandboxes.delete(normalizedName);
+    });
+    return creationPromise;
+  }
+  async deleteSandbox(sandboxName) {
+    const normalizedName = normalizeSandboxName(sandboxName);
+    if (!this.sandboxes.has(normalizedName)) {
+      throw new Error(`Sandbox ${sandboxName} (normalized: ${normalizedName}) not found`);
+    }
+    const response = await fetch(`${this.baseURL}/api/v1/sandbox/${normalizedName}`, {
+      method: "DELETE"
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to delete sandbox: ${response.statusText}`);
+    }
+    this.sandboxes.delete(normalizedName);
+  }
+  async getSandbox(sandboxName) {
+    const normalizedName = normalizeSandboxName(sandboxName);
+    const client = this.sandboxes.get(normalizedName);
+    if (!client) {
+      throw new Error(`Sandbox ${sandboxName} (normalized: ${normalizedName}) not found`);
+    }
+    return client;
+  }
+  async listSandboxes() {
+    return Array.from(this.sandboxes.values());
+  }
+  async getSandboxStatus(sandboxName) {
+    const normalizedName = normalizeSandboxName(sandboxName);
+    if (!this.sandboxes.has(normalizedName)) {
+      throw new Error(`Sandbox ${sandboxName} (normalized: ${normalizedName}) not found`);
+    }
+    try {
+      const client = this.sandboxes.get(normalizedName);
+      const context = await client.sandbox.getContext();
+      return context.ok ? "active" : "inactive";
+    } catch {
+      return "unknown";
+    }
+  }
+  async getSandboxFromConfig(config) {
+    if (config.sandboxConfig.isolatedLevel === "agent") {
+      return this.createSandbox(config.assistant_id);
+    } else if (config.sandboxConfig.isolatedLevel === "thread") {
+      return this.createSandbox(config.thread_id);
+    } else {
+      return this.createSandbox("global");
+    }
+  }
+};
+var SandboxLatticeManager = class _SandboxLatticeManager extends BaseLatticeManager {
+  /**
+   * Get SandboxLatticeManager singleton instance
+   */
+  static getInstance() {
+    if (!_SandboxLatticeManager._instance) {
+      _SandboxLatticeManager._instance = new _SandboxLatticeManager();
+    }
+    return _SandboxLatticeManager._instance;
+  }
+  /**
+   * Get Lattice type prefix
+   */
+  getLatticeType() {
+    return "sandbox_manager";
+  }
+  /**
+   * Register sandbox Lattice
+   * @param key Lattice key name
+   * @param manager Optional sandbox manager. If not provided, will create a default one.
+   * @param baseURL Base URL for sandbox service (used when creating default manager)
+   */
+  registerLattice(key, config) {
+    const { manager, baseURL } = config;
+    const sandboxManager = manager || new DefaultSandboxManager(baseURL);
+    this.register(key, sandboxManager);
+  }
+  /**
+   * Get SandboxLattice
+   * @param key Lattice key name
+   */
+  getSandboxLattice(key) {
+    const sandboxLattice = this.get(key);
+    if (!sandboxLattice) {
+      throw new Error(`SandboxLattice ${key} not found`);
+    }
+    return sandboxLattice;
+  }
+  /**
+   * Get all Lattices
+   */
+  getAllLattices() {
+    return this.getAll();
+  }
+  /**
+   * Check if Lattice exists
+   * @param key Lattice key name
+   */
+  hasLattice(key) {
+    return this.has(key);
+  }
+  /**
+   * Remove Lattice
+   * @param key Lattice key name
+   */
+  removeLattice(key) {
+    return this.remove(key);
+  }
+  /**
+   * Clear all Lattices
+   */
+  clearLattices() {
+    this.clear();
+  }
+  /**
+   * Get Lattice count
+   */
+  getLatticeCount() {
+    return this.count();
+  }
+  /**
+   * Get Lattice key list
+   */
+  getLatticeKeys() {
+    return this.keys();
+  }
+};
+var sandboxLatticeManager = SandboxLatticeManager.getInstance();
+var getSandBoxManager = (key = "default") => {
+  if (!sandboxLatticeManager.hasLattice(key)) {
+    throw new Error(`Sandbox ${key} not configured. Ensure the sandbox manager is registered and the agent is built with connectedSandbox.`);
+  }
+  const sandboxManager = sandboxLatticeManager.getSandboxLattice(key);
+  return sandboxManager;
+};
+
+// src/tool_lattice/code_eval/index.ts
+var CODE_EVAL_DESCRIPTION = `Execute code in Python or JavaScript runtime.
+
+Args:
+    code: Code to execute
+    language: Programming language ('python', 'javascript')
+
+Returns:
+    Dict containing output, errors, and execution details`;
+registerToolLattice(
+  "execute_code",
+  {
+    name: "execute_code",
+    description: CODE_EVAL_DESCRIPTION,
+    needUserApprove: false,
+    schema: z9.object({
+      language: z9.enum(["python", "javascript"]).describe("Programming language: 'python' or 'javascript'"),
+      code: z9.string().describe("Code to execute")
+    })
+  },
+  async (input, exe_config) => {
+    try {
+      const runConfig = exe_config.configurable?.runConfig;
+      const sandboxManager = getSandBoxManager();
+      const sandbox = await sandboxManager.getSandboxFromConfig(runConfig);
+      const result = await sandbox.code.executeCode({
+        language: input.language,
+        code: input.code,
+        timeout: 300
+      });
+      if (!result.ok) {
+        const err = result.error;
+        return `Error executing ${input.language} code: ${err?.content?.message + (err?.content?.errors ? `
+${err?.content?.errors.join("\n")}` : "")}`;
+      }
+      const data = result.body?.data;
+      if (!data) {
+        return "Error: No response data from sandbox code execution.";
+      }
+      const { stdout = "", stderr = "", exit_code, traceback } = data;
+      const parts = [];
+      if (stdout) {
+        parts.push(`stdout:
+${stdout}`);
+      }
+      if (stderr) {
+        parts.push(`stderr:
+${stderr}`);
+      }
+      if (traceback && traceback.length > 0) {
+        parts.push(`traceback:
+${traceback.join("\n")}`);
+      }
+      parts.push(`exit_code: ${exit_code ?? "\u2014"}`);
+      return parts.length > 0 ? parts.join("\n\n") : `exit_code: ${exit_code ?? 0}`;
+    } catch (e) {
+      return `Error: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+);
+
+// src/tool_lattice/code_execute_file/index.ts
+import z10 from "zod";
+import * as path2 from "path";
+var CODE_EXECUTE_FILE_DESCRIPTION = `Execute a code file from the sandbox filesystem. Only supports Python (.py) and JavaScript (.js, .mjs) files. Other file types are not supported. The tool reads the file content and executes it in an isolated sandbox environment. Language is automatically inferred from the file extension. Output is returned via stdout; errors appear in stderr and traceback.`;
+function inferLanguageFromPath(filePath) {
+  const ext = path2.extname(filePath).toLowerCase();
+  if (ext === ".py") {
+    return "python";
+  } else if (ext === ".js" || ext === ".mjs") {
+    return "javascript";
+  }
+  return null;
+}
+registerToolLattice(
+  "execute_code_file",
+  {
+    name: "execute_code_file",
+    description: CODE_EXECUTE_FILE_DESCRIPTION,
+    needUserApprove: false,
+    schema: z10.object({
+      file_path: z10.string().describe("Path to the code file to execute (absolute path in sandbox filesystem). Only supports .py (Python) and .js/.mjs (JavaScript) files.")
+    })
+  },
+  async (input, exe_config) => {
+    try {
+      const runConfig = exe_config.configurable?.runConfig;
+      const sandboxManager = getSandBoxManager();
+      const sandbox = await sandboxManager.getSandboxFromConfig(runConfig);
+      const context = await sandbox.sandbox.getContext();
+      if (!context.ok) {
+        return `Error: ${context.error}`;
+      }
+      const homeDir = context.body?.home_dir;
+      const resolvedFilePath = path2.join(homeDir, input.file_path);
+      const language = inferLanguageFromPath(input.file_path);
+      if (!language) {
+        return `Error: Unsupported file type. This tool only supports Python (.py) and JavaScript (.js, .mjs) files. Other file types cannot be executed.`;
+      }
+      const readResult = await sandbox.file.readFile({
+        file: resolvedFilePath
+      });
+      if (!readResult.ok) {
+        const err = readResult.error;
+        return `Error reading file '${input.file_path}': ${err?.content?.message ?? JSON.stringify(readResult.error)}`;
+      }
+      const fileContent = readResult.body?.data?.content;
+      if (fileContent === void 0 || fileContent === null) {
+        return `Error: File '${input.file_path}' is empty or could not be read.`;
+      }
+      const result = await sandbox.code.executeCode({
+        language,
+        code: fileContent,
+        timeout: 300
+      });
+      if (!result.ok) {
+        const err = result.error;
+        return `Error executing ${language} file '${input.file_path}': ${err?.content?.message ?? JSON.stringify(result.error)}`;
+      }
+      const data = result.body?.data;
+      if (!data) {
+        return "Error: No response data from sandbox code execution.";
+      }
+      const { stdout = "", stderr = "", exit_code, traceback } = data;
+      const parts = [];
+      if (stdout) {
+        parts.push(`stdout:
+${stdout}`);
+      }
+      if (stderr) {
+        parts.push(`stderr:
+${stderr}`);
+      }
+      if (traceback && traceback.length > 0) {
+        parts.push(`traceback:
+${traceback.join("\n")}`);
+      }
+      parts.push(`exit_code: ${exit_code ?? "\u2014"}`);
+      return parts.length > 0 ? parts.join("\n\n") : `exit_code: ${exit_code ?? 0}`;
+    } catch (e) {
+      return `Error: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+);
+
+// src/tool_lattice/convert_to_markdown/index.ts
+import z11 from "zod";
+var CONVERT_TO_MARKDOWN_DESCRIPTION = `Convert a resource described by an http:, https:, file: or data: URI to markdown.
+
+Args:
+    uri (str): The URI to convert. Supported schemes:
+        - http:// or https://: Fetch content from URL
+        - file://: Read content from local file
+        - data:: Decode data URI content
+
+Returns:
+    str: The content converted to markdown format.`;
+registerToolLattice(
+  "convert_to_markdown",
+  {
+    name: "convert_to_markdown",
+    description: CONVERT_TO_MARKDOWN_DESCRIPTION,
+    needUserApprove: false,
+    schema: z11.object({
+      uri: z11.string().describe("The URI to convert.")
+    })
+  },
+  async (input, exe_config) => {
+    try {
+      const runConfig = exe_config.configurable?.runConfig;
+      const sandboxManager = getSandBoxManager();
+      const sandbox = await sandboxManager.getSandboxFromConfig(runConfig);
+      sandbox;
+      const result = await sandbox.util.convertToMarkdown({
+        uri: input.uri
+      });
+      if (!result.ok) {
+        return `Error converting to markdown: ${result.error}`;
+      }
+      return result.body.data;
+    } catch (e) {
+      return `Error converting to markdown: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+);
+
+// src/tool_lattice/browser/browser_navigate.ts
+import z12 from "zod";
+var BROWSER_NAVIGATE_DESCRIPTION = `Navigate to a URL.
+
+Args:
+    url (str): The URL to navigate to.
+
+`;
+registerToolLattice(
+  "browser_navigate",
+  {
+    name: "browser_navigate",
+    description: BROWSER_NAVIGATE_DESCRIPTION,
+    needUserApprove: false,
+    schema: z12.object({
+      url: z12.string().describe("The URL to navigate to.")
+    })
+  },
+  async (input, exe_config) => {
+    try {
+      const runConfig = exe_config.configurable?.runConfig;
+      const sandboxManager = getSandBoxManager();
+      const sandbox = await sandboxManager.getSandboxFromConfig(runConfig);
+      const result = await sandbox.mcp.executeMcpTool("browser", "browser_navigate", {
+        url: input.url
+      });
+      if (!result.ok) {
+        return `Error navigating to URL: ${JSON.stringify(result.error.content)}`;
+      }
+      return result.body?.data?.content?.map((item) => item.text).join("\n") ?? "Navigated to URL";
+    } catch (e) {
+      return `Error navigating to URL: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+);
+
+// src/tool_lattice/browser/get_info.ts
+var BROWSER_GET_INFO_DESCRIPTION = `Get information about browser, like CDP URL, viewport size, etc.
+
+Args:
+    request (Dict): The incoming request context.
+
+Returns:
+    Dict containing browser information including CDP URL, viewport dimensions, and other browser metadata.`;
+registerToolLattice(
+  "browser_get_info",
+  {
+    name: "browser_get_info",
+    description: BROWSER_GET_INFO_DESCRIPTION,
+    needUserApprove: false
+  },
+  async (input, exe_config) => {
+    try {
+      const runConfig = exe_config.configurable?.runConfig;
+      const sandboxManager = getSandBoxManager();
+      const sandbox = await sandboxManager.getSandboxFromConfig(runConfig);
+      const result = await sandbox.browser.getInfo();
+      if (!result.ok) {
+        return `Error getting browser info: ${result.error}`;
+      }
+      return JSON.stringify(result.body.data, void 0, 2);
+    } catch (e) {
+      return `Error getting browser info: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+);
+
+// src/tool_lattice/browser/browser_go_back.ts
+import z13 from "zod";
+var BROWSER_GO_BACK_DESCRIPTION = `Go back to the previous page.
+
+Args:
+    None
+
+`;
+registerToolLattice(
+  "browser_go_back",
+  {
+    name: "browser_go_back",
+    description: BROWSER_GO_BACK_DESCRIPTION,
+    needUserApprove: false,
+    schema: z13.object({})
+  },
+  async (input, exe_config) => {
+    try {
+      const runConfig = exe_config.configurable?.runConfig;
+      const sandboxManager = getSandBoxManager();
+      const sandbox = await sandboxManager.getSandboxFromConfig(runConfig);
+      const result = await sandbox.mcp.executeMcpTool("browser", "browser_go_back", {});
+      if (!result.ok) {
+        return `Error going back: ${JSON.stringify(result.error.content)}`;
+      }
+      return result.body?.data?.content?.map((item) => item.text).join("\n") ?? "Went back to previous page";
+    } catch (e) {
+      return `Error going back: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+);
+
+// src/tool_lattice/browser/browser_go_forward.ts
+import z14 from "zod";
+var BROWSER_GO_FORWARD_DESCRIPTION = `Go forward to the next page.
+
+Args:
+    None
+
+`;
+registerToolLattice(
+  "browser_go_forward",
+  {
+    name: "browser_go_forward",
+    description: BROWSER_GO_FORWARD_DESCRIPTION,
+    needUserApprove: false,
+    schema: z14.object({})
+  },
+  async (input, exe_config) => {
+    try {
+      const runConfig = exe_config.configurable?.runConfig;
+      const sandboxManager = getSandBoxManager();
+      const sandbox = await sandboxManager.getSandboxFromConfig(runConfig);
+      const result = await sandbox.mcp.executeMcpTool("browser", "browser_go_forward", {});
+      if (!result.ok) {
+        return `Error going forward: ${JSON.stringify(result.error.content)}`;
+      }
+      return result.body?.data?.content?.map((item) => item.text).join("\n") ?? "Went forward to next page";
+    } catch (e) {
+      return `Error going forward: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+);
+
+// src/tool_lattice/browser/browser_form_input_fill.ts
+import z15 from "zod";
+var BROWSER_FORM_INPUT_FILL_DESCRIPTION = `Fill out an input field, before using the tool, Either 'index' or 'selector' must be provided.
+
+Args:
+    selector (str): CSS selector for input field, priority use index, if index is not provided, use selector
+    index (int): Index of the element to fill
+    value (str): Value to fill
+    clear (bool): Whether to clear existing text before filling
+
+`;
+registerToolLattice(
+  "browser_form_input_fill",
+  {
+    name: "browser_form_input_fill",
+    description: BROWSER_FORM_INPUT_FILL_DESCRIPTION,
+    needUserApprove: false,
+    schema: z15.object({
+      selector: z15.string().optional().describe("CSS selector for input field, priority use index, if index is not provided, use selector"),
+      index: z15.number().optional().describe("Index of the element to fill"),
+      value: z15.string().describe("Value to fill"),
+      clear: z15.boolean().default(false).describe("Whether to clear existing text before filling")
+    })
+  },
+  async (input, exe_config) => {
+    try {
+      const runConfig = exe_config.configurable?.runConfig;
+      const sandboxManager = getSandBoxManager();
+      const sandbox = await sandboxManager.getSandboxFromConfig(runConfig);
+      const result = await sandbox.mcp.executeMcpTool("browser", "browser_form_input_fill", {
+        selector: input.selector,
+        index: input.index,
+        value: input.value,
+        clear: input.clear
+      });
+      if (!result.ok) {
+        return `Error filling input field: ${JSON.stringify(result.error.content)}`;
+      }
+      return result.body?.data?.content?.map((item) => item.text).join("\n") ?? "Input field filled successfully";
+    } catch (e) {
+      return `Error filling input field: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+);
+
+// src/tool_lattice/browser/browser_get_markdown.ts
+import z16 from "zod";
+var BROWSER_GET_MARKDOWN_DESCRIPTION = `Get the markdown content of the current page.
+
+Args:
+    None
+
+`;
+registerToolLattice(
+  "browser_get_markdown",
+  {
+    name: "browser_get_markdown",
+    description: BROWSER_GET_MARKDOWN_DESCRIPTION,
+    needUserApprove: false,
+    schema: z16.object({})
+  },
+  async (input, exe_config) => {
+    try {
+      const runConfig = exe_config.configurable?.runConfig;
+      const sandboxManager = getSandBoxManager();
+      const sandbox = await sandboxManager.getSandboxFromConfig(runConfig);
+      const result = await sandbox.mcp.executeMcpTool("browser", "browser_get_markdown", {});
+      if (!result.ok) {
+        return `Error getting markdown content: ${JSON.stringify(result.error.content)}`;
+      }
+      return result.body?.data?.content?.map((item) => item.text).join("\n") ?? "Markdown content retrieved";
+    } catch (e) {
+      return `Error getting markdown content: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+);
+
+// src/tool_lattice/browser/browser_get_text.ts
+import z17 from "zod";
+var BROWSER_GET_TEXT_DESCRIPTION = `Get the text content of the current page.
+
+Args:
+    None
+
+`;
+registerToolLattice(
+  "browser_get_text",
+  {
+    name: "browser_get_text",
+    description: BROWSER_GET_TEXT_DESCRIPTION,
+    needUserApprove: false,
+    schema: z17.object({})
+  },
+  async (input, exe_config) => {
+    try {
+      const runConfig = exe_config.configurable?.runConfig;
+      const sandboxManager = getSandBoxManager();
+      const sandbox = await sandboxManager.getSandboxFromConfig(runConfig);
+      const result = await sandbox.mcp.executeMcpTool("browser", "browser_get_text", {});
+      if (!result.ok) {
+        return `Error getting text content: ${JSON.stringify(result.error.content)}`;
+      }
+      return result.body?.data?.content?.map((item) => item.text).join("\n") ?? "Text content retrieved";
+    } catch (e) {
+      return `Error getting text content: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+);
+
+// src/tool_lattice/browser/browser_read_links.ts
+import z18 from "zod";
+var BROWSER_READ_LINKS_DESCRIPTION = `Get all links on the current page.
+
+Args:
+    None
+
+`;
+registerToolLattice(
+  "browser_read_links",
+  {
+    name: "browser_read_links",
+    description: BROWSER_READ_LINKS_DESCRIPTION,
+    needUserApprove: false,
+    schema: z18.object({})
+  },
+  async (input, exe_config) => {
+    try {
+      const runConfig = exe_config.configurable?.runConfig;
+      const sandboxManager = getSandBoxManager();
+      const sandbox = await sandboxManager.getSandboxFromConfig(runConfig);
+      const result = await sandbox.mcp.executeMcpTool("browser", "browser_read_links", {});
+      if (!result.ok) {
+        return `Error reading links: ${JSON.stringify(result.error.content)}`;
+      }
+      return result.body?.data?.content?.map((item) => item.text).join("\n") ?? "Links retrieved successfully";
+    } catch (e) {
+      return `Error reading links: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+);
+
+// src/tool_lattice/browser/browser_new_tab.ts
+import z19 from "zod";
+var BROWSER_NEW_TAB_DESCRIPTION = `Open a new tab.
+
+Args:
+    url (str): URL to open in the new tab
+
+`;
+registerToolLattice(
+  "browser_new_tab",
+  {
+    name: "browser_new_tab",
+    description: BROWSER_NEW_TAB_DESCRIPTION,
+    needUserApprove: false,
+    schema: z19.object({
+      url: z19.string().describe("URL to open in the new tab")
+    })
+  },
+  async (input, exe_config) => {
+    try {
+      const runConfig = exe_config.configurable?.runConfig;
+      const sandboxManager = getSandBoxManager();
+      const sandbox = await sandboxManager.getSandboxFromConfig(runConfig);
+      const result = await sandbox.mcp.executeMcpTool("browser", "browser_new_tab", {
+        url: input.url
+      });
+      if (!result.ok) {
+        return `Error opening new tab: ${JSON.stringify(result.error.content)}`;
+      }
+      return result.body?.data?.content?.map((item) => item.text).join("\n") ?? "New tab opened successfully";
+    } catch (e) {
+      return `Error opening new tab: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+);
+
+// src/tool_lattice/browser/browser_tab_list.ts
+import z20 from "zod";
+var BROWSER_TAB_LIST_DESCRIPTION = `Get the list of tabs.
+
+Args:
+    None
+
+`;
+registerToolLattice(
+  "browser_tab_list",
+  {
+    name: "browser_tab_list",
+    description: BROWSER_TAB_LIST_DESCRIPTION,
+    needUserApprove: false,
+    schema: z20.object({})
+  },
+  async (input, exe_config) => {
+    try {
+      const runConfig = exe_config.configurable?.runConfig;
+      const sandboxManager = getSandBoxManager();
+      const sandbox = await sandboxManager.getSandboxFromConfig(runConfig);
+      const result = await sandbox.mcp.executeMcpTool("browser", "browser_tab_list", {});
+      if (!result.ok) {
+        return `Error getting tab list: ${JSON.stringify(result.error.content)}`;
+      }
+      return result.body?.data?.content?.map((item) => item.text).join("\n") ?? "Tab list retrieved successfully";
+    } catch (e) {
+      return `Error getting tab list: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+);
+
+// src/tool_lattice/browser/browser_switch_tab.ts
+import z21 from "zod";
+var BROWSER_SWITCH_TAB_DESCRIPTION = `Switch to a specific tab.
+
+Args:
+    index (int): Tab index to switch to
+
+`;
+registerToolLattice(
+  "browser_switch_tab",
+  {
+    name: "browser_switch_tab",
+    description: BROWSER_SWITCH_TAB_DESCRIPTION,
+    needUserApprove: false,
+    schema: z21.object({
+      index: z21.number().describe("Tab index to switch to")
+    })
+  },
+  async (input, exe_config) => {
+    try {
+      const runConfig = exe_config.configurable?.runConfig;
+      const sandboxManager = getSandBoxManager();
+      const sandbox = await sandboxManager.getSandboxFromConfig(runConfig);
+      const result = await sandbox.mcp.executeMcpTool("browser", "browser_switch_tab", {
+        index: input.index
+      });
+      if (!result.ok) {
+        return `Error switching tab: ${JSON.stringify(result.error.content)}`;
+      }
+      return result.body?.data?.content?.map((item) => item.text).join("\n") ?? "Tab switched successfully";
+    } catch (e) {
+      return `Error switching tab: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+);
+
+// src/tool_lattice/browser/browser_close_tab.ts
+import z22 from "zod";
+var BROWSER_CLOSE_TAB_DESCRIPTION = `Close the current tab.
+
+Args:
+    None
+
+`;
+registerToolLattice(
+  "browser_close_tab",
+  {
+    name: "browser_close_tab",
+    description: BROWSER_CLOSE_TAB_DESCRIPTION,
+    needUserApprove: false,
+    schema: z22.object({})
+  },
+  async (input, exe_config) => {
+    try {
+      const runConfig = exe_config.configurable?.runConfig;
+      const sandboxManager = getSandBoxManager();
+      const sandbox = await sandboxManager.getSandboxFromConfig(runConfig);
+      const result = await sandbox.mcp.executeMcpTool("browser", "browser_close_tab", {});
+      if (!result.ok) {
+        return `Error closing tab: ${JSON.stringify(result.error.content)}`;
+      }
+      return result.body?.data?.content?.map((item) => item.text).join("\n") ?? "Current tab closed successfully";
+    } catch (e) {
+      return `Error closing tab: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+);
+
+// src/tool_lattice/browser/browser_evaluate.ts
+import z23 from "zod";
+var BROWSER_EVALUATE_DESCRIPTION = `Execute JavaScript in the browser console.
+
+Args:
+    script (str): JavaScript code to execute, () => { /* code */ }
+
+`;
+registerToolLattice(
+  "browser_evaluate",
+  {
+    name: "browser_evaluate",
+    description: BROWSER_EVALUATE_DESCRIPTION,
+    needUserApprove: false,
+    schema: z23.object({
+      script: z23.string().describe("JavaScript code to execute, () => { /* code */ }")
+    })
+  },
+  async (input, exe_config) => {
+    try {
+      const runConfig = exe_config.configurable?.runConfig;
+      const sandboxManager = getSandBoxManager();
+      const sandbox = await sandboxManager.getSandboxFromConfig(runConfig);
+      const result = await sandbox.mcp.executeMcpTool("browser", "browser_evaluate", {
+        script: input.script
+      });
+      if (!result.ok) {
+        return `Error executing JavaScript: ${JSON.stringify(result.error.content)}`;
+      }
+      return result.body?.data?.content?.map((item) => item.text).join("\n") ?? "JavaScript executed successfully";
+    } catch (e) {
+      return `Error executing JavaScript: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+);
+
+// src/tool_lattice/browser/browser_get_download_list.ts
+import z24 from "zod";
+var BROWSER_GET_DOWNLOAD_LIST_DESCRIPTION = `Get the list of downloaded files.
+
+Args:
+    None
+
+`;
+registerToolLattice(
+  "browser_get_download_list",
+  {
+    name: "browser_get_download_list",
+    description: BROWSER_GET_DOWNLOAD_LIST_DESCRIPTION,
+    needUserApprove: false,
+    schema: z24.object({})
+  },
+  async (input, exe_config) => {
+    try {
+      const runConfig = exe_config.configurable?.runConfig;
+      const sandboxManager = getSandBoxManager();
+      const sandbox = await sandboxManager.getSandboxFromConfig(runConfig);
+      const result = await sandbox.mcp.executeMcpTool("browser", "browser_get_download_list", {});
+      if (!result.ok) {
+        return `Error getting download list: ${JSON.stringify(result.error.content)}`;
+      }
+      return result.body?.data?.content?.map((item) => item.text).join("\n") ?? "Download list retrieved successfully";
+    } catch (e) {
+      return `Error getting download list: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+);
+
+// src/tool_lattice/browser/browser_screenshot.ts
+import z25 from "zod";
+var BROWSER_SCREENSHOT_DESCRIPTION = `Take a screenshot of the current page or a specific element.
+
+Args:
+    name (str): Name for the screenshot
+    selector (str): CSS selector for element to screenshot
+    index (int): index of the element to screenshot
+    width (int): Width in pixels (default: viewport width)
+    height (int): Height in pixels (default: viewport height)
+    fullPage (bool): Full page screenshot (default: false)
+    highlight (bool): Highlight the element
+
+`;
+registerToolLattice(
+  "browser_screenshot",
+  {
+    name: "browser_screenshot",
+    description: BROWSER_SCREENSHOT_DESCRIPTION,
+    needUserApprove: false,
+    schema: z25.object({
+      name: z25.string().optional().describe("Name for the screenshot"),
+      selector: z25.string().optional().describe("CSS selector for element to screenshot"),
+      index: z25.number().optional().describe("index of the element to screenshot"),
+      width: z25.number().optional().describe("Width in pixels (default: viewport width)"),
+      height: z25.number().optional().describe("Height in pixels (default: viewport height)"),
+      fullPage: z25.boolean().optional().describe("Full page screenshot (default: false)"),
+      highlight: z25.boolean().default(false).describe("Highlight the element")
+    })
+  },
+  async (input, exe_config) => {
+    try {
+      const runConfig = exe_config.configurable?.runConfig;
+      const sandboxManager = getSandBoxManager();
+      const sandbox = await sandboxManager.getSandboxFromConfig(runConfig);
+      const result = await sandbox.mcp.executeMcpTool("browser", "browser_screenshot", {
+        name: input.name,
+        selector: input.selector,
+        index: input.index,
+        width: input.width,
+        height: input.height,
+        fullPage: input.fullPage,
+        highlight: input.highlight
+      });
+      if (!result.ok) {
+        return `Error taking screenshot: ${JSON.stringify(result.error.content)}`;
+      }
+      return result.body?.data?.content?.map((item) => item.text).join("\n") ?? "Screenshot taken successfully";
+    } catch (e) {
+      return `Error taking screenshot: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+);
+
+// src/tool_lattice/browser/browser_click.ts
+import z26 from "zod";
+var BROWSER_CLICK_DESCRIPTION = `Click an element on the page, before using the tool, use \`browser_get_clickable_elements\` to get the index of the element, but not call \`browser_get_clickable_elements\` multiple times.
+
+Args:
+    index (int): Index of the element to click
+
+`;
+registerToolLattice(
+  "browser_click",
+  {
+    name: "browser_click",
+    description: BROWSER_CLICK_DESCRIPTION,
+    needUserApprove: false,
+    schema: z26.object({
+      index: z26.number().describe("Index of the element to click")
+    })
+  },
+  async (input, exe_config) => {
+    try {
+      const runConfig = exe_config.configurable?.runConfig;
+      const sandboxManager = getSandBoxManager();
+      const sandbox = await sandboxManager.getSandboxFromConfig(runConfig);
+      const result = await sandbox.mcp.executeMcpTool("browser", "browser_click", {
+        index: input.index
+      });
+      if (!result.ok) {
+        return `Error clicking element: ${JSON.stringify(result.error.content)}`;
+      }
+      return result.body?.data?.content?.map((item) => item.text).join("\n") ?? "Element clicked successfully";
+    } catch (e) {
+      return `Error clicking element: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+);
+
+// src/tool_lattice/browser/browser_select.ts
+import z27 from "zod";
+var BROWSER_SELECT_DESCRIPTION = `Select an element on the page with index, Either 'index' or 'selector' must be provided.
+
+Args:
+    index (int): Index of the element to select
+    selector (str): CSS selector for element to select
+    value (str): Value to select
+
+`;
+registerToolLattice(
+  "browser_select",
+  {
+    name: "browser_select",
+    description: BROWSER_SELECT_DESCRIPTION,
+    needUserApprove: false,
+    schema: z27.object({
+      index: z27.number().optional().describe("Index of the element to select"),
+      selector: z27.string().optional().describe("CSS selector for element to select"),
+      value: z27.string().describe("Value to select")
+    })
+  },
+  async (input, exe_config) => {
+    try {
+      const runConfig = exe_config.configurable?.runConfig;
+      const sandboxManager = getSandBoxManager();
+      const sandbox = await sandboxManager.getSandboxFromConfig(runConfig);
+      const result = await sandbox.mcp.executeMcpTool("browser", "browser_select", {
+        index: input.index,
+        selector: input.selector,
+        value: input.value
+      });
+      if (!result.ok) {
+        return `Error selecting element: ${JSON.stringify(result.error.content)}`;
+      }
+      return result.body?.data?.content?.map((item) => item.text).join("\n") ?? "Element selected successfully";
+    } catch (e) {
+      return `Error selecting element: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+);
+
+// src/tool_lattice/browser/browser_hover.ts
+import z28 from "zod";
+var BROWSER_HOVER_DESCRIPTION = `Hover an element on the page, Either 'index' or 'selector' must be provided.
+
+Args:
+    index (int): Index of the element to hover
+    selector (str): CSS selector for element to hover
+
+`;
+registerToolLattice(
+  "browser_hover",
+  {
+    name: "browser_hover",
+    description: BROWSER_HOVER_DESCRIPTION,
+    needUserApprove: false,
+    schema: z28.object({
+      index: z28.number().optional().describe("Index of the element to hover"),
+      selector: z28.string().optional().describe("CSS selector for element to hover")
+    })
+  },
+  async (input, exe_config) => {
+    try {
+      const runConfig = exe_config.configurable?.runConfig;
+      const sandboxManager = getSandBoxManager();
+      const sandbox = await sandboxManager.getSandboxFromConfig(runConfig);
+      const result = await sandbox.mcp.executeMcpTool("browser", "browser_hover", {
+        index: input.index,
+        selector: input.selector
+      });
+      if (!result.ok) {
+        return `Error hovering element: ${JSON.stringify(result.error.content)}`;
+      }
+      return result.body?.data?.content?.map((item) => item.text).join("\n") ?? "Element hovered successfully";
+    } catch (e) {
+      return `Error hovering element: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+);
 
-// src/tool_lattice/load_skills/index.ts
-var LOAD_SKILLS_DESCRIPTION = `Load all available skills and return their metadata (name, description, license, compatibility, metadata, and subSkills) without the content. This tool returns skill information including hierarchical relationships (subSkills). Use this to discover what skills are available and their structure. Skills can have sub-skills, creating a tree structure for organizing capabilities.`;
+// src/tool_lattice/browser/browser_get_clickable_elements.ts
+import z29 from "zod";
+var BROWSER_GET_CLICKABLE_ELEMENTS_DESCRIPTION = `Get the clickable or hoverable or selectable elements on the current page, don't call this tool multiple times.
+
+Args:
+    None
+
+`;
 registerToolLattice(
-  "load_skills",
+  "browser_get_clickable_elements",
   {
-    name: "load_skills",
-    description: LOAD_SKILLS_DESCRIPTION,
+    name: "browser_get_clickable_elements",
+    description: BROWSER_GET_CLICKABLE_ELEMENTS_DESCRIPTION,
     needUserApprove: false,
-    schema: z7.object({})
+    schema: z29.object({})
   },
-  async () => {
+  async (input, exe_config) => {
     try {
-      const storeLattice = getStoreLattice("default", "skill");
-      const skillStore = storeLattice.store;
-      const skills = await skillStore.getAllSkills();
-      const skillsMeta = skills.map((skill) => ({
-        name: skill.name,
-        description: skill.description,
-        license: skill.license,
-        compatibility: skill.compatibility,
-        metadata: skill.metadata,
-        subSkills: skill.subSkills
-      }));
-      return JSON.stringify(skillsMeta, null, 2);
-    } catch (error) {
-      return `Error loading skills: ${error instanceof Error ? error.message : String(error)}`;
+      const runConfig = exe_config.configurable?.runConfig;
+      const sandboxManager = getSandBoxManager();
+      const sandbox = await sandboxManager.getSandboxFromConfig(runConfig);
+      const result = await sandbox.mcp.executeMcpTool("browser", "browser_get_clickable_elements", {});
+      if (!result.ok) {
+        return `Error getting clickable elements: ${JSON.stringify(result.error.content)}`;
+      }
+      return result.body?.data?.content?.map((item) => item.text).join("\n") ?? "Clickable elements retrieved successfully";
+    } catch (e) {
+      return `Error getting clickable elements: ${e instanceof Error ? e.message : String(e)}`;
     }
   }
 );
 
-// src/tool_lattice/load_skill_content/index.ts
-import z8 from "zod";
-var LOAD_SKILL_CONTENT_DESCRIPTION = `Load a specific skill's content by name and return its full content including markdown body. This tool returns the complete skill content including frontmatter and markdown body. If the skill has sub-skills defined, they will be listed in the frontmatter. Use this tool to get the complete skill content for a skill that you want to use.`;
+// src/tool_lattice/browser/browser_scroll.ts
+import z30 from "zod";
+var BROWSER_SCROLL_DESCRIPTION = `Scroll the page.
+
+Args:
+    amount (int): Pixels to scroll (positive for down, negative for up), if the amount is not provided, scroll to the bottom of the page
+
+`;
 registerToolLattice(
-  "load_skill_content",
+  "browser_scroll",
   {
-    name: "load_skill_content",
-    description: LOAD_SKILL_CONTENT_DESCRIPTION,
+    name: "browser_scroll",
+    description: BROWSER_SCROLL_DESCRIPTION,
     needUserApprove: false,
-    schema: z8.object({
-      skill_name: z8.string().describe("The name of the skill to load")
+    schema: z30.object({
+      amount: z30.number().optional().describe("Pixels to scroll (positive for down, negative for up), if the amount is not provided, scroll to the bottom of the page")
     })
   },
-  async (input) => {
+  async (input, exe_config) => {
     try {
-      const storeLattice = getStoreLattice("default", "skill");
-      const skillStore = storeLattice.store;
-      const skill = await skillStore.getSkillById(input.skill_name);
-      if (!skill) {
-        const allSkills = await skillStore.getAllSkills();
-        const availableSkills = allSkills.map((s) => s.name).join(", ");
-        return `Skill "${input.skill_name}" not found. Available skills: ${availableSkills}`;
-      }
-      const frontmatter = ["---"];
-      frontmatter.push(`name: ${skill.name}`);
-      frontmatter.push(`description: ${skill.description}`);
-      if (skill.license) {
-        frontmatter.push(`license: ${skill.license}`);
-      }
-      if (skill.compatibility) {
-        frontmatter.push(`compatibility: ${skill.compatibility}`);
+      const runConfig = exe_config.configurable?.runConfig;
+      const sandboxManager = getSandBoxManager();
+      const sandbox = await sandboxManager.getSandboxFromConfig(runConfig);
+      const result = await sandbox.mcp.executeMcpTool("browser", "browser_scroll", {
+        amount: input.amount
+      });
+      if (!result.ok) {
+        return `Error scrolling page: ${JSON.stringify(result.error.content)}`;
       }
-      if (skill.metadata && Object.keys(skill.metadata).length > 0) {
-        frontmatter.push("metadata:");
-        for (const [key, value] of Object.entries(skill.metadata)) {
-          frontmatter.push(`  ${key}: ${value}`);
-        }
+      return result.body?.data?.content?.map((item) => item.text).join("\n") ?? "Page scrolled successfully";
+    } catch (e) {
+      return `Error scrolling page: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+);
+
+// src/tool_lattice/browser/browser_close.ts
+import z31 from "zod";
+var BROWSER_CLOSE_DESCRIPTION = `Close the browser when the task is done and the browser is not needed anymore.
+
+Args:
+    None
+
+`;
+registerToolLattice(
+  "browser_close",
+  {
+    name: "browser_close",
+    description: BROWSER_CLOSE_DESCRIPTION,
+    needUserApprove: false,
+    schema: z31.object({})
+  },
+  async (input, exe_config) => {
+    try {
+      const runConfig = exe_config.configurable?.runConfig;
+      const sandboxManager = getSandBoxManager();
+      const sandbox = await sandboxManager.getSandboxFromConfig(runConfig);
+      const result = await sandbox.mcp.executeMcpTool("browser", "browser_close", {});
+      if (!result.ok) {
+        return `Error closing browser: ${JSON.stringify(result.error.content)}`;
       }
-      if (skill.subSkills && skill.subSkills.length > 0) {
-        frontmatter.push("subSkills:");
-        for (const subSkill of skill.subSkills) {
-          frontmatter.push(`  - ${subSkill}`);
-        }
+      return result.body?.data?.content?.map((item) => item.text).join("\n") ?? "Browser closed successfully";
+    } catch (e) {
+      return `Error closing browser: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+);
+
+// src/tool_lattice/browser/browser_press_key.ts
+import z32 from "zod";
+var BROWSER_PRESS_KEY_DESCRIPTION = `Press a key on the keyboard.
+
+Args:
+    key (str): Name of the key to press or a character to generate, such as Enter, Tab, Escape, Backspace, Delete, Insert, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, ArrowLeft, ArrowRight, ArrowUp, ArrowDown, PageUp, PageDown, Home, End, ShiftLeft, ShiftRight, ControlLeft, ControlRight, AltLeft, AltRight, MetaLeft, MetaRight, CapsLock, PrintScreen, ScrollLock, Pause, ContextMenu
+
+`;
+registerToolLattice(
+  "browser_press_key",
+  {
+    name: "browser_press_key",
+    description: BROWSER_PRESS_KEY_DESCRIPTION,
+    needUserApprove: false,
+    schema: z32.object({
+      key: z32.enum([
+        "Enter",
+        "Tab",
+        "Escape",
+        "Backspace",
+        "Delete",
+        "Insert",
+        "F1",
+        "F2",
+        "F3",
+        "F4",
+        "F5",
+        "F6",
+        "F7",
+        "F8",
+        "F9",
+        "F10",
+        "F11",
+        "F12",
+        "ArrowLeft",
+        "ArrowRight",
+        "ArrowUp",
+        "ArrowDown",
+        "PageUp",
+        "PageDown",
+        "Home",
+        "End",
+        "ShiftLeft",
+        "ShiftRight",
+        "ControlLeft",
+        "ControlRight",
+        "AltLeft",
+        "AltRight",
+        "MetaLeft",
+        "MetaRight",
+        "CapsLock",
+        "PrintScreen",
+        "ScrollLock",
+        "Pause",
+        "ContextMenu"
+      ]).describe("Name of the key to press or a character to generate, such as Enter, Tab, Escape, Backspace, Delete, Insert, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, ArrowLeft, ArrowRight, ArrowUp, ArrowDown, PageUp, PageDown, Home, End, ShiftLeft, ShiftRight, ControlLeft, ControlRight, AltLeft, AltRight, MetaLeft, MetaRight, CapsLock, PrintScreen, ScrollLock, Pause, ContextMenu")
+    })
+  },
+  async (input, exe_config) => {
+    try {
+      const runConfig = exe_config.configurable?.runConfig;
+      const sandboxManager = getSandBoxManager();
+      const sandbox = await sandboxManager.getSandboxFromConfig(runConfig);
+      const result = await sandbox.mcp.executeMcpTool("browser", "browser_press_key", {
+        key: input.key
+      });
+      if (!result.ok) {
+        return `Error pressing key: ${JSON.stringify(result.error.content)}`;
       }
-      frontmatter.push("---");
-      const content = skill.content || "";
-      return `${frontmatter.join("\n")}
-${content}`;
-    } catch (error) {
-      return `Error loading skill content: ${error instanceof Error ? error.message : String(error)}`;
+      return result.body?.data?.content?.map((item) => item.text).join("\n") ?? `Key ${input.key} pressed successfully`;
+    } catch (e) {
+      return `Error pressing key: ${e instanceof Error ? e.message : String(e)}`;
     }
   }
 );
@@ -2105,9 +3372,9 @@ var ReActAgentGraphBuilder = class {
    */
   build(agentLattice, params) {
     const tools = params.tools.map((t) => {
-      const tool5 = getToolClient(t.key);
-      return tool5;
-    }).filter((tool5) => tool5 !== void 0);
+      const tool7 = getToolClient(t.key);
+      return tool7;
+    }).filter((tool7) => tool7 !== void 0);
     const stateSchema2 = createReactAgentSchema(params.stateSchema);
     return createAgent({
       model: params.model,
@@ -2131,7 +3398,7 @@ import {
 // src/deep_agent_new/middleware/fs.ts
 import { createMiddleware, tool as tool2, ToolMessage } from "langchain";
 import { Command, isCommand, getCurrentTaskInput } from "@langchain/langgraph";
-import { z as z32 } from "zod/v3";
+import { z as z33 } from "zod/v3";
 import { withLangGraph } from "@langchain/langgraph/zod";
 
 // src/deep_agent_new/backends/utils.ts
@@ -2235,8 +3502,8 @@ function performStringReplacement(content, oldString, newString, replaceAll) {
   const newContent = content.split(oldString).join(newString);
   return [newContent, occurrences];
 }
-function validatePath(path2) {
-  const pathStr = path2 || "/";
+function validatePath(path4) {
+  const pathStr = path4 || "/";
   if (!pathStr || pathStr.trim() === "") {
     throw new Error("Path cannot be empty");
   }
@@ -2246,10 +3513,10 @@ function validatePath(path2) {
   }
   return normalized;
 }
-function globSearchFiles(files, pattern, path2 = "/") {
+function globSearchFiles(files, pattern, path4 = "/") {
   let normalizedPath;
   try {
-    normalizedPath = validatePath(path2);
+    normalizedPath = validatePath(path4);
   } catch {
     return "No files found";
   }
@@ -2259,15 +3526,15 @@ function globSearchFiles(files, pattern, path2 = "/") {
   const effectivePattern = pattern;
   const matches = [];
   for (const [filePath, fileData] of Object.entries(filtered)) {
-    let relative = filePath.substring(normalizedPath.length);
-    if (relative.startsWith("/")) {
-      relative = relative.substring(1);
+    let relative2 = filePath.substring(normalizedPath.length);
+    if (relative2.startsWith("/")) {
+      relative2 = relative2.substring(1);
     }
-    if (!relative) {
+    if (!relative2) {
       const parts = filePath.split("/");
-      relative = parts[parts.length - 1] || "";
+      relative2 = parts[parts.length - 1] || "";
     }
-    if (micromatch.isMatch(relative, effectivePattern, {
+    if (micromatch.isMatch(relative2, effectivePattern, {
       dot: true,
       nobrace: false
     })) {
@@ -2280,7 +3547,7 @@ function globSearchFiles(files, pattern, path2 = "/") {
   }
   return matches.map(([fp]) => fp).join("\n");
 }
-function grepMatchesFromFiles(files, pattern, path2 = null, glob = null) {
+function grepMatchesFromFiles(files, pattern, path4 = null, glob = null) {
   let regex;
   try {
     regex = new RegExp(pattern);
@@ -2289,7 +3556,7 @@ function grepMatchesFromFiles(files, pattern, path2 = null, glob = null) {
   }
   let normalizedPath;
   try {
-    normalizedPath = validatePath(path2);
+    normalizedPath = validatePath(path4);
   } catch {
     return [];
   }
@@ -2334,18 +3601,18 @@ var StateBackend = class {
    * @returns List of FileInfo objects for files and directories directly in the directory.
    *          Directories have a trailing / in their path and is_dir=true.
    */
-  lsInfo(path2) {
+  lsInfo(path4) {
     const files = this.getFiles();
     const infos = [];
     const subdirs = /* @__PURE__ */ new Set();
-    const normalizedPath = path2.endsWith("/") ? path2 : path2 + "/";
+    const normalizedPath = path4.endsWith("/") ? path4 : path4 + "/";
     for (const [k, fd] of Object.entries(files)) {
       if (!k.startsWith(normalizedPath)) {
         continue;
       }
-      const relative = k.substring(normalizedPath.length);
-      if (relative.includes("/")) {
-        const subdirName = relative.split("/")[0];
+      const relative2 = k.substring(normalizedPath.length);
+      if (relative2.includes("/")) {
+        const subdirName = relative2.split("/")[0];
         subdirs.add(normalizedPath + subdirName + "/");
         continue;
       }
@@ -2444,16 +3711,16 @@ var StateBackend = class {
   /**
    * Structured search results or error string for invalid input.
    */
-  grepRaw(pattern, path2 = "/", glob = null) {
+  grepRaw(pattern, path4 = "/", glob = null) {
     const files = this.getFiles();
-    return grepMatchesFromFiles(files, pattern, path2, glob);
+    return grepMatchesFromFiles(files, pattern, path4, glob);
   }
   /**
    * Structured glob matching returning FileInfo objects.
    */
-  globInfo(pattern, path2 = "/") {
+  globInfo(pattern, path4 = "/") {
     const files = this.getFiles();
-    const result = globSearchFiles(files, pattern, path2);
+    const result = globSearchFiles(files, pattern, path4);
     if (result === "No files found") {
       return [];
     }
@@ -2474,10 +3741,10 @@ var StateBackend = class {
 };
 
 // src/deep_agent_new/middleware/fs.ts
-var FileDataSchema = z32.object({
-  content: z32.array(z32.string()),
-  created_at: z32.string(),
-  modified_at: z32.string()
+var FileDataSchema = z33.object({
+  content: z33.array(z33.string()),
+  created_at: z33.string(),
+  modified_at: z33.string()
 });
 function fileDataReducer(left, right) {
   if (left === void 0) {
@@ -2499,20 +3766,20 @@ function fileDataReducer(left, right) {
   }
   return result;
 }
-var FilesystemStateSchema = z32.object({
+var FilesystemStateSchema = z33.object({
   files: withLangGraph(
-    z32.record(z32.string(), FileDataSchema).default({}),
+    z33.record(z33.string(), FileDataSchema).default({}),
     {
       reducer: {
         fn: fileDataReducer,
-        schema: z32.record(z32.string(), FileDataSchema.nullable())
+        schema: z33.record(z33.string(), FileDataSchema.nullable())
       }
     }
   )
 });
-function getBackend(backend, stateAndStore) {
+async function getBackend(backend, stateAndStore) {
   if (typeof backend === "function") {
-    return backend(stateAndStore);
+    return await backend(stateAndStore);
   }
   return backend;
 }
@@ -2538,11 +3805,11 @@ function createLsTool(backend, options) {
         state: getCurrentTaskInput(config),
         store: config.store
       };
-      const resolvedBackend = getBackend(backend, stateAndStore);
-      const path2 = input.path || "/";
-      const infos = await resolvedBackend.lsInfo(path2);
+      const resolvedBackend = await getBackend(backend, stateAndStore);
+      const path4 = input.path || "/";
+      const infos = await resolvedBackend.lsInfo(path4);
       if (infos.length === 0) {
-        return `No files found in ${path2}`;
+        return `No files found in ${path4}`;
       }
       const lines = [];
       for (const info of infos) {
@@ -2558,8 +3825,8 @@ function createLsTool(backend, options) {
     {
       name: "ls",
       description: customDescription || LS_TOOL_DESCRIPTION,
-      schema: z32.object({
-        path: z32.string().optional().default("/").describe("Directory path to list (default: /)")
+      schema: z33.object({
+        path: z33.string().optional().default("/").describe("Directory path to list (default: /)")
       })
     }
   );
@@ -2572,17 +3839,17 @@ function createReadFileTool(backend, options) {
         state: getCurrentTaskInput(config),
         store: config.store
       };
-      const resolvedBackend = getBackend(backend, stateAndStore);
+      const resolvedBackend = await getBackend(backend, stateAndStore);
       const { file_path, offset = 0, limit = 2e3 } = input;
       return await resolvedBackend.read(file_path, offset, limit);
     },
     {
       name: "read_file",
       description: customDescription || READ_FILE_TOOL_DESCRIPTION,
-      schema: z32.object({
-        file_path: z32.string().describe("Absolute path to the file to read"),
-        offset: z32.number({ coerce: true }).optional().default(0).describe("Line offset to start reading from (0-indexed)"),
-        limit: z32.number({ coerce: true }).optional().default(2e3).describe("Maximum number of lines to read")
+      schema: z33.object({
+        file_path: z33.string().describe("Absolute path to the file to read"),
+        offset: z33.number({ coerce: true }).optional().default(0).describe("Line offset to start reading from (0-indexed)"),
+        limit: z33.number({ coerce: true }).optional().default(2e3).describe("Maximum number of lines to read")
       })
     }
   );
@@ -2595,7 +3862,7 @@ function createWriteFileTool(backend, options) {
         state: getCurrentTaskInput(config),
         store: config.store
       };
-      const resolvedBackend = getBackend(backend, stateAndStore);
+      const resolvedBackend = await getBackend(backend, stateAndStore);
       const { file_path, content } = input;
       const result = await resolvedBackend.write(file_path, content);
       if (result.error) {
@@ -2617,9 +3884,9 @@ function createWriteFileTool(backend, options) {
     {
       name: "write_file",
       description: customDescription || WRITE_FILE_TOOL_DESCRIPTION,
-      schema: z32.object({
-        file_path: z32.string().describe("Absolute path to the file to write"),
-        content: z32.string().describe("Content to write to the file")
+      schema: z33.object({
+        file_path: z33.string().describe("Absolute path to the file to write"),
+        content: z33.string().describe("Content to write to the file")
       })
     }
   );
@@ -2632,7 +3899,7 @@ function createEditFileTool(backend, options) {
         state: getCurrentTaskInput(config),
         store: config.store
       };
-      const resolvedBackend = getBackend(backend, stateAndStore);
+      const resolvedBackend = await getBackend(backend, stateAndStore);
       const { file_path, old_string, new_string, replace_all = false } = input;
       const result = await resolvedBackend.edit(
         file_path,
@@ -2659,11 +3926,11 @@ function createEditFileTool(backend, options) {
     {
       name: "edit_file",
       description: customDescription || EDIT_FILE_TOOL_DESCRIPTION,
-      schema: z32.object({
-        file_path: z32.string().describe("Absolute path to the file to edit"),
-        old_string: z32.string().describe("String to be replaced (must match exactly)"),
-        new_string: z32.string().describe("String to replace with"),
-        replace_all: z32.boolean().optional().default(false).describe("Whether to replace all occurrences")
+      schema: z33.object({
+        file_path: z33.string().describe("Absolute path to the file to edit"),
+        old_string: z33.string().describe("String to be replaced (must match exactly)"),
+        new_string: z33.string().describe("String to replace with"),
+        replace_all: z33.boolean().optional().default(false).describe("Whether to replace all occurrences")
       })
     }
   );
@@ -2676,9 +3943,9 @@ function createGlobTool(backend, options) {
         state: getCurrentTaskInput(config),
         store: config.store
       };
-      const resolvedBackend = getBackend(backend, stateAndStore);
-      const { pattern, path: path2 = "/" } = input;
-      const infos = await resolvedBackend.globInfo(pattern, path2);
+      const resolvedBackend = await getBackend(backend, stateAndStore);
+      const { pattern, path: path4 = "/" } = input;
+      const infos = await resolvedBackend.globInfo(pattern, path4);
       if (infos.length === 0) {
         return `No files found matching pattern '${pattern}'`;
       }
@@ -2687,9 +3954,9 @@ function createGlobTool(backend, options) {
     {
       name: "glob",
       description: customDescription || GLOB_TOOL_DESCRIPTION,
-      schema: z32.object({
-        pattern: z32.string().describe("Glob pattern (e.g., '*.py', '**/*.ts')"),
-        path: z32.string().optional().default("/").describe("Base path to search from (default: /)")
+      schema: z33.object({
+        pattern: z33.string().describe("Glob pattern (e.g., '*.py', '**/*.ts')"),
+        path: z33.string().optional().default("/").describe("Base path to search from (default: /)")
       })
     }
   );
@@ -2702,9 +3969,9 @@ function createGrepTool(backend, options) {
         state: getCurrentTaskInput(config),
         store: config.store
       };
-      const resolvedBackend = getBackend(backend, stateAndStore);
-      const { pattern, path: path2 = "/", glob = null } = input;
-      const result = await resolvedBackend.grepRaw(pattern, path2, glob);
+      const resolvedBackend = await getBackend(backend, stateAndStore);
+      const { pattern, path: path4 = "/", glob = null } = input;
+      const result = await resolvedBackend.grepRaw(pattern, path4, glob);
       if (typeof result === "string") {
         return result;
       }
@@ -2726,17 +3993,17 @@ ${currentFile}:`);
     {
       name: "grep",
       description: customDescription || GREP_TOOL_DESCRIPTION,
-      schema: z32.object({
-        pattern: z32.string().describe("Regex pattern to search for"),
-        path: z32.string().optional().default("/").describe("Base path to search from (default: /)"),
-        glob: z32.string().optional().nullable().describe("Optional glob pattern to filter files (e.g., '*.py')")
+      schema: z33.object({
+        pattern: z33.string().describe("Regex pattern to search for"),
+        path: z33.string().optional().default("/").describe("Base path to search from (default: /)"),
+        glob: z33.string().optional().nullable().describe("Optional glob pattern to filter files (e.g., '*.py')")
       })
     }
   );
 }
 function createFilesystemMiddleware(options = {}) {
   const {
-    backend = (stateAndStore) => new StateBackend(stateAndStore),
+    backend = async (stateAndStore) => new StateBackend(stateAndStore),
     systemPrompt: customSystemPrompt = null,
     customToolDescriptions = null,
     toolTokenLimitBeforeEvict = 2e4
@@ -2781,7 +4048,7 @@ ${systemPrompt}` : systemPrompt;
             state: request.state || {},
             store: request.config?.store
           };
-          const resolvedBackend = getBackend(backend, stateAndStore);
+          const resolvedBackend = await getBackend(backend, stateAndStore);
           const sanitizedId = sanitizeToolCallId(
             request.toolCall?.id || msg.tool_call_id
           );
@@ -2857,7 +4124,7 @@ ${systemPrompt}` : systemPrompt;
 }
 
 // src/deep_agent_new/middleware/subagents.ts
-import { z as z9 } from "zod/v3";
+import { z as z34 } from "zod/v3";
 import {
   createMiddleware as createMiddleware2,
   createAgent as createAgent2,
@@ -3534,9 +4801,9 @@ function createTaskTool(options) {
     {
       name: "task",
       description: finalTaskDescription,
-      schema: z9.object({
-        description: z9.string().describe("The task to execute with the selected agent"),
-        subagent_type: z9.string().describe(
+      schema: z34.object({
+        description: z34.string().describe("The task to execute with the selected agent"),
+        subagent_type: z34.string().describe(
           `Name of the agent to use. Available: ${Object.keys(
             subagentGraphs
           ).join(", ")}`
@@ -3640,7 +4907,7 @@ var SUPPORTS_NOFOLLOW = fsSync.constants.O_NOFOLLOW !== void 0;
 
 // src/deep_agent_new/middleware/todos.ts
 import { Command as Command3 } from "@langchain/langgraph";
-import { z as z10 } from "zod";
+import { z as z35 } from "zod";
 import { createMiddleware as createMiddleware4, tool as tool4, ToolMessage as ToolMessage4 } 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.
@@ -3868,12 +5135,12 @@ 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 = z10.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
-var TodoSchema = z10.object({
-  content: z10.string().describe("Content of the todo item"),
+var TodoStatus = z35.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
+var TodoSchema = z35.object({
+  content: z35.string().describe("Content of the todo item"),
   status: TodoStatus
 });
-var stateSchema = z10.object({ todos: z10.array(TodoSchema).default([]) });
+var stateSchema = z35.object({ todos: z35.array(TodoSchema).default([]) });
 function todoListMiddleware(options) {
   const writeTodos = tool4(
     ({ todos }, config) => {
@@ -3892,8 +5159,8 @@ function todoListMiddleware(options) {
     {
       name: "write_todos",
       description: options?.toolDescription ?? WRITE_TODOS_DESCRIPTION,
-      schema: z10.object({
-        todos: z10.array(TodoSchema).describe("List of todo items to update")
+      schema: z35.object({
+        todos: z35.array(TodoSchema).describe("List of todo items to update")
       })
     }
   );
@@ -3981,7 +5248,7 @@ function createDeepAgent(params = {}) {
   const finalSystemPrompt = systemPrompt ? `${systemPrompt}
 
 ${BASE_PROMPT}` : BASE_PROMPT;
-  const filesystemBackend = backend ? backend : (config) => new StateBackend(config);
+  const filesystemBackend = backend ? backend : async (config) => new StateBackend(config);
   const middleware = [
     // Provides todo list management capabilities for tracking tasks
     todoListMiddleware(),
@@ -4046,6 +5313,303 @@ ${BASE_PROMPT}` : BASE_PROMPT;
   });
 }
 
+// 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) => {
+      console.log(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 relative2 = path3.relative(rootPath, realPath);
+    const normalized = relative2.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/middlewares/codeEvalMiddleware.ts
+import { createMiddleware as createMiddleware6 } from "langchain";
+function createCodeEvalMiddleware(params = {}) {
+  const codeEvalTool = getToolClient("execute_code");
+  const codeExecuteFileTool = getToolClient("execute_code_file");
+  return createMiddleware6({
+    name: "codeEvalMiddleware",
+    tools: [codeEvalTool, codeExecuteFileTool, getToolClient("convert_to_markdown")]
+  });
+}
+
+// src/middlewares/browserMiddleware.ts
+import { createMiddleware as createMiddleware7 } from "langchain";
+function createBrowserMiddleware(params = {}) {
+  const browserTools = toolLatticeManager.getAllLattices().filter((tool7) => tool7.key.startsWith("browser_"));
+  return createMiddleware7({
+    name: "browserMiddleware",
+    tools: browserTools.map((tool7) => tool7.client)
+  });
+}
+
 // src/agent_lattice/builders/DeepAgentGraphBuilder.ts
 var DeepAgentGraphBuilder = class {
   /**
@@ -4059,7 +5623,7 @@ var DeepAgentGraphBuilder = class {
     const tools = params.tools.map((t) => {
       const toolClient = getToolClient(t.key);
       return toolClient;
-    }).filter((tool5) => tool5 !== void 0);
+    }).filter((tool7) => tool7 !== void 0);
     const subagents = params.subAgents.map((sa) => {
       if (sa.client) {
         return {
@@ -4078,6 +5642,35 @@ var DeepAgentGraphBuilder = class {
         };
       }
     });
+    let filesystemBackend;
+    let middlewares = [];
+    if (params.connectedSandbox) {
+      const availabledModules = params.connectedSandbox?.availabledModules || ["filesystem", "code_eval", "browser"];
+      if (availabledModules.includes("filesystem")) {
+        const sandboxManager = sandboxLatticeManager.getSandboxLattice("default");
+        if (!sandboxManager) {
+          throw new Error("Sandbox manager not found");
+        }
+        let sandboxName = "global";
+        if (params.connectedSandbox.isolatedLevel === "agent") {
+          sandboxName = agentLattice.config.key;
+          filesystemBackend = async (agentAndState) => new SandboxFilesystem({
+            sandboxInstance: await sandboxManager.createSandbox(sandboxName)
+          });
+        } else if (params.connectedSandbox.isolatedLevel === "thread") {
+          filesystemBackend = async (agentAndState) => new SandboxFilesystem({
+            sandboxInstance: await sandboxManager.createSandbox(sandboxName)
+            //TODO: add threadId to sandbox
+          });
+        }
+      }
+      if (availabledModules.includes("code_eval")) {
+        middlewares.push(createCodeEvalMiddleware());
+      }
+      if (availabledModules.includes("browser")) {
+        middlewares.push(createBrowserMiddleware());
+      }
+    }
     const deepAgent = createDeepAgent({
       tools,
       model: params.model,
@@ -4085,7 +5678,9 @@ var DeepAgentGraphBuilder = class {
       systemPrompt: params.prompt,
       subagents,
       checkpointer: getCheckpointSaver("default"),
-      skillCategories: params.skillCategories
+      skillCategories: params.skillCategories,
+      backend: filesystemBackend,
+      middleware: middlewares
     });
     return deepAgent;
   }
@@ -4203,7 +5798,8 @@ var AgentParamsBuilder = class {
       subAgents: [...subAgents, ...internalSubAgents],
       prompt: agentLattice.config.prompt,
       stateSchema: agentLattice.config.schema,
-      skillCategories
+      skillCategories,
+      connectedSandbox: agentLattice.config.connectedSandbox
     };
   }
 };
@@ -6488,6 +8084,106 @@ var SkillLatticeManager = class _SkillLatticeManager extends BaseLatticeManager
 };
 var skillLatticeManager = SkillLatticeManager.getInstance();
 
+// src/mcp_lattice/McpLatticeManager.ts
+import { MultiServerMCPClient } from "@langchain/mcp-adapters";
+var McpLatticeManager = class _McpLatticeManager extends BaseLatticeManager {
+  constructor() {
+    super(...arguments);
+    this.client = null;
+    this.servers = /* @__PURE__ */ new Map();
+  }
+  static getInstance() {
+    if (!_McpLatticeManager._instance) {
+      _McpLatticeManager._instance = new _McpLatticeManager();
+    }
+    return _McpLatticeManager._instance;
+  }
+  getLatticeType() {
+    return "mcp";
+  }
+  registerServers(servers) {
+    for (const server of servers) {
+      if (this.servers.has(server.name)) {
+        console.warn(`[MCP] Server '${server.name}' already registered, skipping`);
+        continue;
+      }
+      this.servers.set(server.name, server);
+      console.log(`[MCP] Registered server: ${server.name}`);
+    }
+  }
+  addServer(name, connection) {
+    this.registerServers([{ name, connection }]);
+  }
+  removeServer(name) {
+    const deleted = this.servers.delete(name);
+    if (deleted) {
+      console.log(`[MCP] Removed server: ${name}`);
+    }
+    return deleted;
+  }
+  async connect() {
+    if (this.client) {
+      console.warn("[MCP] Client already connected");
+      return;
+    }
+    const serverConfigs = {};
+    for (const [name, info] of this.servers) {
+      serverConfigs[name] = info.connection;
+    }
+    if (Object.keys(serverConfigs).length === 0) {
+      console.warn("[MCP] No servers registered");
+      return;
+    }
+    this.client = new MultiServerMCPClient({
+      mcpServers: serverConfigs
+    });
+    console.log(`[MCP] Connecting to ${this.servers.size} servers...`);
+    await this.client.initializeConnections();
+    console.log("[MCP] All servers connected");
+  }
+  async disconnect() {
+    if (this.client) {
+      await this.client.close();
+      this.client = null;
+      console.log("[MCP] Disconnected");
+    }
+  }
+  isConnected() {
+    return this.client !== null;
+  }
+  async getAllTools() {
+    if (!this.client) {
+      throw new Error("MCP client not connected");
+    }
+    return this.client.getTools();
+  }
+  getServerNames() {
+    return Array.from(this.servers.keys());
+  }
+  hasServer(name) {
+    return this.servers.has(name);
+  }
+  /**
+   * 将 MCP 工具注册到 Tool Lattice
+   * @param prefix 工具键名前缀，用于区分不同服务器的工具
+   */
+  async registerToolsToToolLattice(prefix) {
+    if (!this.client) {
+      throw new Error("MCP client not connected");
+    }
+    const tools = await this.getAllTools();
+    console.log(`[MCP] Registering ${tools.length} tools to Tool Lattice...`);
+    for (const tool7 of tools) {
+      const toolKey = prefix ? `${prefix}_${tool7.name}` : tool7.name;
+      tool7.name = toolKey;
+      toolLatticeManager.registerExistingTool(toolKey, tool7);
+      console.log(`[MCP] Registered tool: ${toolKey}`);
+    }
+    console.log(`[MCP] Successfully registered ${tools.length} tools to Tool Lattice`);
+  }
+};
+var mcpManager = McpLatticeManager.getInstance();
+
 // src/index.ts
 import * as Protocols from "@axiom-lattice/protocols";
 export {
@@ -6507,6 +8203,7 @@ export {
   InMemoryChunkBuffer,
   InMemoryThreadStore,
   LoggerLatticeManager,
+  McpLatticeManager,
   MemoryLatticeManager,
   MemoryQueueClient,
   MemoryScheduleStorage,
@@ -6516,6 +8213,7 @@ export {
   PostgresDatabase,
   Protocols,
   QueueLatticeManager,
+  SandboxLatticeManager,
   ScheduleLatticeManager,
   SkillLatticeManager,
   SqlDatabaseManager,
@@ -6541,6 +8239,7 @@ export {
   getModelLattice,
   getNextCronTime,
   getQueueLattice,
+  getSandBoxManager,
   getScheduleLattice,
   getStoreLattice,
   getToolClient,
@@ -6550,9 +8249,12 @@ export {
   getVectorStoreLattice,
   hasChunkBuffer,
   isValidCronExpression,
+  isValidSandboxName,
   isValidSkillName,
   loggerLatticeManager,
+  mcpManager,
   modelLatticeManager,
+  normalizeSandboxName,
   parseCronExpression,
   queueLatticeManager,
   registerAgentLattice,
@@ -6560,6 +8262,7 @@ export {
   registerCheckpointSaver,
   registerChunkBuffer,
   registerEmbeddingsLattice,
+  registerExistingTool,
   registerLoggerLattice,
   registerModelLattice,
   registerQueueLattice,
@@ -6567,6 +8270,7 @@ export {
   registerStoreLattice,
   registerToolLattice,
   registerVectorStoreLattice,
+  sandboxLatticeManager,
   scheduleLatticeManager,
   skillLatticeManager,
   sqlDatabaseManager,