@axiom-lattice/core 2.1.50 → 2.1.52

package/dist/index.mjs

@@ -3266,39 +3266,68 @@ ${serverKeys.map(
 // src/tool_lattice/code_eval/index.ts
 import z15 from "zod";
 
-// src/sandbox_lattice/utils.ts
-function normalizeSandboxName(name) {
-  if (!name || typeof name !== "string") {
-    throw new Error("Sandbox name must be a non-empty string");
+// src/deep_agent_new/backends/volumeFilesystem.ts
+var VolumeFilesystem = class {
+  constructor(client) {
+    this.client = client;
   }
-  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`
-    );
+  async lsInfo(path4) {
+    const entries = await this.client.list(path4);
+    return entries.map((entry) => ({
+      path: entry.path,
+      is_dir: entry.kind === "directory",
+      size: entry.size,
+      modified_at: entry.modified ? new Date(entry.modified).toISOString() : void 0
+    }));
   }
-  if (!/^[a-z0-9]/.test(normalized)) {
-    normalized = `sandbox-${normalized}`;
+  async read(filePath, offset = 0, limit = 2e3) {
+    const raw = await this.client.read(filePath);
+    const lines = raw.split("\n");
+    const start = Math.max(0, offset);
+    const end = Math.min(lines.length, start + limit);
+    const sliced = lines.slice(start, end);
+    return sliced.map((line, i) => {
+      const lineNum = (start + i + 1).toString().padStart(6, " ");
+      return `${lineNum}|${line}`;
+    }).join("\n");
   }
-  if (!/[a-z0-9]$/.test(normalized)) {
-    normalized = `${normalized}-0`;
+  async readRaw(filePath) {
+    const content = await this.client.read(filePath);
+    const lines = content.split("\n");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      content: lines,
+      created_at: now,
+      modified_at: now
+    };
   }
-  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`;
+  grepRaw(_pattern, _path, _glob) {
+    throw new Error("Not supported on volume backend");
+  }
+  globInfo(_pattern, _path) {
+    throw new Error("Not supported on volume backend");
+  }
+  async write(filePath, content) {
+    try {
+      await this.client.write(filePath, content);
+      return { path: filePath, filesUpdate: null };
+    } catch (err) {
+      return { error: String(err) };
     }
   }
-  return normalized;
+  edit(_filePath, _oldString, _newString, _replaceAll) {
+    throw new Error("Not supported on volume backend");
+  }
+};
+
+// src/sandbox_lattice/utils.ts
+import { createHash } from "crypto";
+function normalizeSandboxName(name) {
+  if (!name || typeof name !== "string") {
+    throw new Error("Sandbox name must be a non-empty string");
+  }
+  const hash = createHash("sha256").update(name).digest("hex").slice(0, 16);
+  return `n${hash}`;
 }
 function isValidSandboxName(name) {
   if (!name || typeof name !== "string") {
@@ -3307,6 +3336,24 @@ function isValidSandboxName(name) {
   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());
 }
+function buildSandboxMetadataEnv(config) {
+  if (!config) {
+    return {};
+  }
+  const vars = {};
+  if (config.tenantId) vars.LATTICE_TENANT_ID = config.tenantId;
+  if (config.assistant_id) vars.LATTICE_ASSISTANT_ID = config.assistant_id;
+  if (config.projectId) vars.LATTICE_PROJECT_ID = config.projectId;
+  if (config.workspaceId) vars.LATTICE_WORKSPACE_ID = config.workspaceId;
+  return vars;
+}
+
+// src/sandbox_lattice/volumeFsUtils.ts
+import { createHash as createHash2 } from "crypto";
+function buildNamedVolumeName(prefix, ...parts) {
+  const hash = createHash2("sha256").update(parts.filter((part) => part !== void 0).join("\0")).digest("hex").slice(0, 16);
+  return `${prefix}${hash}`;
+}
 
 // src/sandbox_lattice/SandboxLatticeManager.ts
 function computeSandboxName(config) {
@@ -3317,7 +3364,7 @@ function computeSandboxName(config) {
       return normalizeSandboxName(`${config.tenantId ?? "default"}-${config.assistant_id}`);
     case "project":
       return normalizeSandboxName(
-        `${config.tenantId ?? "default"}-${config.workspaceId ?? "default"}-${config.projectId ?? "default"}`
+        `${config.tenantId ?? "default"}-${config.assistant_id ?? "default"}-${config.projectId ?? "default"}`
       );
   }
 }
@@ -3379,6 +3426,19 @@ var SandboxLatticeManager = class _SandboxLatticeManager extends BaseLatticeMana
     });
     return this.createSandbox(name, config);
   }
+  async getVolumeBackend(config) {
+    const provider = this._requireProvider();
+    if (!provider.createVolumeFsClient) {
+      return null;
+    }
+    const tenantId = config.tenantId ?? "default";
+    if (!config.projectId) {
+      return null;
+    }
+    const volumeName = buildNamedVolumeName("p", "project", tenantId, config.workspaceId, config.projectId);
+    const client = provider.createVolumeFsClient(volumeName);
+    return new VolumeFilesystem(client);
+  }
   async createSandbox(name, config) {
     const provider = this._requireProvider();
     return provider.createSandbox(name, config);
@@ -4414,13 +4474,6 @@ import { HumanMessage as HumanMessage3 } from "@langchain/core/messages";
 // src/agent_lattice/types.ts
 import {
   AgentType,
-  AgentConfig,
-  ReactAgentConfig,
-  DeepAgentConfig,
-  TeamAgentConfig,
-  TeamTeammateConfig,
-  AgentConfigWithTools,
-  GraphBuildOptions,
   hasTools,
   isDeepAgentConfig,
   isTeamAgentConfig,
@@ -5011,21 +5064,28 @@ function truncateIfTooLong(result) {
   }
   return result;
 }
-function validatePath(path3) {
-  const pathStr = path3 || "/";
+function validatePath(path4) {
+  const pathStr = path4 || "/";
   if (!pathStr || pathStr.trim() === "") {
     throw new Error("Path cannot be empty");
   }
-  let normalized = pathStr.startsWith("/") ? pathStr : "/" + pathStr;
+  let normalized;
+  if (pathStr === "~") {
+    normalized = "~/";
+  } else if (pathStr.startsWith("~/")) {
+    normalized = pathStr;
+  } else {
+    normalized = pathStr.startsWith("/") ? pathStr : "/" + pathStr;
+  }
   if (!normalized.endsWith("/")) {
     normalized += "/";
   }
   return normalized;
 }
-function globSearchFiles(files, pattern, path3 = "/") {
+function globSearchFiles(files, pattern, path4 = "/") {
   let normalizedPath;
   try {
-    normalizedPath = validatePath(path3);
+    normalizedPath = validatePath(path4);
   } catch {
     return "No files found";
   }
@@ -5077,7 +5137,7 @@ function formatGrepResults(results, outputMode) {
   }
   return lines.join("\n");
 }
-function grepSearchFiles(files, pattern, path3 = null, glob = null, outputMode = "files_with_matches") {
+function grepSearchFiles(files, pattern, path4 = null, glob = null, outputMode = "files_with_matches") {
   let regex;
   try {
     regex = new RegExp(pattern);
@@ -5086,7 +5146,7 @@ function grepSearchFiles(files, pattern, path3 = null, glob = null, outputMode =
   }
   let normalizedPath;
   try {
-    normalizedPath = validatePath(path3);
+    normalizedPath = validatePath(path4);
   } catch {
     return "No matches found";
   }
@@ -5118,7 +5178,7 @@ function grepSearchFiles(files, pattern, path3 = null, glob = null, outputMode =
   }
   return formatGrepResults(results, outputMode);
 }
-function grepMatchesFromFiles(files, pattern, path3 = null, glob = null) {
+function grepMatchesFromFiles(files, pattern, path4 = null, glob = null) {
   let regex;
   try {
     regex = new RegExp(pattern);
@@ -5127,7 +5187,7 @@ function grepMatchesFromFiles(files, pattern, path3 = null, glob = null) {
   }
   let normalizedPath;
   try {
-    normalizedPath = validatePath(path3);
+    normalizedPath = validatePath(path4);
   } catch {
     return [];
   }
@@ -5188,11 +5248,11 @@ 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(path3) {
+  lsInfo(path4) {
     const files = this.getFiles();
     const infos = [];
     const subdirs = /* @__PURE__ */ new Set();
-    const normalizedPath = path3.endsWith("/") ? path3 : path3 + "/";
+    const normalizedPath = path4.endsWith("/") ? path4 : path4 + "/";
     for (const [k, fd] of Object.entries(files)) {
       if (!k.startsWith(normalizedPath)) {
         continue;
@@ -5298,16 +5358,16 @@ var StateBackend = class {
   /**
    * Structured search results or error string for invalid input.
    */
-  grepRaw(pattern, path3 = "/", glob = null) {
+  grepRaw(pattern, path4 = "/", glob = null) {
     const files = this.getFiles();
-    return grepMatchesFromFiles(files, pattern, path3, glob);
+    return grepMatchesFromFiles(files, pattern, path4, glob);
   }
   /**
    * Structured glob matching returning FileInfo objects.
    */
-  globInfo(pattern, path3 = "/") {
+  globInfo(pattern, path4 = "/") {
     const files = this.getFiles();
-    const result = globSearchFiles(files, pattern, path3);
+    const result = globSearchFiles(files, pattern, path4);
     if (result === "No files found") {
       return [];
     }
@@ -5401,10 +5461,10 @@ function createLsTool(backend, options) {
         ...runConfig
       };
       const resolvedBackend = await getBackend(backend, stateAndStore);
-      const path3 = input.path || "/";
-      const infos = await resolvedBackend.lsInfo(path3);
+      const path4 = input.path || "/";
+      const infos = await resolvedBackend.lsInfo(path4);
       if (infos.length === 0) {
-        return `No files found in ${path3}`;
+        return `No files found in ${path4}`;
       }
       const lines = [];
       for (const info of infos) {
@@ -5547,8 +5607,8 @@ function createGlobTool(backend, options) {
         ...runConfig
       };
       const resolvedBackend = await getBackend(backend, stateAndStore);
-      const { pattern, path: path3 = "/" } = input;
-      const infos = await resolvedBackend.globInfo(pattern, path3);
+      const { pattern, path: path4 = "/" } = input;
+      const infos = await resolvedBackend.globInfo(pattern, path4);
       if (infos.length === 0) {
         return `No files found matching pattern '${pattern}'`;
       }
@@ -5575,8 +5635,8 @@ function createGrepTool(backend, options) {
         ...runConfig
       };
       const resolvedBackend = await getBackend(backend, stateAndStore);
-      const { pattern, path: path3 = "/", glob = null } = input;
-      const result = await resolvedBackend.grepRaw(pattern, path3, glob);
+      const { pattern, path: path4 = "/", glob = null } = input;
+      const result = await resolvedBackend.grepRaw(pattern, path4, glob);
       if (typeof result === "string") {
         return result;
       }
@@ -12995,13 +13055,13 @@ var StoreBackend = 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.
    */
-  async lsInfo(path3) {
+  async lsInfo(path4) {
     const store = this.getStore();
     const namespace = this.getNamespace();
     const items = await this.searchStorePaginated(store, namespace);
     const infos = [];
     const subdirs = /* @__PURE__ */ new Set();
-    const normalizedPath = path3.endsWith("/") ? path3 : path3 + "/";
+    const normalizedPath = path4.endsWith("/") ? path4 : path4 + "/";
     for (const item of items) {
       const itemKey = String(item.key);
       if (!itemKey.startsWith(normalizedPath)) {
@@ -13119,7 +13179,7 @@ var StoreBackend = class {
   /**
    * Structured search results or error string for invalid input.
    */
-  async grepRaw(pattern, path3 = "/", glob = null) {
+  async grepRaw(pattern, path4 = "/", glob = null) {
     const store = this.getStore();
     const namespace = this.getNamespace();
     const items = await this.searchStorePaginated(store, namespace);
@@ -13131,12 +13191,12 @@ var StoreBackend = class {
         continue;
       }
     }
-    return grepMatchesFromFiles(files, pattern, path3, glob);
+    return grepMatchesFromFiles(files, pattern, path4, glob);
   }
   /**
    * Structured glob matching returning FileInfo objects.
    */
-  async globInfo(pattern, path3 = "/") {
+  async globInfo(pattern, path4 = "/") {
     const store = this.getStore();
     const namespace = this.getNamespace();
     const items = await this.searchStorePaginated(store, namespace);
@@ -13148,7 +13208,7 @@ var StoreBackend = class {
         continue;
       }
     }
-    const result = globSearchFiles(files, pattern, path3);
+    const result = globSearchFiles(files, pattern, path4);
     if (result === "No files found") {
       return [];
     }
@@ -13197,8 +13257,9 @@ var FilesystemBackend = class {
    */
   resolvePath(key) {
     if (this.virtualMode) {
-      const vpath = key.startsWith("/") ? key : "/" + key;
-      if (vpath.includes("..") || vpath.startsWith("~")) {
+      const normalizedKey = key === "~" ? "/" : key.startsWith("~/") ? `/${key.slice(2)}` : key;
+      const vpath = normalizedKey.startsWith("/") ? normalizedKey : "/" + normalizedKey;
+      if (vpath.includes("..") || vpath.includes("~")) {
         throw new Error("Path traversal not allowed");
       }
       const full = path2.resolve(this.cwd, vpath.substring(1));
@@ -13723,10 +13784,10 @@ var CompositeBackend = class {
    * @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(path3) {
+  async lsInfo(path4) {
     for (const [routePrefix, backend] of this.sortedRoutes) {
-      if (path3.startsWith(routePrefix.replace(/\/$/, ""))) {
-        const suffix = path3.substring(routePrefix.length);
+      if (path4.startsWith(routePrefix.replace(/\/$/, ""))) {
+        const suffix = path4.substring(routePrefix.length);
         const searchPath = suffix ? "/" + suffix : "/";
         const infos = await backend.lsInfo(searchPath);
         const prefixed = [];
@@ -13739,9 +13800,9 @@ var CompositeBackend = class {
         return prefixed;
       }
     }
-    if (path3 === "/") {
+    if (path4 === "/") {
       const results = [];
-      const defaultInfos = await this.default.lsInfo(path3);
+      const defaultInfos = await this.default.lsInfo(path4);
       results.push(...defaultInfos);
       for (const [routePrefix] of this.sortedRoutes) {
         results.push({
@@ -13754,7 +13815,7 @@ var CompositeBackend = class {
       results.sort((a, b) => a.path.localeCompare(b.path));
       return results;
     }
-    return await this.default.lsInfo(path3);
+    return await this.default.lsInfo(path4);
   }
   /**
    * Read file content, routing to appropriate backend.
@@ -13781,10 +13842,10 @@ var CompositeBackend = class {
   /**
    * Structured search results or error string for invalid input.
    */
-  async grepRaw(pattern, path3 = "/", glob = null) {
+  async grepRaw(pattern, path4 = "/", glob = null) {
     for (const [routePrefix, backend] of this.sortedRoutes) {
-      if (path3.startsWith(routePrefix.replace(/\/$/, ""))) {
-        const searchPath = path3.substring(routePrefix.length - 1);
+      if (path4.startsWith(routePrefix.replace(/\/$/, ""))) {
+        const searchPath = path4.substring(routePrefix.length - 1);
         const raw = await backend.grepRaw(pattern, searchPath || "/", glob);
         if (typeof raw === "string") {
           return raw;
@@ -13796,7 +13857,7 @@ var CompositeBackend = class {
       }
     }
     const allMatches = [];
-    const rawDefault = await this.default.grepRaw(pattern, path3, glob);
+    const rawDefault = await this.default.grepRaw(pattern, path4, glob);
     if (typeof rawDefault === "string") {
       return rawDefault;
     }
@@ -13818,11 +13879,11 @@ var CompositeBackend = class {
   /**
    * Structured glob matching returning FileInfo objects.
    */
-  async globInfo(pattern, path3 = "/") {
+  async globInfo(pattern, path4 = "/") {
     const results = [];
     for (const [routePrefix, backend] of this.sortedRoutes) {
-      if (path3.startsWith(routePrefix.replace(/\/$/, ""))) {
-        const searchPath = path3.substring(routePrefix.length - 1);
+      if (path4.startsWith(routePrefix.replace(/\/$/, ""))) {
+        const searchPath = path4.substring(routePrefix.length - 1);
         const infos = await backend.globInfo(pattern, searchPath || "/");
         return infos.map((fi) => ({
           ...fi,
@@ -13830,7 +13891,7 @@ var CompositeBackend = class {
         }));
       }
     }
-    const defaultInfos = await this.default.globInfo(pattern, path3);
+    const defaultInfos = await this.default.globInfo(pattern, path4);
     results.push(...defaultInfos);
     for (const [routePrefix, backend] of Object.entries(this.routes)) {
       const infos = await backend.globInfo(pattern, "/");
@@ -13878,11 +13939,11 @@ var MemoryBackend = class {
   getFiles() {
     return Object.fromEntries(this.files);
   }
-  lsInfo(path3) {
+  lsInfo(path4) {
     const files = this.getFiles();
     const infos = [];
     const subdirs = /* @__PURE__ */ new Set();
-    const normalizedPath = path3.endsWith("/") ? path3 : path3 + "/";
+    const normalizedPath = path4.endsWith("/") ? path4 : path4 + "/";
     for (const [k, fd] of Object.entries(files)) {
       if (!k.startsWith(normalizedPath)) {
         continue;
@@ -13957,13 +14018,13 @@ var MemoryBackend = class {
     this.files.set(filePath, newFileData);
     return { path: filePath, filesUpdate: null, occurrences };
   }
-  grepRaw(pattern, path3 = "/", glob = null) {
+  grepRaw(pattern, path4 = "/", glob = null) {
     const files = this.getFiles();
-    return grepMatchesFromFiles(files, pattern, path3, glob);
+    return grepMatchesFromFiles(files, pattern, path4, glob);
   }
-  globInfo(pattern, path3 = "/") {
+  globInfo(pattern, path4 = "/") {
     const files = this.getFiles();
-    const result = globSearchFiles(files, pattern, path3);
+    const result = globSearchFiles(files, pattern, path4);
     if (result === "No files found") {
       return [];
     }
@@ -18011,22 +18072,30 @@ var mcpManager = McpLatticeManager.getInstance();
 import { Sandbox } from "microsandbox";
 
 // src/sandbox_lattice/MicrosandboxInstance.ts
+function exec(native, cmd, opts) {
+  return native.execWith(cmd, (b) => {
+    if (opts?.args) b.args(opts.args);
+    if (opts?.cwd) b.cwd(opts.cwd);
+    if (opts?.timeoutMs) b.timeout(opts.timeoutMs);
+    return b;
+  });
+}
 var MicrosandboxInstance = class {
   constructor(name, native) {
     this.native = native;
     this.file = {
       readFile: async (file) => {
         const fs3 = this.native.fs();
-        const content = await fs3.readString(file);
+        const content = await fs3.readToString(file);
         return { content };
       },
       writeFile: async (file, content) => {
         const fs3 = this.native.fs();
         await fs3.write(file, Buffer.from(content));
       },
-      listPath: async (path3, options) => {
+      listPath: async (path4, options) => {
         const fs3 = this.native.fs();
-        const entries = await fs3.list(path3);
+        const entries = await fs3.list(path4);
         const files = (entries || []).map((e) => ({
           path: e.path,
           is_dir: e.kind === "directory",
@@ -18035,17 +18104,15 @@ var MicrosandboxInstance = class {
         }));
         return { files };
       },
-      findFiles: async (path3, glob) => {
-        const output = await this.native.execWithConfig({
-          cmd: "sh",
-          args: ["-c", `find "${path3}" -name "${glob}" -type f`]
+      findFiles: async (path4, glob) => {
+        const output = await exec(this.native, "sh", {
+          args: ["-c", `find "${path4}" -name "${glob}" -type f`]
         });
         const lines = output.stdout().split("\n").filter(Boolean);
         return { files: lines };
       },
       searchInFile: async (file, regex) => {
-        const output = await this.native.execWithConfig({
-          cmd: "grep",
+        const output = await exec(this.native, "grep", {
           args: ["-n", "-E", regex, file]
         });
         const lines = output.stdout().split("\n").filter(Boolean);
@@ -18062,14 +18129,13 @@ var MicrosandboxInstance = class {
         return { matches, line_numbers };
       },
       strReplaceEditor: async (params) => {
-        const { path: path3, old_str, new_str, replace_mode } = params;
+        const { path: path4, old_str, new_str, replace_mode } = params;
         const delim = "#";
         const escapedOld = old_str.replace(new RegExp(`[\\\\${delim}]`, "g"), "\\$&").replace(/\n/g, "\\n");
         const escapedNew = new_str.replace(new RegExp(`[\\\\${delim}]`, "g"), "\\$&").replace(/\n/g, "\\n");
         const flag = replace_mode === "ALL" ? "g" : "";
-        await this.native.execWithConfig({
-          cmd: "sh",
-          args: ["-c", `sed -i 's${delim}${escapedOld}${delim}${escapedNew}${delim}${flag}' "${path3}"`]
+        await exec(this.native, "sh", {
+          args: ["-c", `sed -i 's${delim}${escapedOld}${delim}${escapedNew}${delim}${flag}' "${path4}"`]
         });
       },
       uploadFile: async (params) => {
@@ -18084,8 +18150,7 @@ var MicrosandboxInstance = class {
     };
     this.shell = {
       execCommand: async (params) => {
-        const output = await this.native.execWithConfig({
-          cmd: "sh",
+        const output = await exec(this.native, "sh", {
           args: ["-c", params.command],
           cwd: params.exec_dir,
           timeoutMs: params.timeout ? params.timeout * 1e3 : void 0
@@ -18108,7 +18173,7 @@ var MicrosandboxInstance = class {
   }
   async getStatus() {
     try {
-      await this.native.execWithConfig({ cmd: "echo", args: ["ok"] });
+      await this.native.exec("echo", ["ok"]);
       return "running";
     } catch {
       return "unknown";
@@ -18135,7 +18200,7 @@ var MicrosandboxProvider = class {
     this.instances = /* @__PURE__ */ new Map();
     this.creating = /* @__PURE__ */ new Map();
   }
-  async createSandbox(name) {
+  async createSandbox(name, config) {
     const existing = this.instances.get(name);
     if (existing) {
       return existing;
@@ -18162,13 +18227,11 @@ var MicrosandboxProvider = class {
         native = void 0;
       }
       if (!native) {
-        native = await Sandbox.createDetached({
-          name,
-          image: this.config.image ?? "python:3.11-slim",
-          cpus: this.config.cpus ?? 1,
-          memoryMib: this.config.memoryMib ?? 512,
-          env: this.config.env
+        const builder = Sandbox.builder(name).image(this.config.image ?? "python:3.11-slim").cpus(this.config.cpus ?? 1).memory(this.config.memoryMib ?? 512).envs({
+          ...this.config.env,
+          ...buildSandboxMetadataEnv(config)
         });
+        native = await builder.createDetached();
       }
       const instance = new MicrosandboxInstance(name, native);
       this.instances.set(name, instance);
@@ -18208,31 +18271,92 @@ var MicrosandboxProvider = class {
   }
 };
 
+// src/sandbox_lattice/pathUtils.ts
+import path3 from "path";
+var SANDBOX_HOME_DIR = "/home/daytona";
+function normalizeExternalSandboxPath(inputPath) {
+  if (inputPath === "~") {
+    return "~/";
+  }
+  if (inputPath === SANDBOX_HOME_DIR) {
+    return "~/";
+  }
+  if (inputPath.startsWith(`${SANDBOX_HOME_DIR}/`)) {
+    return `~/${inputPath.slice(SANDBOX_HOME_DIR.length + 1)}`;
+  }
+  if (inputPath.startsWith("~/")) {
+    return inputPath;
+  }
+  if (inputPath.startsWith("/")) {
+    return `~${inputPath}`;
+  }
+  return inputPath;
+}
+function toSandboxRelativePath(inputPath) {
+  const canonicalPath = normalizeExternalSandboxPath(inputPath);
+  return canonicalPath === "~/" ? "" : canonicalPath.slice(2);
+}
+function toSandboxAbsolutePath(inputPath, homeDir = SANDBOX_HOME_DIR) {
+  const relativePath = toSandboxRelativePath(inputPath);
+  return relativePath ? path3.posix.join(homeDir, relativePath) : homeDir;
+}
+function fromSandboxExecutionPath(inputPath, homeDir = SANDBOX_HOME_DIR) {
+  if (inputPath === homeDir) {
+    return "~/";
+  }
+  if (inputPath.startsWith(`${homeDir}/`)) {
+    return `~/${inputPath.slice(homeDir.length + 1)}`;
+  }
+  return normalizeExternalSandboxPath(inputPath);
+}
+
 // src/sandbox_lattice/MicrosandboxRemoteInstance.ts
 var MicrosandboxRemoteInstance = class {
   constructor(name, client) {
     this.client = client;
     this.file = {
       readFile: async (file) => {
-        const result = await this.client.readFile(this.name, file);
+        const result = await this.client.readFile(
+          this.name,
+          toSandboxAbsolutePath(file, SANDBOX_HOME_DIR)
+        );
         return { content: result.content };
       },
       writeFile: async (file, content) => {
-        await this.client.writeFile(this.name, file, content);
+        await this.client.writeFile(
+          this.name,
+          toSandboxAbsolutePath(file, SANDBOX_HOME_DIR),
+          content
+        );
       },
-      listPath: async (path3, options) => {
-        const result = await this.client.listPath(this.name, path3, options?.recursive);
+      listPath: async (path4, options) => {
+        const result = await this.client.listPath(
+          this.name,
+          toSandboxAbsolutePath(path4, SANDBOX_HOME_DIR),
+          options?.recursive
+        );
         const files = result.entries.map((entry) => ({
-          path: entry.path,
-          is_dir: entry.type === "dir"
+          path: fromSandboxExecutionPath(entry.path, SANDBOX_HOME_DIR),
+          is_dir: entry.type === "directory"
         }));
         return { files };
       },
-      findFiles: async (path3, glob) => {
-        return this.client.findFiles(this.name, path3, glob);
+      findFiles: async (path4, glob) => {
+        const result = await this.client.findFiles(
+          this.name,
+          toSandboxAbsolutePath(path4, SANDBOX_HOME_DIR),
+          glob
+        );
+        return {
+          files: result.files.map((filePath) => fromSandboxExecutionPath(filePath, SANDBOX_HOME_DIR))
+        };
       },
       searchInFile: async (file, regex) => {
-        const result = await this.client.searchInFile(this.name, file, regex);
+        const result = await this.client.searchInFile(
+          this.name,
+          toSandboxAbsolutePath(file, SANDBOX_HOME_DIR),
+          regex
+        );
         return {
           matches: result.matches.map((match) => match.content),
           line_numbers: result.matches.map((match) => match.line)
@@ -18240,16 +18364,23 @@ var MicrosandboxRemoteInstance = class {
       },
       strReplaceEditor: async (params) => {
         await this.client.replaceInFile(this.name, {
-          path: params.path,
+          path: toSandboxAbsolutePath(params.path, SANDBOX_HOME_DIR),
           search: params.old_str,
           replace: params.new_str
         });
       },
       uploadFile: async (params) => {
-        await this.client.uploadFile(this.name, params.file, params.data);
+        await this.client.uploadFile(
+          this.name,
+          toSandboxAbsolutePath(params.file, SANDBOX_HOME_DIR),
+          params.data
+        );
       },
       downloadFile: async (params) => {
-        const result = await this.client.downloadFile(this.name, params.file);
+        const result = await this.client.downloadFile(
+          this.name,
+          toSandboxAbsolutePath(params.file, SANDBOX_HOME_DIR)
+        );
         if (result.contentBase64) {
           return Buffer.from(result.contentBase64, "base64");
         }
@@ -18294,6 +18425,7 @@ var MicrosandboxRemoteInstance = class {
 var MicrosandboxServiceClient = class {
   constructor(config) {
     this.baseURL = config.baseURL.replace(/\/$/, "");
+    this.apiKey = config.apiKey;
   }
   async ensureSandbox(name, input) {
     return this.request(`/api/sandboxes/${encodeURIComponent(name)}`, {
@@ -18326,34 +18458,34 @@ var MicrosandboxServiceClient = class {
       method: "GET"
     });
   }
-  async readFile(sandboxName, path3) {
+  async readFile(sandboxName, path4) {
     return this.request("/api/files/read", {
       method: "POST",
-      body: { sandboxName, path: path3 }
+      body: { sandboxName, path: path4 }
     });
   }
-  async writeFile(sandboxName, path3, content) {
+  async writeFile(sandboxName, path4, content) {
     return this.request("/api/files/write", {
       method: "POST",
-      body: { sandboxName, path: path3, content }
+      body: { sandboxName, path: path4, content }
     });
   }
-  async listPath(sandboxName, path3, recursive) {
+  async listPath(sandboxName, path4, recursive) {
     return this.request("/api/files/list", {
       method: "POST",
-      body: { sandboxName, path: path3, recursive }
+      body: { sandboxName, path: path4, recursive }
     });
   }
-  async findFiles(sandboxName, path3, pattern) {
+  async findFiles(sandboxName, path4, pattern) {
     return this.request("/api/files/find", {
       method: "POST",
-      body: { sandboxName, path: path3, pattern }
+      body: { sandboxName, path: path4, pattern }
     });
   }
-  async searchInFile(sandboxName, path3, query) {
+  async searchInFile(sandboxName, path4, query) {
     return this.request("/api/files/search", {
       method: "POST",
-      body: { sandboxName, path: path3, query }
+      body: { sandboxName, path: path4, query }
     });
   }
   async replaceInFile(sandboxName, input) {
@@ -18362,14 +18494,14 @@ var MicrosandboxServiceClient = class {
       body: { sandboxName, ...input }
     });
   }
-  async uploadFile(sandboxName, path3, content) {
+  async uploadFile(sandboxName, path4, content) {
     return this.request("/api/files/upload", {
       method: "POST",
-      body: { sandboxName, path: path3, contentBase64: content.toString("base64") }
+      body: { sandboxName, path: path4, contentBase64: content.toString("base64") }
     });
   }
-  async downloadFile(sandboxName, path3) {
-    const query = new URLSearchParams({ sandboxName, path: path3 });
+  async downloadFile(sandboxName, path4) {
+    const query = new URLSearchParams({ sandboxName, path: path4 });
     return this.request(`/api/files/download?${query.toString()}`, {
       method: "GET"
     });
@@ -18380,33 +18512,109 @@ var MicrosandboxServiceClient = class {
       body: input
     });
   }
-  async request(path3, init) {
-    const response = await fetch(`${this.baseURL}${path3}`, {
+  async volumeFsRead(volumeName, path4) {
+    const result = await this.request(
+      `/api/volumes/${encodeURIComponent(volumeName)}/fs/read`,
+      {
+        method: "POST",
+        body: { path: path4 }
+      }
+    );
+    return result.content;
+  }
+  async volumeFsWrite(volumeName, path4, content) {
+    await this.request(
+      `/api/volumes/${encodeURIComponent(volumeName)}/fs/write`,
+      {
+        method: "POST",
+        body: { path: path4, content }
+      }
+    );
+  }
+  async volumeFsList(volumeName, path4) {
+    const result = await this.request(
+      `/api/volumes/${encodeURIComponent(volumeName)}/fs/list`,
+      {
+        method: "POST",
+        body: { path: path4 }
+      }
+    );
+    return result.entries;
+  }
+  async volumeFsDownload(volumeName, path4) {
+    const result = await this.request(
+      `/api/volumes/${encodeURIComponent(volumeName)}/fs/download?path=${encodeURIComponent(path4)}`,
+      {
+        method: "GET"
+      }
+    );
+    return Buffer.from(result.contentBase64, "base64");
+  }
+  async volumeFsUpload(volumeName, path4, data) {
+    await this.request(
+      `/api/volumes/${encodeURIComponent(volumeName)}/fs/upload`,
+      {
+        method: "POST",
+        body: { path: path4, contentBase64: data.toString("base64") }
+      }
+    );
+  }
+  async request(path4, init) {
+    const headers = {};
+    if (init.body) {
+      headers["content-type"] = "application/json";
+    }
+    if (this.apiKey) {
+      headers.Authorization = `Bearer ${this.apiKey}`;
+    }
+    const response = await fetch(`${this.baseURL}${path4}`, {
       method: init.method,
-      headers: init.body ? { "content-type": "application/json" } : void 0,
+      headers: Object.keys(headers).length > 0 ? headers : void 0,
       body: init.body ? JSON.stringify(init.body) : void 0
     });
     if (!response.ok) {
       throw new Error(`Microsandbox service request failed: ${response.status} ${response.statusText}`);
     }
     const payload = await response.json();
+    if (payload?.success === false) {
+      throw new Error(`Microsandbox service request failed: ${payload.error ?? "unsuccessful response envelope"}`);
+    }
+    if (payload?.success !== true || !("data" in payload)) {
+      throw new Error("Microsandbox service returned an invalid success envelope");
+    }
     return payload.data;
   }
 };
 
 // src/sandbox_lattice/providers/MicrosandboxRemoteProvider.ts
-var defaultMicrosandboxRemoteConfig = {
-  image: process.env.MICROSANDBOX_IMAGE ?? "daytonaio/sandbox:0.6.0",
-  cpus: Number(process.env.MICROSANDBOX_CPUS ?? "1"),
-  memoryMib: Number(process.env.MICROSANDBOX_MEMORY ?? "512")
-};
+function parseOptionalNumberEnv(name, fallback) {
+  const rawValue = process.env[name];
+  if (rawValue === void 0) {
+    return fallback;
+  }
+  const parsedValue = Number(rawValue);
+  if (!Number.isFinite(parsedValue)) {
+    throw new Error(`Invalid ${name} environment value: ${rawValue}`);
+  }
+  return parsedValue;
+}
+function getDefaultMicrosandboxRemoteConfig() {
+  return {
+    image: process.env.MICROSANDBOX_IMAGE ?? "daytona-cn-shanghai.cr.volces.com/daytona/sandbox:0.0.2",
+    //"daytonaio/sandbox:0.6.0",
+    cpus: parseOptionalNumberEnv("MICROSANDBOX_CPUS", 1),
+    memoryMib: parseOptionalNumberEnv("MICROSANDBOX_MEMORY", 512),
+    user: "root"
+  };
+}
 var MicrosandboxRemoteProvider = class {
   constructor(config) {
     this.config = config;
     this.instances = /* @__PURE__ */ new Map();
     this.creating = /* @__PURE__ */ new Map();
     this.client = config.client ?? new MicrosandboxServiceClient({
-      baseURL: config.baseURL
+      baseURL: config.baseURL,
+      apiKey: config.apiKey ?? process.env.MICROSANDBOX_API_KEY
     });
   }
   async createSandbox(name, config) {
@@ -18425,9 +18633,14 @@ var MicrosandboxRemoteProvider = class {
       return instance;
     })();
     this.creating.set(name, creation);
-    creation.finally(() => {
-      this.creating.delete(name);
-    });
+    creation.then(
+      () => {
+        this.creating.delete(name);
+      },
+      () => {
+        this.creating.delete(name);
+      }
+    );
     return creation;
   }
   async getSandbox(name) {
@@ -18445,37 +18658,49 @@ var MicrosandboxRemoteProvider = class {
     await this.client.deleteSandbox(name);
     this.instances.delete(name);
   }
+  createVolumeFsClient(volumeName) {
+    return {
+      read: (path4) => this.client.volumeFsRead(volumeName, path4),
+      write: (path4, content) => this.client.volumeFsWrite(volumeName, path4, content),
+      list: (path4) => this.client.volumeFsList(volumeName, path4),
+      readRaw: (path4) => this.client.volumeFsDownload(volumeName, path4),
+      writeRaw: (path4, data) => this.client.volumeFsUpload(volumeName, path4, data)
+    };
+  }
   async listSandboxes() {
     return Array.from(this.instances.values());
   }
   buildEnsureInput(config) {
+    const defaultMicrosandboxRemoteConfig = getDefaultMicrosandboxRemoteConfig();
     return {
       image: this.config.image ?? defaultMicrosandboxRemoteConfig.image,
       cpus: this.config.cpus ?? defaultMicrosandboxRemoteConfig.cpus,
       memoryMib: this.config.memoryMib ?? defaultMicrosandboxRemoteConfig.memoryMib,
-      env: this.config.env,
+      env: {
+        ...this.config.env,
+        ...buildSandboxMetadataEnv(config)
+      },
       volumes: config?.volumes ?? this.buildDefaultVolumes(config)
     };
   }
   buildDefaultVolumes(config) {
     const tenantId = config?.tenantId ?? "default";
     const volumes = {
-      "/home/microsandbox/.agents/skills": {
+      "/home/daytona/.agents/skills": {
         type: "named",
-        name: `${tenantId}-skills`
+        name: buildNamedVolumeName("s", "skills", tenantId)
       }
     };
     if (config?.assistant_id) {
-      volumes["/home/microsandbox/agent"] = {
+      volumes["/home/daytona/agent"] = {
         type: "named",
-        name: `${tenantId}-agent-${config.assistant_id}`
+        name: buildNamedVolumeName("a", "agent", tenantId, config.assistant_id)
       };
     }
     if (config?.projectId) {
-      const projectVolumeName = config.workspaceId ? `${tenantId}-workspace-${config.workspaceId}-project-${config.projectId}` : `${tenantId}-project-${config.projectId}`;
-      volumes["/home/microsandbox/project"] = {
+      volumes["/home/daytona/project"] = {
         type: "named",
-        name: projectVolumeName
+        name: buildNamedVolumeName("p", "project", tenantId, config.workspaceId, config.projectId)
       };
     }
     return volumes;
@@ -18503,9 +18728,9 @@ var RemoteSandboxInstance = class {
           throw new Error(String(result.error));
         }
       },
-      listPath: async (path3, options) => {
+      listPath: async (path4, options) => {
         const result = await this.client.file.listPath({
-          path: path3,
+          path: path4,
           recursive: options?.recursive ?? false
         });
         if (!result.ok) {
@@ -18519,8 +18744,8 @@ var RemoteSandboxInstance = class {
         }));
         return { files };
       },
-      findFiles: async (path3, glob) => {
-        const result = await this.client.file.findFiles({ path: path3, glob });
+      findFiles: async (path4, glob) => {
+        const result = await this.client.file.findFiles({ path: path4, glob });
         if (!result.ok) {
           throw new Error(String(result.error));
         }
@@ -18657,8 +18882,8 @@ var E2BInstance = class {
       writeFile: async (file, content) => {
         await this.native.files.write(file, content);
       },
-      listPath: async (path3, options) => {
-        const entries = await this.native.files.list(path3);
+      listPath: async (path4, options) => {
+        const entries = await this.native.files.list(path4);
         const files = entries.map((e) => ({
           path: e.path,
           is_dir: e.type === "dir",
@@ -18667,9 +18892,9 @@ var E2BInstance = class {
         }));
         return { files };
       },
-      findFiles: async (path3, glob) => {
+      findFiles: async (path4, glob) => {
         const result = await this.native.commands.run(
-          `find "${path3}" -name "${glob}" -type f`
+          `find "${path4}" -name "${glob}" -type f`
         );
         const lines = result.stdout.split("\n").filter(Boolean);
         return { files: lines };
@@ -18692,13 +18917,13 @@ var E2BInstance = class {
         return { matches, line_numbers };
       },
       strReplaceEditor: async (params) => {
-        const { path: path3, old_str, new_str, replace_mode } = params;
+        const { path: path4, old_str, new_str, replace_mode } = params;
         const delim = "#";
         const escapedOld = old_str.replace(new RegExp(`[\\\\${delim}]`, "g"), "\\$&").replace(/\n/g, "\\n");
         const escapedNew = new_str.replace(new RegExp(`[\\\\${delim}]`, "g"), "\\$&").replace(/\n/g, "\\n");
         const flag = replace_mode === "ALL" ? "g" : "";
         await this.native.commands.run(
-          `sed -i 's${delim}${escapedOld}${delim}${escapedNew}${delim}${flag}' "${path3}"`
+          `sed -i 's${delim}${escapedOld}${delim}${escapedNew}${delim}${flag}' "${path4}"`
         );
       },
       uploadFile: async (params) => {
@@ -18814,26 +19039,18 @@ var DaytonaInstance = class {
     this.native = native;
     this.file = {
       readFile: async (file) => {
-        const buffer2 = await this.native.fs.downloadFile(this.toSandboxHomePath(file));
+        const buffer2 = await this.native.fs.downloadFile(toSandboxRelativePath(file));
         return { content: buffer2.toString("utf-8") };
       },
       writeFile: async (file, content) => {
-        await this.native.fs.uploadFile(Buffer.from(content, "utf-8"), this.toSandboxHomePath(file));
+        await this.native.fs.uploadFile(Buffer.from(content, "utf-8"), toSandboxRelativePath(file));
       },
-      listPath: async (path3, options) => {
-        const entries = await this.native.fs.listFiles(this.toSandboxHomePath(path3));
+      listPath: async (path4, options) => {
+        const entries = await this.native.fs.listFiles(toSandboxRelativePath(path4));
         const files = entries.map((e) => {
-          let name = e.name || "";
-          while (name.startsWith("~/") || name.startsWith("/")) {
-            if (name.startsWith("~/")) {
-              name = name.slice(2);
-            } else if (name.startsWith("/")) {
-              name = name.slice(1);
-            }
-          }
-          const fullPath = name ? `${path3}/${name}`.replace(/\/+/g, "/") : path3;
+          const rawPath = e.name || "";
           return {
-            path: fullPath,
+            path: fromSandboxExecutionPath(rawPath),
             is_dir: e.isDir ?? false,
             size: e.size,
             modified_at: e.modTime ? e.modTime : void 0
@@ -18841,12 +19058,12 @@ var DaytonaInstance = class {
         });
         return { files };
       },
-      findFiles: async (path3, glob) => {
-        const result = await this.native.fs.searchFiles(this.toSandboxHomePath(path3), glob);
-        return { files: result.files || [] };
+      findFiles: async (path4, glob) => {
+        const result = await this.native.fs.searchFiles(toSandboxRelativePath(path4), glob);
+        return { files: (result.files || []).map((filePath) => fromSandboxExecutionPath(filePath)) };
       },
       searchInFile: async (file, regex) => {
-        const matches = await this.native.fs.findFiles(this.toSandboxHomePath(file), regex);
+        const matches = await this.native.fs.findFiles(toSandboxRelativePath(file), regex);
         const line_numbers = [];
         const matchTexts = [];
         for (const match of matches) {
@@ -18856,8 +19073,8 @@ var DaytonaInstance = class {
         return { matches: matchTexts, line_numbers };
       },
       strReplaceEditor: async (params) => {
-        const { path: path3, old_str, new_str, replace_mode } = params;
-        const relPath = this.toSandboxHomePath(path3);
+        const { path: path4, old_str, new_str, replace_mode } = params;
+        const relPath = toSandboxRelativePath(path4);
         if (replace_mode === "ALL") {
           await this.native.fs.replaceInFiles([relPath], old_str, new_str);
         } else {
@@ -18871,10 +19088,10 @@ var DaytonaInstance = class {
         }
       },
       uploadFile: async (params) => {
-        await this.native.fs.uploadFile(params.data, this.toSandboxHomePath(params.file));
+        await this.native.fs.uploadFile(params.data, toSandboxRelativePath(params.file));
       },
       downloadFile: async (params) => {
-        const buffer2 = await this.native.fs.downloadFile(this.toSandboxHomePath(params.file));
+        const buffer2 = await this.native.fs.downloadFile(toSandboxRelativePath(params.file));
         return Buffer.isBuffer(buffer2) ? buffer2 : Buffer.from(buffer2);
       }
     };
@@ -18895,25 +19112,6 @@ var DaytonaInstance = class {
     };
     this.name = name;
   }
-  /**
-   * All sandbox file operations live under the user's home directory (~).
-   * The AI uses virtual paths like "~/agent/file.txt". Daytona SDK expects
-   * relative paths for file operations (they are resolved against ~ automatically),
-   * so we strip the leading "~/" or "/" here.
-   * 
-   * Handles edge cases like "~/~/agent/file.txt" by repeatedly stripping prefixes.
-   */
-  toSandboxHomePath(path3) {
-    let result = path3;
-    while (result.startsWith("~/") || result.startsWith("/")) {
-      if (result.startsWith("~/")) {
-        result = result.slice(2);
-      } else if (result.startsWith("/")) {
-        result = result.slice(1);
-      }
-    }
-    return result;
-  }
   async start() {
     await this.native.start();
   }
@@ -19254,7 +19452,6 @@ function clearEncryptionKeyCache() {
 export {
   AGENT_TASK_EVENT,
   Agent,
-  AgentConfig,
   AgentInstanceManager,
   AgentLatticeManager,
   AgentManager,
@@ -19273,7 +19470,6 @@ export {
   EmbeddingsLatticeManager,
   FileSystemSkillStore,
   FilesystemBackend,
-  GraphBuildOptions,
   HumanMessage3 as HumanMessage,
   InMemoryAssistantStore,
   InMemoryChunkBuffer,
@@ -19327,9 +19523,12 @@ export {
   ThreadStatus2 as ThreadStatus,
   ToolLatticeManager,
   VectorStoreLatticeManager,
+  VolumeFilesystem,
   agentInstanceManager,
   agentLatticeManager,
   buildGrepResultsDict,
+  buildNamedVolumeName,
+  buildSandboxMetadataEnv,
   buildSkillFile,
   checkEmptyContent,
   clearEncryptionKeyCache,