@axiom-lattice/gateway 2.1.20 → 2.1.22

package/dist/index.mjs

@@ -2,6 +2,7 @@
 import fastify from "fastify";
 import cors from "@fastify/cors";
 import sensible from "@fastify/sensible";
+import websocket from "@fastify/websocket";
 
 // src/services/agent_service.ts
 import {
@@ -46,7 +47,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 },
     {
@@ -88,7 +93,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`);
@@ -1319,6 +1328,393 @@ async function getHealth(request, reply) {
   }
 }
 
+// src/controllers/skills.ts
+import { getStoreLattice as getStoreLattice3 } from "@axiom-lattice/core";
+import { validateSkillName } from "@axiom-lattice/core";
+function serializeSkill(skill) {
+  const serialized = {
+    id: skill.id,
+    name: skill.name,
+    description: skill.description,
+    license: skill.license,
+    compatibility: skill.compatibility,
+    metadata: skill.metadata || {},
+    content: skill.content,
+    subSkills: skill.subSkills,
+    createdAt: skill.createdAt instanceof Date ? skill.createdAt.toISOString() : skill.createdAt ? new Date(skill.createdAt).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: skill.updatedAt instanceof Date ? skill.updatedAt.toISOString() : skill.updatedAt ? new Date(skill.updatedAt).toISOString() : (/* @__PURE__ */ new Date()).toISOString()
+  };
+  Object.keys(serialized).forEach((key) => {
+    if (serialized[key] === void 0) {
+      delete serialized[key];
+    }
+  });
+  return serialized;
+}
+async function getSkillList(request, reply) {
+  try {
+    const storeLattice = getStoreLattice3("default", "skill");
+    const skillStore = storeLattice.store;
+    const skills = await skillStore.getAllSkills();
+    const serializedSkills = skills.map(serializeSkill);
+    return {
+      success: true,
+      message: "Successfully retrieved skill list",
+      data: {
+        records: serializedSkills,
+        total: serializedSkills.length
+      }
+    };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to retrieve skills: ${error.message}`,
+      data: {
+        records: [],
+        total: 0
+      }
+    });
+  }
+}
+async function getSkill(request, reply) {
+  try {
+    const { id } = request.params;
+    const storeLattice = getStoreLattice3("default", "skill");
+    const skillStore = storeLattice.store;
+    const skill = await skillStore.getSkillById(id);
+    if (!skill) {
+      return reply.status(404).send({
+        success: false,
+        message: "Skill not found"
+      });
+    }
+    return {
+      success: true,
+      message: "Successfully retrieved skill",
+      data: serializeSkill(skill)
+    };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to retrieve skill: ${error.message}`
+    });
+  }
+}
+async function createSkill(request, reply) {
+  try {
+    const data = request.body;
+    if (!data.name) {
+      return reply.status(400).send({
+        success: false,
+        message: "name is required"
+      });
+    }
+    if (!data.description) {
+      return reply.status(400).send({
+        success: false,
+        message: "description is required"
+      });
+    }
+    try {
+      validateSkillName(data.name);
+    } catch (error) {
+      return reply.status(400).send({
+        success: false,
+        message: error.message || "Invalid skill name format"
+      });
+    }
+    const id = request.body.id || data.name;
+    if (id !== data.name) {
+      return reply.status(400).send({
+        success: false,
+        message: `id "${id}" must equal name "${data.name}" (name is used for path addressing)`
+      });
+    }
+    const storeLattice = getStoreLattice3("default", "skill");
+    const skillStore = storeLattice.store;
+    const exists = await skillStore.hasSkill(id);
+    if (exists) {
+      return reply.status(409).send({
+        success: false,
+        message: `Skill with id "${id}" already exists`
+      });
+    }
+    const newSkill = await skillStore.createSkill(id, data);
+    return reply.status(201).send({
+      success: true,
+      message: "Successfully created skill",
+      data: serializeSkill(newSkill)
+    });
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to create skill: ${error.message}`
+    });
+  }
+}
+async function updateSkill(request, reply) {
+  try {
+    const { id } = request.params;
+    const updates = request.body;
+    if (updates.name !== void 0) {
+      try {
+        validateSkillName(updates.name);
+      } catch (error) {
+        return reply.status(400).send({
+          success: false,
+          message: error.message || "Invalid skill name format"
+        });
+      }
+    }
+    const storeLattice = getStoreLattice3("default", "skill");
+    const skillStore = storeLattice.store;
+    const exists = await skillStore.hasSkill(id);
+    if (!exists) {
+      return reply.status(404).send({
+        success: false,
+        message: "Skill not found"
+      });
+    }
+    const updatedSkill = await skillStore.updateSkill(id, updates);
+    if (!updatedSkill) {
+      return reply.status(500).send({
+        success: false,
+        message: "Failed to update skill"
+      });
+    }
+    return {
+      success: true,
+      message: "Successfully updated skill",
+      data: serializeSkill(updatedSkill)
+    };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to update skill: ${error.message}`
+    });
+  }
+}
+async function deleteSkill(request, reply) {
+  try {
+    const { id } = request.params;
+    const storeLattice = getStoreLattice3("default", "skill");
+    const skillStore = storeLattice.store;
+    const exists = await skillStore.hasSkill(id);
+    if (!exists) {
+      return reply.status(404).send({
+        success: false,
+        message: "Skill not found"
+      });
+    }
+    const deleted = await skillStore.deleteSkill(id);
+    if (!deleted) {
+      return reply.status(500).send({
+        success: false,
+        message: "Failed to delete skill"
+      });
+    }
+    return {
+      success: true,
+      message: "Successfully deleted skill"
+    };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to delete skill: ${error.message}`
+    });
+  }
+}
+async function searchSkillsByMetadata(request, reply) {
+  try {
+    const { key, value } = request.query;
+    if (!key || !value) {
+      return reply.status(400).send({
+        success: false,
+        message: "key and value query parameters are required",
+        data: {
+          records: [],
+          total: 0
+        }
+      });
+    }
+    const storeLattice = getStoreLattice3("default", "skill");
+    const skillStore = storeLattice.store;
+    const skills = await skillStore.searchByMetadata(key, value);
+    const serializedSkills = skills.map(serializeSkill);
+    return {
+      success: true,
+      message: "Successfully searched skills",
+      data: {
+        records: serializedSkills,
+        total: serializedSkills.length
+      }
+    };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to search skills: ${error.message}`,
+      data: {
+        records: [],
+        total: 0
+      }
+    });
+  }
+}
+async function filterSkillsByCompatibility(request, reply) {
+  try {
+    const { compatibility } = request.query;
+    if (!compatibility) {
+      return reply.status(400).send({
+        success: false,
+        message: "compatibility query parameter is required",
+        data: {
+          records: [],
+          total: 0
+        }
+      });
+    }
+    const storeLattice = getStoreLattice3("default", "skill");
+    const skillStore = storeLattice.store;
+    const skills = await skillStore.filterByCompatibility(compatibility);
+    const serializedSkills = skills.map(serializeSkill);
+    return {
+      success: true,
+      message: "Successfully filtered skills",
+      data: {
+        records: serializedSkills,
+        total: serializedSkills.length
+      }
+    };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to filter skills: ${error.message}`,
+      data: {
+        records: [],
+        total: 0
+      }
+    });
+  }
+}
+async function filterSkillsByLicense(request, reply) {
+  try {
+    const { license } = request.query;
+    if (!license) {
+      return reply.status(400).send({
+        success: false,
+        message: "license query parameter is required",
+        data: {
+          records: [],
+          total: 0
+        }
+      });
+    }
+    const storeLattice = getStoreLattice3("default", "skill");
+    const skillStore = storeLattice.store;
+    const skills = await skillStore.filterByLicense(license);
+    const serializedSkills = skills.map(serializeSkill);
+    return {
+      success: true,
+      message: "Successfully filtered skills",
+      data: {
+        records: serializedSkills,
+        total: serializedSkills.length
+      }
+    };
+  } catch (error) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to filter skills: ${error.message}`,
+      data: {
+        records: [],
+        total: 0
+      }
+    });
+  }
+}
+
+// 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",
@@ -1590,6 +1986,256 @@ var getHealthSchema = {
   }
 };
 
+// src/services/sandbox_service.ts
+import { getAgentConfig, getAgentLattice as getAgentLattice2, normalizeSandboxName } from "@axiom-lattice/core";
+var SANDBOX_BASE_URL = process.env.SANDBOX_BASE_URL || "http://localhost:8080";
+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 {
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl || SANDBOX_BASE_URL;
+  }
+  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) {
+    return `${this.baseUrl}/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
+var SANDBOX_BASE_URL2 = process.env.SANDBOX_BASE_URL || "http://localhost:8080";
+async function registerSandboxProxyRoutes(app2) {
+  app2.get(
+    "/api/assistants/:assistantId/threads/:threadId/sandbox",
+    async (request, reply) => {
+      const { assistantId, threadId } = request.params;
+      const sandboxConfig = sandboxService.getSandboxConfig(assistantId);
+      if (!sandboxConfig) {
+        const errorHtml = sandboxService.generateErrorHtml(
+          assistantId,
+          threadId,
+          "unknown",
+          `Assistant ${assistantId} not found`
+        );
+        return reply.status(404).type("text/html").send(errorHtml);
+      }
+      const { isolatedLevel } = sandboxConfig;
+      const sandboxName = sandboxService.computeSandboxName(
+        assistantId,
+        threadId,
+        isolatedLevel
+      );
+      try {
+        const html = await sandboxService.getVncHtml(sandboxName);
+        const rewrittenHtml = sandboxService.rewriteHtml(html, assistantId, threadId);
+        return reply.type("text/html").send(rewrittenHtml);
+      } catch (error) {
+        const errorHtml = sandboxService.generateErrorHtml(
+          assistantId,
+          threadId,
+          isolatedLevel,
+          error.message || "Failed to connect to sandbox"
+        );
+        return reply.status(502).type("text/html").send(errorHtml);
+      }
+    }
+  );
+  app2.get(
+    "/api/assistants/:assistantId/threads/:threadId/sandbox/vnc/*",
+    async (request, reply) => {
+      const { assistantId, threadId, "*": restPath } = request.params;
+      const sandboxConfig = sandboxService.getSandboxConfig(assistantId);
+      if (!sandboxConfig) {
+        return reply.status(404).send("Assistant not found");
+      }
+      const { isolatedLevel } = sandboxConfig;
+      const sandboxName = sandboxService.computeSandboxName(
+        assistantId,
+        threadId,
+        isolatedLevel
+      );
+      const targetPath = restPath ? `/vnc/${restPath}` : "/vnc/";
+      const targetUrl = `${sandboxService.getTargetUrl(sandboxName)}${targetPath}`;
+      try {
+        const response = await fetch(targetUrl);
+        const contentType = response.headers.get("content-type") || "application/octet-stream";
+        const body = await response.arrayBuffer();
+        reply.status(response.status).type(contentType).send(Buffer.from(body));
+      } catch (error) {
+        reply.status(502).send(`Proxy error: ${error.message}`);
+      }
+    }
+  );
+}
+
 // src/routes/index.ts
 var registerLatticeRoutes = (app2) => {
   app2.post("/api/runs", createRun);
@@ -1665,6 +2311,7 @@ var registerLatticeRoutes = (app2) => {
   );
   app2.get("/api/models", getModels);
   app2.put("/api/models", updateModels);
+  app2.get("/api/tools", getToolConfigs);
   app2.get(
     "/health",
     { schema: getHealthSchema },
@@ -1678,6 +2325,36 @@ var registerLatticeRoutes = (app2) => {
   app2.post("/api/schedules/:taskId/cancel", cancelScheduledTask);
   app2.post("/api/schedules/:taskId/pause", pauseScheduledTask);
   app2.post("/api/schedules/:taskId/resume", resumeScheduledTask);
+  app2.get("/api/skills", getSkillList);
+  app2.get(
+    "/api/skills/:id",
+    getSkill
+  );
+  app2.post(
+    "/api/skills",
+    createSkill
+  );
+  app2.put(
+    "/api/skills/:id",
+    updateSkill
+  );
+  app2.delete(
+    "/api/skills/:id",
+    deleteSkill
+  );
+  app2.get(
+    "/api/skills/search/metadata",
+    searchSkillsByMetadata
+  );
+  app2.get(
+    "/api/skills/filter/compatibility",
+    filterSkillsByCompatibility
+  );
+  app2.get(
+    "/api/skills/filter/license",
+    filterSkillsByLicense
+  );
+  registerSandboxProxyRoutes(app2);
 };
 
 // src/swagger.ts
@@ -2102,6 +2779,7 @@ app.register(cors, {
   credentials: true
 });
 app.register(sensible);
+app.register(websocket);
 app.setErrorHandler((error, request, reply) => {
   const getHeaderValue = (header) => {
     if (Array.isArray(header)) {