@axiom-lattice/gateway 2.1.21 → 2.1.23

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,8 @@
 import fastify from "fastify";
 import cors from "@fastify/cors";
+import multipart from "@fastify/multipart";
 import sensible from "@fastify/sensible";
+import websocket from "@fastify/websocket";
 import { registerLatticeRoutes } from "./routes";
 import { configureSwagger } from "./swagger";
 import {
@@ -19,6 +21,7 @@ import {
   PinoFileOptions,
 } from "@axiom-lattice/protocols";
 
+
 process.on("unhandledRejection", (reason, promise) => {
   console.error("未处理的Promise拒绝:", reason);
   // 可以在这里进行日志记录或其他处理
@@ -59,6 +62,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[])
@@ -111,11 +115,19 @@ app.register(cors, {
     "X-Requested-With",
     "x-tenant-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);
 
 // 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" },
+      },
+    },
+  },
+};

package/src/services/agent_service.ts

@@ -59,7 +59,11 @@ export async function agent_invoke({
   }
 
   // Get runConfig from agent config and merge into configurable
-  const runConfig = agentLattice?.config?.runConfig || {};
+  const runConfig = {
+    ...agentLattice?.config?.runConfig || {},
+    assistant_id,
+    sandboxConfig: agentLattice?.config?.connectedSandbox,
+  }
 
   const result = await runnable_agent.invoke(
     command
@@ -72,6 +76,7 @@ export 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
       },
       recursionLimit: 200,
@@ -116,7 +121,11 @@ export async function agent_stream({
   const chunkBuffer = getOrCreateChunkBuffer();
 
   // Get runConfig from agent config and merge into configurable
-  const runConfig = agentLattice?.config?.runConfig || {};
+  const runConfig = {
+    ...agentLattice?.config?.runConfig || {},
+    assistant_id,
+    sandboxConfig: agentLattice?.config?.connectedSandbox,
+  }
 
   try {
     if (!runnable_agent) {
@@ -126,10 +135,10 @@ export async function agent_stream({
       command
         ? new Command(command)
         : {
-            ...rest,
-            messages,
-            "x-tenant-id": tenant_id,
-          },
+          ...rest,
+          messages,
+          "x-tenant-id": tenant_id,
+        },
 
       {
         configurable: {
@@ -138,6 +147,7 @@ export 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
         },
         streamMode: ["updates", "messages"],