@axiom-lattice/core 2.1.51 → 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,
@@ -18019,13 +18072,21 @@ 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) => {
@@ -18044,16 +18105,14 @@ var MicrosandboxInstance = class {
         return { files };
       },
       findFiles: async (path4, glob) => {
-        const output = await this.native.execWithConfig({
-          cmd: "sh",
+        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);
@@ -18075,8 +18134,7 @@ var MicrosandboxInstance = class {
         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",
+        await exec(this.native, "sh", {
           args: ["-c", `sed -i 's${delim}${escapedOld}${delim}${escapedNew}${delim}${flag}' "${path4}"`]
         });
       },
@@ -18092,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
@@ -18116,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";
@@ -18143,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;
@@ -18170,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);
@@ -18218,30 +18273,42 @@ var MicrosandboxProvider = class {
 
 // src/sandbox_lattice/pathUtils.ts
 import path3 from "path";
-function isVirtualSandboxPath(inputPath) {
-  return inputPath === "~" || inputPath.startsWith("~/") || inputPath.startsWith("/");
-}
-function toSandboxHomePath(inputPath, options = {}) {
-  const { homeDir = "/home/daytona", absolute = false } = options;
-  if (!isVirtualSandboxPath(inputPath)) {
-    return inputPath;
+var SANDBOX_HOME_DIR = "/home/daytona";
+function normalizeExternalSandboxPath(inputPath) {
+  if (inputPath === "~") {
+    return "~/";
   }
-  let relativePath = inputPath;
-  while (relativePath.startsWith("~/") || relativePath.startsWith("/")) {
-    if (relativePath.startsWith("~/")) {
-      relativePath = relativePath.slice(2);
-    } else {
-      relativePath = relativePath.slice(1);
-    }
+  if (inputPath === SANDBOX_HOME_DIR) {
+    return "~/";
   }
-  if (relativePath === "~") {
-    relativePath = "";
+  if (inputPath.startsWith(`${SANDBOX_HOME_DIR}/`)) {
+    return `~/${inputPath.slice(SANDBOX_HOME_DIR.length + 1)}`;
   }
-  if (!absolute) {
-    return relativePath;
+  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 {
@@ -18251,40 +18318,43 @@ var MicrosandboxRemoteInstance = class {
       readFile: async (file) => {
         const result = await this.client.readFile(
           this.name,
-          toSandboxHomePath(file, { absolute: true, homeDir: "/home/daytona" })
+          toSandboxAbsolutePath(file, SANDBOX_HOME_DIR)
         );
         return { content: result.content };
       },
       writeFile: async (file, content) => {
         await this.client.writeFile(
           this.name,
-          toSandboxHomePath(file, { absolute: true, homeDir: "/home/daytona" }),
+          toSandboxAbsolutePath(file, SANDBOX_HOME_DIR),
           content
         );
       },
       listPath: async (path4, options) => {
         const result = await this.client.listPath(
           this.name,
-          toSandboxHomePath(path4, { absolute: true, homeDir: "/home/daytona" }),
+          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 (path4, glob) => {
-        return this.client.findFiles(
+        const result = await this.client.findFiles(
           this.name,
-          toSandboxHomePath(path4, { absolute: true, homeDir: "/home/daytona" }),
+          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,
-          toSandboxHomePath(file, { absolute: true, homeDir: "/home/daytona" }),
+          toSandboxAbsolutePath(file, SANDBOX_HOME_DIR),
           regex
         );
         return {
@@ -18294,7 +18364,7 @@ var MicrosandboxRemoteInstance = class {
       },
       strReplaceEditor: async (params) => {
         await this.client.replaceInFile(this.name, {
-          path: toSandboxHomePath(params.path, { absolute: true, homeDir: "/home/daytona" }),
+          path: toSandboxAbsolutePath(params.path, SANDBOX_HOME_DIR),
           search: params.old_str,
           replace: params.new_str
         });
@@ -18302,14 +18372,14 @@ var MicrosandboxRemoteInstance = class {
       uploadFile: async (params) => {
         await this.client.uploadFile(
           this.name,
-          toSandboxHomePath(params.file, { absolute: true, homeDir: "/home/daytona" }),
+          toSandboxAbsolutePath(params.file, SANDBOX_HOME_DIR),
           params.data
         );
       },
       downloadFile: async (params) => {
         const result = await this.client.downloadFile(
           this.name,
-          toSandboxHomePath(params.file, { absolute: true, homeDir: "/home/daytona" })
+          toSandboxAbsolutePath(params.file, SANDBOX_HOME_DIR)
         );
         if (result.contentBase64) {
           return Buffer.from(result.contentBase64, "base64");
@@ -18442,6 +18512,53 @@ var MicrosandboxServiceClient = class {
       body: input
     });
   }
+  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) {
@@ -18483,9 +18600,11 @@ function parseOptionalNumberEnv(name, fallback) {
 }
 function getDefaultMicrosandboxRemoteConfig() {
   return {
-    image: process.env.MICROSANDBOX_IMAGE ?? "daytonaio/sandbox:0.6.0",
+    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)
+    memoryMib: parseOptionalNumberEnv("MICROSANDBOX_MEMORY", 512),
+    user: "root"
   };
 }
 var MicrosandboxRemoteProvider = class {
@@ -18539,6 +18658,15 @@ 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());
   }
@@ -18548,7 +18676,10 @@ var MicrosandboxRemoteProvider = class {
       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)
     };
   }
@@ -18557,20 +18688,19 @@ var MicrosandboxRemoteProvider = class {
     const volumes = {
       "/home/daytona/.agents/skills": {
         type: "named",
-        name: `${tenantId}-skills`
+        name: buildNamedVolumeName("s", "skills", tenantId)
       }
     };
     if (config?.assistant_id) {
       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/daytona/project"] = {
         type: "named",
-        name: projectVolumeName
+        name: buildNamedVolumeName("p", "project", tenantId, config.workspaceId, config.projectId)
       };
     }
     return volumes;
@@ -18909,26 +19039,18 @@ var DaytonaInstance = class {
     this.native = native;
     this.file = {
       readFile: async (file) => {
-        const buffer2 = await this.native.fs.downloadFile(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"), toSandboxHomePath(file));
+        await this.native.fs.uploadFile(Buffer.from(content, "utf-8"), toSandboxRelativePath(file));
       },
       listPath: async (path4, options) => {
-        const entries = await this.native.fs.listFiles(toSandboxHomePath(path4));
+        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 ? `${path4}/${name}`.replace(/\/+/g, "/") : path4;
+          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
@@ -18937,11 +19059,11 @@ var DaytonaInstance = class {
         return { files };
       },
       findFiles: async (path4, glob) => {
-        const result = await this.native.fs.searchFiles(toSandboxHomePath(path4), glob);
-        return { files: result.files || [] };
+        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(toSandboxHomePath(file), regex);
+        const matches = await this.native.fs.findFiles(toSandboxRelativePath(file), regex);
         const line_numbers = [];
         const matchTexts = [];
         for (const match of matches) {
@@ -18952,7 +19074,7 @@ var DaytonaInstance = class {
       },
       strReplaceEditor: async (params) => {
         const { path: path4, old_str, new_str, replace_mode } = params;
-        const relPath = toSandboxHomePath(path4);
+        const relPath = toSandboxRelativePath(path4);
         if (replace_mode === "ALL") {
           await this.native.fs.replaceInFiles([relPath], old_str, new_str);
         } else {
@@ -18966,10 +19088,10 @@ var DaytonaInstance = class {
         }
       },
       uploadFile: async (params) => {
-        await this.native.fs.uploadFile(params.data, toSandboxHomePath(params.file));
+        await this.native.fs.uploadFile(params.data, toSandboxRelativePath(params.file));
       },
       downloadFile: async (params) => {
-        const buffer2 = await this.native.fs.downloadFile(toSandboxHomePath(params.file));
+        const buffer2 = await this.native.fs.downloadFile(toSandboxRelativePath(params.file));
         return Buffer.isBuffer(buffer2) ? buffer2 : Buffer.from(buffer2);
       }
     };
@@ -19330,7 +19452,6 @@ function clearEncryptionKeyCache() {
 export {
   AGENT_TASK_EVENT,
   Agent,
-  AgentConfig,
   AgentInstanceManager,
   AgentLatticeManager,
   AgentManager,
@@ -19349,7 +19470,6 @@ export {
   EmbeddingsLatticeManager,
   FileSystemSkillStore,
   FilesystemBackend,
-  GraphBuildOptions,
   HumanMessage3 as HumanMessage,
   InMemoryAssistantStore,
   InMemoryChunkBuffer,
@@ -19403,9 +19523,12 @@ export {
   ThreadStatus2 as ThreadStatus,
   ToolLatticeManager,
   VectorStoreLatticeManager,
+  VolumeFilesystem,
   agentInstanceManager,
   agentLatticeManager,
   buildGrepResultsDict,
+  buildNamedVolumeName,
+  buildSandboxMetadataEnv,
   buildSkillFile,
   checkEmptyContent,
   clearEncryptionKeyCache,