@axiom-lattice/gateway 2.1.21 → 2.1.23

package/dist/index.mjs

@@ -1,7 +1,9 @@
 // src/index.ts
 import fastify from "fastify";
 import cors from "@fastify/cors";
+import multipart from "@fastify/multipart";
 import sensible from "@fastify/sensible";
+import websocket from "@fastify/websocket";
 
 // src/services/agent_service.ts
 import {
@@ -46,7 +48,11 @@ async function agent_invoke({
   if (!runnable_agent) {
     throw new Error(`Agent ${assistant_id} not found`);
   }
-  const runConfig = agentLattice?.config?.runConfig || {};
+  const runConfig = {
+    ...agentLattice?.config?.runConfig || {},
+    assistant_id,
+    sandboxConfig: agentLattice?.config?.connectedSandbox
+  };
   const result = await runnable_agent.invoke(
     command ? new Command(command) : { ...rest, messages, "x-tenant-id": tenant_id },
     {
@@ -56,6 +62,7 @@ async function agent_invoke({
         "x-tenant-id": tenant_id,
         "x-request-id": run_id,
         "x-thread-id": thread_id,
+        "x-assistant-id": assistant_id,
         runConfig
         // Inject runConfig for tools to access
       },
@@ -88,7 +95,11 @@ async function agent_stream({
     messages = [humanMessage];
   }
   const chunkBuffer = getOrCreateChunkBuffer();
-  const runConfig = agentLattice?.config?.runConfig || {};
+  const runConfig = {
+    ...agentLattice?.config?.runConfig || {},
+    assistant_id,
+    sandboxConfig: agentLattice?.config?.connectedSandbox
+  };
   try {
     if (!runnable_agent) {
       throw new Error(`Agent ${assistant_id} not found`);
@@ -106,6 +117,7 @@ async function agent_stream({
           "x-tenant-id": tenant_id,
           "x-request-id": run_id,
           "x-thread-id": thread_id,
+          "x-assistant-id": assistant_id,
           runConfig
           // Inject runConfig for tools to access
         },
@@ -1624,6 +1636,88 @@ async function filterSkillsByLicense(request, reply) {
   }
 }
 
+// src/controllers/tools.ts
+import { getStoreLattice as getStoreLattice4, toolLatticeManager } from "@axiom-lattice/core";
+function serializeSchema(schema) {
+  if (!schema) {
+    return void 0;
+  }
+  try {
+    if (schema._def) {
+      const def = schema._def;
+      if (def.typeName === "ZodObject") {
+        const shape = def.shape();
+        const properties = {};
+        const required = [];
+        for (const [key, value] of Object.entries(shape)) {
+          const fieldDef = value._def;
+          if (fieldDef) {
+            properties[key] = {
+              type: fieldDef.typeName === "ZodString" ? "string" : fieldDef.typeName === "ZodNumber" ? "number" : fieldDef.typeName === "ZodBoolean" ? "boolean" : fieldDef.typeName === "ZodArray" ? "array" : fieldDef.typeName === "ZodObject" ? "object" : "unknown",
+              description: fieldDef.description
+            };
+            if (!value.isOptional()) {
+              required.push(key);
+            }
+          }
+        }
+        return {
+          type: "object",
+          properties,
+          required: required.length > 0 ? required : void 0
+        };
+      }
+    }
+    return {
+      type: "object",
+      description: schema.description || "Schema definition"
+    };
+  } catch (error) {
+    return {
+      type: "object",
+      description: "Schema definition"
+    };
+  }
+}
+async function getToolConfigs(request, reply) {
+  try {
+    const allLattices = toolLatticeManager.getAllLattices();
+    const toolConfigs = allLattices.map((lattice) => {
+      const config = { ...lattice.config };
+      const serializedSchema = config.schema ? serializeSchema(config.schema) : void 0;
+      return {
+        id: lattice.key,
+        name: config.name,
+        description: config.description,
+        schema: serializedSchema,
+        returnDirect: config.returnDirect,
+        needUserApprove: config.needUserApprove
+      };
+    });
+    return reply.send({
+      success: true,
+      message: "Successfully retrieved tool configs",
+      data: {
+        records: toolConfigs,
+        total: toolConfigs.length
+      }
+    });
+  } catch (error) {
+    console.error("Failed to get tool configs", {
+      error: error.message,
+      stack: error.stack
+    });
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to retrieve tool configs: ${error.message}`,
+      data: {
+        records: [],
+        total: 0
+      }
+    });
+  }
+}
+
 // src/schemas/index.ts
 var getAllMemoryItemsSchema = {
   description: "Get all memory items for an assistant thread",
@@ -1895,6 +1989,332 @@ var getHealthSchema = {
   }
 };
 
+// src/controllers/sandbox.ts
+import { Readable } from "stream";
+
+// src/services/sandbox_service.ts
+import { getAgentConfig, getAgentLattice as getAgentLattice2, getSandBoxManager, normalizeSandboxName } from "@axiom-lattice/core";
+var ERROR_HTML = `<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Sandbox \u8FDE\u63A5\u9519\u8BEF</title>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      padding: 20px;
+    }
+    .container {
+      background: white;
+      border-radius: 16px;
+      padding: 40px;
+      max-width: 500px;
+      width: 100%;
+      box-shadow: 0 20px 60px rgba(0,0,0,0.3);
+    }
+    .error-icon {
+      width: 80px;
+      height: 80px;
+      background: #fee2e2;
+      border-radius: 50%;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      margin: 0 auto 24px;
+    }
+    .error-icon svg {
+      width: 40px;
+      height: 40px;
+      color: #dc2626;
+    }
+    h1 { color: #1f2937; margin-bottom: 16px; text-align: center; }
+    p { color: #6b7280; margin-bottom: 12px; line-height: 1.6; }
+    .info {
+      background: #f3f4f6;
+      border-radius: 8px;
+      padding: 16px;
+      margin: 20px 0;
+    }
+    .info-item {
+      display: flex;
+      justify-content: space-between;
+      padding: 8px 0;
+      border-bottom: 1px solid #e5e7eb;
+    }
+    .info-item:last-child { border-bottom: none; }
+    .label { color: #6b7280; font-size: 14px; }
+    .value { color: #1f2937; font-weight: 500; font-family: monospace; }
+    .retry-btn {
+      width: 100%;
+      padding: 14px;
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      color: white;
+      border: none;
+      border-radius: 8px;
+      font-size: 16px;
+      cursor: pointer;
+      transition: transform 0.2s;
+    }
+    .retry-btn:hover { transform: translateY(-2px); }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="error-icon">
+      <svg fill="none" stroke="currentColor" viewBox="0 0 24 24">
+        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z"/>
+      </svg>
+    </div>
+    <h1>\u65E0\u6CD5\u8FDE\u63A5\u5230 Sandbox</h1>
+    <p>\u65E0\u6CD5\u8FDE\u63A5\u5230\u6C99\u7BB1\u73AF\u5883\uFF0C\u8BF7\u68C0\u67E5\u914D\u7F6E\u540E\u91CD\u8BD5\u3002</p>
+    <div class="info">
+      <div class="info-item">
+        <span class="label">Assistant ID</span>
+        <span class="value" id="assistantId">-</span>
+      </div>
+      <div class="info-item">
+        <span class="label">Thread ID</span>
+        <span class="value" id="threadId">-</span>
+      </div>
+      <div class="info-item">
+        <span class="label">\u9694\u79BB\u7EA7\u522B</span>
+        <span class="value" id="isolatedLevel">-</span>
+      </div>
+      <div class="info-item">
+        <span class="label">\u9519\u8BEF\u4FE1\u606F</span>
+        <span class="value" id="errorMsg">-</span>
+      </div>
+    </div>
+    <button class="retry-btn" onclick="window.location.reload()">\u91CD\u65B0\u8FDE\u63A5</button>
+  </div>
+  <script>
+    const params = new URLSearchParams(window.location.search);
+    document.getElementById('assistantId').textContent = params.get('assistantId') || '-';
+    document.getElementById('threadId').textContent = params.get('threadId') || '-';
+    document.getElementById('isolatedLevel').textContent = params.get('isolatedLevel') || '-';
+    document.getElementById('errorMsg').textContent = params.get('error') || '\u672A\u77E5\u9519\u8BEF';
+  </script>
+</body>
+</html>`;
+var SandboxService = class {
+  getSandboxConfig(assistantId) {
+    const agentConfig = getAgentConfig(assistantId);
+    if (!agentConfig) {
+      return null;
+    }
+    const agentLattice = getAgentLattice2(assistantId);
+    return agentLattice?.config?.connectedSandbox || null;
+  }
+  computeSandboxName(assistantId, threadId, isolatedLevel) {
+    let sandboxName;
+    switch (isolatedLevel) {
+      case "agent":
+        sandboxName = assistantId;
+        break;
+      case "thread":
+        sandboxName = threadId;
+        break;
+      case "global":
+      default:
+        sandboxName = "global";
+        break;
+    }
+    return normalizeSandboxName(sandboxName);
+  }
+  getTargetUrl(sandboxName) {
+    const sandboxManager = getSandBoxManager("default");
+    return `${sandboxManager.getBaseURL()}/sandbox/${sandboxName}`;
+  }
+  async getVncHtml(sandboxName) {
+    const response = await fetch(`${this.getTargetUrl(sandboxName)}/vnc/index.html`);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch VNC HTML: ${response.statusText}`);
+    }
+    return response.text();
+  }
+  rewriteHtml(html, assistantId, threadId) {
+    const prefix = `/api/assistants/${assistantId}/threads/${threadId}/sandbox/vnc`;
+    let rewritten = html;
+    rewritten = rewritten.replace(
+      /(src|href)=["']([^"']*)["']/g,
+      (match, attr, url) => {
+        if (url.startsWith("http://") || url.startsWith("https://") || url.startsWith("//")) {
+          return match;
+        }
+        const rewrittenUrl = url.startsWith("/") ? `${prefix}${url}` : `${prefix}/${url}`;
+        return `${attr}="${rewrittenUrl}"`;
+      }
+    );
+    rewritten = rewritten.replace(
+      /path=sandbox\/[^&"']+/g,
+      (match) => {
+        return `path=${prefix}/websockify`;
+      }
+    );
+    rewritten = rewritten.replace(
+      /new WebSocket\([^)]*\?path=sandbox[^)]*\)/g,
+      (match) => {
+        return match.replace(/path=sandbox[^)]+/, `path=${prefix}/websockify`);
+      }
+    );
+    return rewritten;
+  }
+  generateErrorHtml(assistantId, threadId, isolatedLevel, errorMessage) {
+    const encodedError = encodeURIComponent(errorMessage);
+    return ERROR_HTML.replace("{assistantId}", assistantId).replace("{threadId}", threadId).replace("{isolatedLevel}", isolatedLevel).replace("{errorMessage}", errorMessage);
+  }
+};
+var sandboxService = new SandboxService();
+
+// src/controllers/sandbox.ts
+import { getSandBoxManager as getSandBoxManager2 } from "@axiom-lattice/core";
+function getFilenameFromPath(path) {
+  const segments = path.replace(/\/+$/, "").split("/");
+  return segments[segments.length - 1] || "download";
+}
+var EXT_TO_MIME = {
+  ".txt": "text/plain",
+  ".html": "text/html",
+  ".css": "text/css",
+  ".js": "application/javascript",
+  ".json": "application/json",
+  ".pdf": "application/pdf",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".zip": "application/zip",
+  ".csv": "text/csv",
+  ".xml": "application/xml"
+};
+function getContentTypeFromFilename(filename) {
+  const ext = filename.includes(".") ? filename.slice(filename.lastIndexOf(".")).toLowerCase() : "";
+  return EXT_TO_MIME[ext] ?? "application/octet-stream";
+}
+function registerSandboxProxyRoutes(app2) {
+  app2.post(
+    "/api/assistants/:assistantId/threads/:threadId/sandbox/uploadfile",
+    async (request, reply) => {
+      console.log("[Sandbox Upload] Route matched:", request.url);
+      const { assistantId, threadId } = request.params;
+      const sandboxConfig = sandboxService.getSandboxConfig(assistantId);
+      if (!sandboxConfig) {
+        return reply.status(500).send({ error: "Assistant sandbox config not found" });
+      }
+      const { isolatedLevel } = sandboxConfig;
+      const sandboxName = sandboxService.computeSandboxName(
+        assistantId,
+        threadId,
+        isolatedLevel
+      );
+      const sandboxManager = getSandBoxManager2("default");
+      const sandbox = await sandboxManager.createSandbox(sandboxName);
+      try {
+        const data = await request.file();
+        if (!data) {
+          return reply.status(400).send({ error: "No file in request" });
+        }
+        const buffer = await data.toBuffer();
+        const pathEntry = data.fields?.path;
+        const pathValue = pathEntry && typeof pathEntry === "object" && "value" in pathEntry ? String(pathEntry.value) : typeof pathEntry === "string" ? pathEntry : void 0;
+        const formData = new FormData();
+        formData.append("file", new Blob([buffer]), data.filename ?? "file");
+        const path = `/home/gem/uploads/${pathValue ? pathValue : ""}${data.filename}`;
+        const uploadResult = await sandbox.file.uploadFile({
+          file: buffer,
+          path
+        });
+        if (!uploadResult.ok) {
+          return reply.status(502).send({ error: `Upload error: ${uploadResult.error}` });
+        }
+        const relativePath = uploadResult.body?.data?.file_path.replace(`/home/gem`, "");
+        const result = { id: relativePath, name: data.filename, size: buffer.length };
+        return reply.status(200).send({ message: "File uploaded successfully", ...result });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return reply.status(502).send({ error: `Upload proxy error: ${message}` });
+      }
+    }
+  );
+  app2.get(
+    "/api/assistants/:assistantId/threads/:threadId/sandbox/downloadfile",
+    async (request, reply) => {
+      const { assistantId, threadId } = request.params;
+      const { path: filePath } = request.query;
+      if (!filePath || typeof filePath !== "string") {
+        return reply.status(400).send({ error: "Query parameter 'path' is required" });
+      }
+      const sandboxConfig = sandboxService.getSandboxConfig(assistantId);
+      if (!sandboxConfig) {
+        return reply.status(404).send({ error: "Assistant sandbox config not found" });
+      }
+      const { isolatedLevel } = sandboxConfig;
+      const sandboxName = sandboxService.computeSandboxName(
+        assistantId,
+        threadId,
+        isolatedLevel
+      );
+      const sandboxManager = getSandBoxManager2("default");
+      const sandbox = await sandboxManager.createSandbox(sandboxName);
+      try {
+        const resolvedPath = filePath.startsWith("/home/gem") ? filePath : `/home/gem/${filePath.replace(/^\//, "")}`;
+        const filename = getFilenameFromPath(resolvedPath);
+        const inferredContentType = getContentTypeFromFilename(filename);
+        const downloadResult = await sandbox.file.downloadFile({
+          path: resolvedPath
+        });
+        if (!downloadResult.ok) {
+          return reply.status(502).send({
+            error: `Download error: ${JSON.stringify(downloadResult.error)}`
+          });
+        }
+        const body = downloadResult.body;
+        if (typeof body?.stream === "function") {
+          const webStream = body.stream();
+          const nodeStream = Readable.fromWeb(webStream);
+          const contentType2 = body.contentType ?? inferredContentType;
+          const contentDisposition2 = body.contentDisposition ?? `inline; filename="${filename.replace(/"/g, '\\"')}"; filename*=UTF-8''${encodeURIComponent(filename)}`;
+          reply = reply.status(200).type(contentType2).header("Content-Disposition", contentDisposition2).send(nodeStream);
+          return reply;
+        }
+        const bodyUnknown = downloadResult.body;
+        let buf;
+        let contentType = inferredContentType;
+        let contentDisposition = `inline; filename="${filename.replace(/"/g, '\\"')}"; filename*=UTF-8''${encodeURIComponent(filename)}`;
+        if (bodyUnknown instanceof ArrayBuffer) {
+          buf = Buffer.from(bodyUnknown);
+        } else if (bodyUnknown instanceof Buffer) {
+          buf = bodyUnknown;
+        } else if (bodyUnknown && typeof bodyUnknown.arrayBuffer === "function") {
+          const res = bodyUnknown;
+          buf = Buffer.from(await res.arrayBuffer());
+          if (res.headers?.get("content-type")) contentType = res.headers.get("content-type");
+          if (res.headers?.get("content-disposition")) contentDisposition = res.headers.get("content-disposition");
+        } else if (bodyUnknown && typeof bodyUnknown.blob === "function") {
+          const blob = await bodyUnknown.blob();
+          buf = Buffer.from(await blob.arrayBuffer());
+        } else {
+          return reply.status(502).send({ error: "Unexpected download response format" });
+        }
+        reply = reply.status(200).type(contentType).header("Content-Disposition", contentDisposition).send(buf);
+        return reply;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return reply.status(502).send({ error: `Download proxy error: ${message}` });
+      }
+    }
+  );
+}
+
 // src/routes/index.ts
 var registerLatticeRoutes = (app2) => {
   app2.post("/api/runs", createRun);
@@ -1970,6 +2390,7 @@ var registerLatticeRoutes = (app2) => {
   );
   app2.get("/api/models", getModels);
   app2.put("/api/models", updateModels);
+  app2.get("/api/tools", getToolConfigs);
   app2.get(
     "/health",
     { schema: getHealthSchema },
@@ -2012,6 +2433,7 @@ var registerLatticeRoutes = (app2) => {
     "/api/skills/filter/license",
     filterSkillsByLicense
   );
+  registerSandboxProxyRoutes(app2);
 };
 
 // src/swagger.ts
@@ -2430,12 +2852,20 @@ app.register(cors, {
     "Authorization",
     "X-Requested-With",
     "x-tenant-id",
-    "x-request-id"
+    "x-request-id",
+    "x-assistant-id",
+    "x-thread-id"
   ],
   exposedHeaders: ["Content-Type"],
   credentials: true
 });
 app.register(sensible);
+app.register(multipart, {
+  limits: {
+    fileSize: Number(process.env.BODY_LIMIT) || 50 * 1024 * 1024
+  }
+});
+app.register(websocket);
 app.setErrorHandler((error, request, reply) => {
   const getHeaderValue = (header) => {
     if (Array.isArray(header)) {