@axiom-lattice/gateway 2.1.20 → 2.1.22

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

@@ -1,4 +1,5 @@
 import { FastifyInstance } from "fastify";
+import { ScheduledTaskStatus } from "@axiom-lattice/protocols";
 import * as assistantController from "../controllers/assistant";
 import * as runController from "../controllers/run";
 import * as memoryController from "../controllers/memory";
@@ -9,6 +10,8 @@ import * as schedulesController from "../controllers/schedules";
 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,
@@ -23,7 +26,9 @@ import {
   updateConfigSchema,
   getConfigSchema,
   getHealthSchema,
+  getSandboxUrlSchema,
 } from "../schemas";
+import { registerSandboxProxyRoutes } from "../controllers/sandbox";
 
 export const registerLatticeRoutes = (app: FastifyInstance): void => {
   // 运行路由
@@ -190,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",
@@ -200,7 +208,11 @@ export const registerLatticeRoutes = (app: FastifyInstance): void => {
   // Schedule routes for viewing scheduled tasks by thread
   app.get<{
     Params: { assistantId: string; threadId: string };
-    Querystring: { status?: string; limit?: string; offset?: string };
+    Querystring: {
+      status?: ScheduledTaskStatus;
+      limit?: string;
+      offset?: string;
+    };
   }>(
     "/api/assistants/:assistantId/threads/:threadId/schedules",
     schedulesController.getThreadSchedules
@@ -225,4 +237,60 @@ export const registerLatticeRoutes = (app: FastifyInstance): void => {
   app.post<{
     Params: { taskId: string };
   }>("/api/schedules/:taskId/resume", schedulesController.resumeScheduledTask);
+
+  // Skills CRUD routes
+  app.get("/api/skills", skillsController.getSkillList);
+
+  app.get<{
+    Params: { id: string };
+  }>(
+    "/api/skills/:id",
+    skillsController.getSkill
+  );
+
+  app.post<{
+    Body: any;
+  }>(
+    "/api/skills",
+    skillsController.createSkill
+  );
+
+  app.put<{
+    Params: { id: string };
+    Body: any;
+  }>(
+    "/api/skills/:id",
+    skillsController.updateSkill
+  );
+
+  app.delete<{
+    Params: { id: string };
+  }>(
+    "/api/skills/:id",
+    skillsController.deleteSkill
+  );
+
+  // Skills search and filter routes
+  app.get<{
+    Querystring: { key: string; value: string };
+  }>(
+    "/api/skills/search/metadata",
+    skillsController.searchSkillsByMetadata
+  );
+
+  app.get<{
+    Querystring: { compatibility: string };
+  }>(
+    "/api/skills/filter/compatibility",
+    skillsController.filterSkillsByCompatibility
+  );
+
+  app.get<{
+    Querystring: { license: string };
+  }>(
+    "/api/skills/filter/license",
+    skillsController.filterSkillsByLicense
+  );
+
+  registerSandboxProxyRoutes(app);
 };