@axiom-lattice/gateway 2.1.21 → 2.1.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/gateway",
-  "version": "2.1.21",
+  "version": "2.1.22",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -17,9 +17,12 @@
   "description": "API Gateway for LangGraph agent-based applications",
   "dependencies": {
     "@fastify/cors": "^11.0.0",
+    "@fastify/http-proxy": "^9.5.0",
+    "@fastify/reply-from": "^12.5.0",
     "@fastify/sensible": "^6.0.3",
     "@fastify/swagger": "^9.5.1",
     "@fastify/swagger-ui": "^5.2.3",
+    "@fastify/websocket": "^11.0.1",
     "@langchain/core": "1.1.4",
     "@langchain/langgraph": "1.0.4",
     "@supabase/supabase-js": "^2.49.1",
@@ -32,15 +35,16 @@
     "pino-roll": "^3.1.0",
     "redis": "^5.0.1",
     "uuid": "^9.0.1",
-    "@axiom-lattice/core": "2.1.16",
-    "@axiom-lattice/protocols": "2.1.10",
-    "@axiom-lattice/queue-redis": "1.0.9"
+    "@axiom-lattice/core": "2.1.17",
+    "@axiom-lattice/protocols": "2.1.11",
+    "@axiom-lattice/queue-redis": "1.0.10"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",
     "@types/lodash": "^4.17.16",
     "@types/node": "^20.17.23",
     "@types/uuid": "^9.0.8",
+    "@types/ws": "^8.18.1",
     "@typescript-eslint/eslint-plugin": "^7.2.0",
     "@typescript-eslint/parser": "^7.2.0",
     "eslint": "^8.57.0",

package/src/controllers/sandbox.ts

@@ -0,0 +1,150 @@
+import { FastifyInstance, FastifyRequest, FastifyReply } from "fastify";
+// import { WebSocket, createWebSocketStream } from "ws";
+import { pipeline } from "stream/promises";
+import { sandboxService } from "../services/sandbox_service";
+const SANDBOX_BASE_URL = process.env.SANDBOX_BASE_URL || "http://localhost:8080";
+
+interface SandboxParams {
+  assistantId: string;
+  threadId: string;
+}
+
+interface ProxyParams extends SandboxParams {
+  "*": string;
+}
+
+interface ResourceParams extends SandboxParams {
+  resourcePath: string;
+}
+
+export async function registerSandboxProxyRoutes(app: FastifyInstance): Promise<void> {
+  app.get<{ Params: SandboxParams }>(
+    "/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: any) {
+        const errorHtml = sandboxService.generateErrorHtml(
+          assistantId,
+          threadId,
+          isolatedLevel,
+          error.message || "Failed to connect to sandbox"
+        );
+        return reply.status(502).type("text/html").send(errorHtml);
+      }
+    }
+  );
+
+
+
+  // app.get<{ Params: SandboxParams }>(
+  //   "/api/assistants/:assistantId/threads/:threadId/sandbox/websockify",
+  //   { websocket: true },
+
+  //   (connection, request) => {
+
+  //     const url = (connection?.url) as string;
+  //     console.log(`[WebSocket] Received connection from URL: ${url}`);
+
+  //     const urlMatch = url.match(/\/api\/assistants\/([^/]+)\/threads\/([^/]+)\/sandbox\/websockify/);
+  //     if (!urlMatch) {
+  //       console.error(`[WebSocket] Failed to parse params from URL: ${url}`);
+  //       connection.close(1008, "Invalid URL format");
+  //       return;
+  //     }
+
+  //     const assistantId = urlMatch[1];
+  //     const threadId = urlMatch[2];
+  //     console.log(`[WebSocket] Parsed params - assistantId: ${assistantId}, threadId: ${threadId}`);
+
+  //     const sandboxConfig = sandboxService.getSandboxConfig(assistantId);
+  //     if (!sandboxConfig) {
+  //       console.error(`[WebSocket] Assistant ${assistantId} not found`);
+  //       connection.close(1008, "Assistant not found");
+  //       return;
+  //     }
+
+  //     const { isolatedLevel } = sandboxConfig;
+  //     const sandboxName = sandboxService.computeSandboxName(
+  //       assistantId,
+  //       threadId,
+  //       isolatedLevel
+  //     );
+
+  //     const targetUrl = sandboxService.getTargetUrl(sandboxName);
+  //     const targetWsUrl = targetUrl.replace(/^http/, "ws").replace(/^https/, "wss") + "/websockify";
+
+  //     console.log(`[WebSocket] Connecting to target: ${targetWsUrl}`);
+
+  //     const targetSocket = new WebSocket(targetWsUrl);
+  //     const clientStream = createWebSocketStream(connection, { encoding: "utf8" });
+
+  //     const targetStream = createWebSocketStream(targetSocket, { encoding: "utf8" });
+
+  //     const forward = pipeline(clientStream, targetStream);
+  //     const backward = pipeline(targetStream, clientStream);
+
+  //     Promise.all([forward, backward]).catch((err) => {
+  //       console.error(`[WebSocket] Proxy pipeline failed:`, err.message);
+  //       targetSocket.terminate();
+  //       connection.terminate();
+  //     });
+  //   }
+  // );
+
+  app.get<{ Params: ProxyParams }>(
+    "/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: any) {
+        reply.status(502).send(`Proxy error: ${error.message}`);
+      }
+    }
+  );
+
+
+}

package/src/controllers/tools.ts

@@ -0,0 +1,410 @@
+import { FastifyRequest, FastifyReply } from "fastify";
+import { getStoreLattice, toolLatticeManager } from "@axiom-lattice/core";
+import type {
+  Tool,
+  ToolConfig,
+} from "@axiom-lattice/protocols";
+
+/**
+ * Tools Controller
+ * Handles tool-related CRUD operations
+ */
+
+/**
+ * Tool list response interface
+ */
+interface ToolListResponse {
+  success: boolean;
+  message: string;
+  data: {
+    records: Tool[];
+    total: number;
+  };
+}
+
+/**
+ * Tool response interface
+ */
+interface ToolResponse {
+  success: boolean;
+  message: string;
+  data?: Tool;
+}
+
+/**
+ * Serialize Tool object for JSON response
+ * Converts Date objects to ISO strings
+ * Explicitly creates a plain object to ensure all fields are serializable
+ */
+function serializeTool(tool: Tool): any {
+  // Explicitly create a plain object with all fields
+  // This ensures Fastify can properly serialize the response
+  const serialized: any = {
+    id: tool.id,
+    name: tool.name,
+    description: tool.description,
+    license: tool.license,
+    compatibility: tool.compatibility,
+    metadata: tool.metadata || {},
+    config: tool.config,
+    createdAt: tool.createdAt instanceof Date ? tool.createdAt.toISOString() : (tool.createdAt ? new Date(tool.createdAt).toISOString() : new Date().toISOString()),
+    updatedAt: tool.updatedAt instanceof Date ? tool.updatedAt.toISOString() : (tool.updatedAt ? new Date(tool.updatedAt).toISOString() : new Date().toISOString()),
+  };
+
+  // Remove undefined fields to avoid serialization issues
+  Object.keys(serialized).forEach((key) => {
+    if (serialized[key] === undefined) {
+      delete serialized[key];
+    }
+  });
+
+  return serialized;
+}
+
+/**
+ * Get list of all tools
+ */
+export async function getToolList(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<ToolListResponse> {
+  try {
+    const storeLattice = getStoreLattice("default", "tool");
+    const toolStore = storeLattice.store;
+    const tools = await toolStore.getAllTools();
+
+    // Serialize tools to convert Date objects to ISO strings
+    const serializedTools = tools.map(serializeTool);
+
+    return {
+      success: true,
+      message: "Successfully retrieved tool list",
+      data: {
+        records: serializedTools,
+        total: serializedTools.length,
+      },
+    };
+  } catch (error: any) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to retrieve tools: ${error.message}`,
+      data: {
+        records: [],
+        total: 0,
+      },
+    });
+  }
+}
+
+/**
+ * Get a single tool by ID
+ */
+export async function getTool(
+  request: FastifyRequest<{ Params: { id: string } }>,
+  reply: FastifyReply
+): Promise<ToolResponse> {
+  try {
+    const { id } = request.params;
+
+    const storeLattice = getStoreLattice("default", "tool");
+    const toolStore = storeLattice.store;
+    const tool = await toolStore.getToolById(id);
+
+    if (!tool) {
+      return reply.status(404).send({
+        success: false,
+        message: "Tool not found",
+      });
+    }
+
+    return {
+      success: true,
+      message: "Successfully retrieved tool",
+      data: serializeTool(tool),
+    };
+  } catch (error: any) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to retrieve tool: ${error.message}`,
+    });
+  }
+}
+
+/**
+ * Search tools by metadata
+ */
+export async function searchToolsByMetadata(
+  request: FastifyRequest<{
+    Querystring: { key: string; value: string };
+  }>,
+  reply: FastifyReply
+): Promise<ToolListResponse> {
+  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 = getStoreLattice("default", "tool");
+    const toolStore = storeLattice.store;
+    const tools = await toolStore.searchByMetadata(key, value);
+
+    // Serialize tools to convert Date objects to ISO strings
+    const serializedTools = tools.map(serializeTool);
+
+    return {
+      success: true,
+      message: "Successfully searched tools",
+      data: {
+        records: serializedTools,
+        total: serializedTools.length,
+      },
+    };
+  } catch (error: any) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to search tools: ${error.message}`,
+      data: {
+        records: [],
+        total: 0,
+      },
+    });
+  }
+}
+
+/**
+ * Filter tools by compatibility
+ */
+export async function filterToolsByCompatibility(
+  request: FastifyRequest<{
+    Querystring: { compatibility: string };
+  }>,
+  reply: FastifyReply
+): Promise<ToolListResponse> {
+  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 = getStoreLattice("default", "tool");
+    const toolStore = storeLattice.store;
+    const tools = await toolStore.filterByCompatibility(compatibility);
+
+    // Serialize tools to convert Date objects to ISO strings
+    const serializedTools = tools.map(serializeTool);
+
+    return {
+      success: true,
+      message: "Successfully filtered tools",
+      data: {
+        records: serializedTools,
+        total: serializedTools.length,
+      },
+    };
+  } catch (error: any) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to filter tools: ${error.message}`,
+      data: {
+        records: [],
+        total: 0,
+      },
+    });
+  }
+}
+
+/**
+ * Filter tools by license
+ */
+export async function filterToolsByLicense(
+  request: FastifyRequest<{
+    Querystring: { license: string };
+  }>,
+  reply: FastifyReply
+): Promise<ToolListResponse> {
+  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 = getStoreLattice("default", "tool");
+    const toolStore = storeLattice.store;
+    const tools = await toolStore.filterByLicense(license);
+
+    // Serialize tools to convert Date objects to ISO strings
+    const serializedTools = tools.map(serializeTool);
+
+    return {
+      success: true,
+      message: "Successfully filtered tools",
+      data: {
+        records: serializedTools,
+        total: serializedTools.length,
+      },
+    };
+  } catch (error: any) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to filter tools: ${error.message}`,
+      data: {
+        records: [],
+        total: 0,
+      },
+    });
+  }
+}
+
+/**
+ * Tool config meta response interface
+ */
+interface ToolConfigMetaResponse {
+  success: boolean;
+  message: string;
+  data: {
+    records: Array<{
+      id: string;
+      name: string;
+      description: string;
+      schema?: any; // Serialized schema
+      returnDirect?: boolean;
+      needUserApprove?: boolean;
+    }>;
+    total: number;
+  };
+}
+
+/**
+ * Serialize ZodSchema to JSON-serializable format
+ * Attempts to extract schema information for API response
+ */
+function serializeSchema(schema: any): any {
+  if (!schema) {
+    return undefined;
+  }
+
+  try {
+    // Try to get JSON schema if available (zod-to-json-schema or similar)
+    if (schema._def) {
+      // For Zod schemas, try to extract basic info
+      const def = schema._def;
+      if (def.typeName === "ZodObject") {
+        // Extract shape information
+        const shape = def.shape();
+        const properties: Record<string, any> = {};
+        const required: string[] = [];
+
+        for (const [key, value] of Object.entries(shape)) {
+          const fieldDef = (value as any)._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 as any).isOptional()) {
+              required.push(key);
+            }
+          }
+        }
+
+        return {
+          type: "object",
+          properties,
+          required: required.length > 0 ? required : undefined,
+        };
+      }
+    }
+
+    // Fallback: return schema description or type name
+    return {
+      type: "object",
+      description: schema.description || "Schema definition",
+    };
+  } catch (error) {
+    // If serialization fails, return a safe fallback
+    return {
+      type: "object",
+      description: "Schema definition",
+    };
+  }
+}
+
+/**
+ * Get tool config meta from ToolLatticeManager
+ * Exposes tool configuration metadata via /api/tools endpoint
+ */
+export async function getToolConfigs(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<ToolConfigMetaResponse> {
+  try {
+    const allLattices = toolLatticeManager.getAllLattices();
+    
+    const toolConfigs = allLattices.map((lattice) => {
+      const config = { ...lattice.config };
+      
+      // Serialize schema if present
+      const serializedSchema = config.schema ? serializeSchema(config.schema) : undefined;
+
+      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: any) {
+    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,
+      },
+    });
+  }
+}

package/src/index.ts

@@ -1,6 +1,7 @@
 import fastify from "fastify";
 import cors from "@fastify/cors";
 import sensible from "@fastify/sensible";
+import websocket from "@fastify/websocket";
 import { registerLatticeRoutes } from "./routes";
 import { configureSwagger } from "./swagger";
 import {
@@ -19,6 +20,7 @@ import {
   PinoFileOptions,
 } from "@axiom-lattice/protocols";
 
+
 process.on("unhandledRejection", (reason, promise) => {
   console.error("未处理的Promise拒绝:", reason);
   // 可以在这里进行日志记录或其他处理
@@ -59,6 +61,7 @@ const app = fastify({
   bodyLimit: Number(process.env.BODY_LIMIT) || 50 * 1024 * 1024, // Default 50MB, configurable via BODY_LIMIT env var
 });
 
+
 // Add custom logging hooks
 app.addHook("onRequest", (request, reply, done) => {
   // Convert headers to strings (Fastify headers can be string | string[])
@@ -116,6 +119,7 @@ app.register(cors, {
   credentials: true,
 });
 app.register(sensible);
+app.register(websocket);
 
 // Error handler
 app.setErrorHandler((error, request, reply) => {

package/src/routes/index.ts

@@ -11,6 +11,7 @@ import * as configController from "../controllers/config";
 import * as modelsController from "../controllers/models";
 import * as healthController from "../controllers/health";
 import * as skillsController from "../controllers/skills";
+import * as toolsController from "../controllers/tools";
 import {
   createRunSchema,
   getAllMemoryItemsSchema,
@@ -25,7 +26,9 @@ import {
   updateConfigSchema,
   getConfigSchema,
   getHealthSchema,
+  getSandboxUrlSchema,
 } from "../schemas";
+import { registerSandboxProxyRoutes } from "../controllers/sandbox";
 
 export const registerLatticeRoutes = (app: FastifyInstance): void => {
   // 运行路由
@@ -192,6 +195,9 @@ export const registerLatticeRoutes = (app: FastifyInstance): void => {
     Body: { models: any[] };
   }>("/api/models", modelsController.updateModels);
 
+  // Tools config meta route
+  app.get("/api/tools", toolsController.getToolConfigs);
+
   // Health check route
   app.get(
     "/health",
@@ -285,4 +291,6 @@ export const registerLatticeRoutes = (app: FastifyInstance): void => {
     "/api/skills/filter/license",
     skillsController.filterSkillsByLicense
   );
+
+  registerSandboxProxyRoutes(app);
 };

package/src/schemas/index.ts

@@ -805,3 +805,45 @@ export const filterSkillsByLicenseSchema: FastifySchema = {
     },
   },
 };
+
+export const getSandboxUrlSchema: FastifySchema = {
+  description: "Get sandbox URL based on assistant and thread configuration",
+  tags: ["Sandbox"],
+  summary: "Get Sandbox URL",
+  params: {
+    type: "object",
+    properties: {
+      assistantId: { type: "string", description: "Assistant ID" },
+      threadId: { type: "string", description: "Thread ID" },
+    },
+    required: ["assistantId", "threadId"],
+  },
+  response: {
+    200: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        message: { type: "string" },
+        data: {
+          type: "object",
+          properties: {
+            sandboxUrl: { type: "string", description: "Sandbox URL" },
+            sandboxName: { type: "string", description: "Sandbox name" },
+            isolatedLevel: {
+              type: "string",
+              enum: ["agent", "thread", "global"],
+              description: "Sandbox isolation level",
+            },
+          },
+        },
+      },
+    },
+    404: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        message: { type: "string" },
+      },
+    },
+  },
+};