@axiom-lattice/gateway 2.1.34 → 2.1.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/gateway",
-  "version": "2.1.34",
+  "version": "2.1.36",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -36,9 +36,9 @@
     "pino-roll": "^3.1.0",
     "redis": "^5.0.1",
     "uuid": "^9.0.1",
-    "@axiom-lattice/core": "2.1.29",
-    "@axiom-lattice/protocols": "2.1.16",
-    "@axiom-lattice/queue-redis": "1.0.15"
+    "@axiom-lattice/core": "2.1.30",
+    "@axiom-lattice/protocols": "2.1.17",
+    "@axiom-lattice/queue-redis": "1.0.16"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

package/src/controllers/mcp-configs.ts

@@ -0,0 +1,691 @@
+/**
+ * MCP Server Config Controller
+ * Handles MCP server configuration CRUD operations with automatic tool registration
+ */
+
+import { FastifyRequest, FastifyReply } from "fastify";
+import {
+  getStoreLattice,
+  mcpManager,
+  toolLatticeManager,
+} from "@axiom-lattice/core";
+import type {
+  McpServerConfigStore,
+  McpServerConfigEntry,
+  CreateMcpServerConfigRequest,
+  UpdateMcpServerConfigRequest,
+  McpServerConfig,
+  McpTool,
+} from "@axiom-lattice/protocols";
+import { randomUUID } from "crypto";
+
+/**
+ * Get tenant ID from request headers
+ */
+function getTenantId(request: FastifyRequest): string {
+  return (request.headers["x-tenant-id"] as string) || "default";
+}
+
+/**
+ * MCP server config list response
+ */
+interface McpServerConfigListResponse {
+  success: boolean;
+  message: string;
+  data: {
+    records: McpServerConfigEntry[];
+    total: number;
+  };
+}
+
+/**
+ * MCP server config response
+ */
+interface McpServerConfigResponse {
+  success: boolean;
+  message: string;
+  data?: McpServerConfigEntry;
+}
+
+/**
+ * Test connection response
+ */
+interface TestConnectionResponse {
+  success: boolean;
+  message: string;
+  data?: {
+    connected: boolean;
+    latency?: number;
+    error?: string;
+  };
+}
+
+/**
+ * List tools response
+ */
+interface ListToolsResponse {
+  success: boolean;
+  message: string;
+  data?: {
+    tools: McpTool[];
+  };
+}
+
+/**
+ * Get all MCP server configs for a tenant
+ */
+export async function getMcpServerConfigList(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<McpServerConfigListResponse> {
+  const tenantId = getTenantId(request);
+
+  try {
+    const storeLattice = getStoreLattice("default", "mcp");
+    const store: McpServerConfigStore = storeLattice.store;
+
+    const configs = await store.getAllConfigs(tenantId);
+
+    return {
+      success: true,
+      message: "MCP server configurations retrieved successfully",
+      data: {
+        records: configs,
+        total: configs.length,
+      },
+    };
+  } catch (error) {
+    console.error("Failed to get MCP server configs:", error);
+    return {
+      success: false,
+      message: "Failed to retrieve MCP server configurations",
+      data: {
+        records: [],
+        total: 0,
+      },
+    };
+  }
+}
+
+/**
+ * Get MCP server config by key
+ */
+export async function getMcpServerConfig(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<McpServerConfigResponse> {
+  const tenantId = getTenantId(request);
+  const { key } = request.params as { key: string };
+
+  try {
+    const storeLattice = getStoreLattice("default", "mcp");
+    const store: McpServerConfigStore = storeLattice.store;
+
+    const config = await store.getConfigByKey(tenantId, key);
+
+    if (!config) {
+      return {
+        success: false,
+        message: "MCP server configuration not found",
+      };
+    }
+
+    return {
+      success: true,
+      message: "MCP server configuration retrieved successfully",
+      data: config,
+    };
+  } catch (error) {
+    console.error("Failed to get MCP server config:", error);
+    return {
+      success: false,
+      message: "Failed to retrieve MCP server configuration",
+    };
+  }
+}
+
+/**
+ * Create new MCP server config
+ */
+export async function createMcpServerConfig(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<McpServerConfigResponse> {
+  const tenantId = getTenantId(request);
+  const body = request.body as CreateMcpServerConfigRequest & {
+    id?: string;
+  };
+
+  try {
+    const storeLattice = getStoreLattice("default", "mcp");
+    const store: McpServerConfigStore = storeLattice.store;
+
+    // Check if key already exists
+    const existing = await store.getConfigByKey(tenantId, body.key);
+    if (existing) {
+      reply.code(409);
+      return {
+        success: false,
+        message: "MCP server configuration with this key already exists",
+      };
+    }
+
+    const id = body.id || randomUUID();
+    const config = await store.createConfig(tenantId, id, body);
+
+    // Auto-connect and register tools
+    try {
+      await connectAndRegisterTools(config);
+      // Update status to connected
+      await store.updateConfig(tenantId, id, { status: "connected" });
+      config.status = "connected";
+    } catch (error) {
+      console.warn("Failed to auto-connect MCP server:", error);
+      // Update status to error but don't fail the creation
+      await store.updateConfig(tenantId, id, { status: "error" });
+      config.status = "error";
+    }
+
+    reply.code(201);
+    return {
+      success: true,
+      message: "MCP server configuration created successfully",
+      data: config,
+    };
+  } catch (error) {
+    console.error("Failed to create MCP server config:", error);
+    return {
+      success: false,
+      message: "Failed to create MCP server configuration",
+    };
+  }
+}
+
+/**
+ * Update MCP server config
+ */
+export async function updateMcpServerConfig(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<McpServerConfigResponse> {
+  const tenantId = getTenantId(request);
+  const { key } = request.params as { key: string };
+  const updates = request.body as Partial<UpdateMcpServerConfigRequest>;
+
+  try {
+    const storeLattice = getStoreLattice("default", "mcp");
+    const store: McpServerConfigStore = storeLattice.store;
+
+    const existing = await store.getConfigByKey(tenantId, key);
+    if (!existing) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "MCP server configuration not found",
+      };
+    }
+
+    // If config is being updated, we need to reconnect
+    const shouldReconnect = updates.config !== undefined;
+
+    const updated = await store.updateConfig(tenantId, existing.id, updates);
+
+    if (!updated) {
+      return {
+        success: false,
+        message: "Failed to update MCP server configuration",
+      };
+    }
+
+    // Reconnect and re-register tools if config changed
+    if (shouldReconnect) {
+      try {
+        // Disconnect existing connection if any
+        if (mcpManager.hasServer(key)) {
+          await mcpManager.removeServer(key);
+        }
+        // Reconnect with new config
+        await connectAndRegisterTools(updated);
+        await store.updateConfig(tenantId, existing.id, { status: "connected" });
+        updated.status = "connected";
+      } catch (error) {
+        console.warn("Failed to reconnect MCP server:", error);
+        await store.updateConfig(tenantId, existing.id, { status: "error" });
+        updated.status = "error";
+      }
+    }
+
+    return {
+      success: true,
+      message: "MCP server configuration updated successfully",
+      data: updated,
+    };
+  } catch (error) {
+    console.error("Failed to update MCP server config:", error);
+    return {
+      success: false,
+      message: "Failed to update MCP server configuration",
+    };
+  }
+}
+
+/**
+ * Delete MCP server config by key or id
+ */
+export async function deleteMcpServerConfig(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<McpServerConfigResponse> {
+  const tenantId = getTenantId(request);
+  const { keyOrId } = request.params as { keyOrId: string };
+
+  try {
+    const storeLattice = getStoreLattice("default", "mcp");
+    const store: McpServerConfigStore = storeLattice.store;
+
+    // Try to find by key first, then by id
+    let config = await store.getConfigByKey(tenantId, keyOrId);
+    let configKey = keyOrId;
+
+    if (!config) {
+      // Try to find by id
+      config = await store.getConfigById(tenantId, keyOrId);
+      if (config) {
+        configKey = config.key;
+      }
+    }
+
+    if (!config) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "MCP server configuration not found",
+      };
+    }
+
+    // Disconnect and remove from MCP manager
+    try {
+      if (mcpManager.hasServer(configKey)) {
+        await mcpManager.removeServer(configKey);
+      }
+    } catch (error) {
+      console.warn("Failed to remove from MCP manager:", error);
+    }
+
+    const deleted = await store.deleteConfig(tenantId, config.id);
+
+    if (!deleted) {
+      return {
+        success: false,
+        message: "Failed to delete MCP server configuration",
+      };
+    }
+
+    return {
+      success: true,
+      message: "MCP server configuration deleted successfully",
+    };
+  } catch (error) {
+    console.error("Failed to delete MCP server config:", error);
+    return {
+      success: false,
+      message: "Failed to delete MCP server configuration",
+    };
+  }
+}
+
+/**
+ * Test MCP server connection
+ */
+export async function testMcpServerConnection(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<TestConnectionResponse> {
+  const tenantId = getTenantId(request);
+  const { key } = request.params as { key: string };
+
+  try {
+    const storeLattice = getStoreLattice("default", "mcp");
+    const store: McpServerConfigStore = storeLattice.store;
+
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "MCP server configuration not found",
+      };
+    }
+
+    const startTime = Date.now();
+
+    // Test connection by trying to list tools
+    try {
+      // Create temporary connection
+      const testKey = `__test_${key}_${Date.now()}`;
+      const connection = convertToConnection(config.config);
+      mcpManager.addServer(testKey, connection);
+
+      await mcpManager.connect();
+      const tools = await mcpManager.getAllTools();
+      const latency = Date.now() - startTime;
+
+      // Cleanup
+      await mcpManager.removeServer(testKey);
+
+      return {
+        success: true,
+        message: "Connection test successful",
+        data: {
+          connected: true,
+          latency,
+        },
+      };
+    } catch (error) {
+      return {
+        success: true,
+        message: "Connection test failed",
+        data: {
+          connected: false,
+          error: error instanceof Error ? error.message : "Unknown error",
+        },
+      };
+    }
+  } catch (error) {
+    console.error("Failed to test MCP server connection:", error);
+    return {
+      success: false,
+      message: "Failed to test MCP server connection",
+      data: {
+        connected: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+      },
+    };
+  }
+}
+
+/**
+ * List available tools from an MCP server
+ */
+export async function listMcpServerTools(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<ListToolsResponse> {
+  const tenantId = getTenantId(request);
+  const { key } = request.params as { key: string };
+
+  try {
+    const storeLattice = getStoreLattice("default", "mcp");
+    const store: McpServerConfigStore = storeLattice.store;
+
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "MCP server configuration not found",
+      };
+    }
+
+    // Ensure server is connected
+    if (!mcpManager.hasServer(key)) {
+      await connectAndRegisterTools(config);
+    }
+
+    const tools = await mcpManager.getAllTools();
+
+    return {
+      success: true,
+      message: "Tools retrieved successfully",
+      data: {
+        tools,
+      },
+    };
+  } catch (error) {
+    console.error("Failed to list MCP tools:", error);
+    return {
+      success: false,
+      message: "Failed to retrieve tools",
+    };
+  }
+}
+
+/**
+ * Connect to MCP server and register tools
+ */
+export async function connectMcpServer(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<McpServerConfigResponse> {
+  const tenantId = getTenantId(request);
+  const { key } = request.params as { key: string };
+
+  try {
+    const storeLattice = getStoreLattice("default", "mcp");
+    const store: McpServerConfigStore = storeLattice.store;
+
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "MCP server configuration not found",
+      };
+    }
+
+    await connectAndRegisterTools(config);
+
+    // Update status
+    const updated = await store.updateConfig(tenantId, config.id, {
+      status: "connected",
+    });
+
+    return {
+      success: true,
+      message: "MCP server connected successfully",
+      data: updated || config,
+    };
+  } catch (error) {
+    console.error("Failed to connect MCP server:", error);
+
+    // Update status to error
+    const storeLattice = getStoreLattice("default", "mcp");
+    const store: McpServerConfigStore = storeLattice.store;
+    const config = await store.getConfigByKey(tenantId, key);
+    if (config) {
+      await store.updateConfig(tenantId, config.id, { status: "error" });
+    }
+
+    return {
+      success: false,
+      message: `Failed to connect MCP server: ${
+        error instanceof Error ? error.message : "Unknown error"
+      }`,
+    };
+  }
+}
+
+/**
+ * Disconnect from MCP server
+ */
+export async function disconnectMcpServer(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<McpServerConfigResponse> {
+  const tenantId = getTenantId(request);
+  const { key } = request.params as { key: string };
+
+  try {
+    const storeLattice = getStoreLattice("default", "mcp");
+    const store: McpServerConfigStore = storeLattice.store;
+
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "MCP server configuration not found",
+      };
+    }
+
+    // Disconnect from MCP manager
+    if (mcpManager.hasServer(key)) {
+      await mcpManager.removeServer(key);
+    }
+
+    // Update status
+    const updated = await store.updateConfig(tenantId, config.id, {
+      status: "disconnected",
+    });
+
+    return {
+      success: true,
+      message: "MCP server disconnected successfully",
+      data: updated || config,
+    };
+  } catch (error) {
+    console.error("Failed to disconnect MCP server:", error);
+    return {
+      success: false,
+      message: "Failed to disconnect MCP server",
+    };
+  }
+}
+
+/**
+ * Test MCP server connection and list tools without saving config
+ * Used for multi-step configuration flow
+ */
+export async function testMcpServerTools(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<ListToolsResponse> {
+  const body = request.body as {
+    config: McpServerConfig;
+  };
+
+  try {
+    if (!body.config) {
+      reply.code(400);
+      return {
+        success: false,
+        message: "config is required",
+      };
+    }
+
+    const testKey = `__test_${Date.now()}`;
+
+    // Create temporary connection
+    const connection = convertToConnection(body.config);
+    mcpManager.addServer(testKey, connection);
+
+    await mcpManager.connect();
+    const tools = await mcpManager.getAllTools();
+
+    // Cleanup
+    await mcpManager.removeServer(testKey);
+
+    return {
+      success: true,
+      message: "Tools retrieved successfully",
+      data: {
+        tools,
+      },
+    };
+  } catch (error) {
+    console.error("Failed to test MCP server tools:", error);
+    return {
+      success: false,
+      message: `Failed to retrieve tools: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    };
+  }
+}
+
+/**
+ * Convert McpServerConfig to Connection format compatible with @langchain/mcp-adapters
+ */
+function convertToConnection(config: McpServerConfig): any {
+  const baseConfig = {
+    env: config.env,
+  };
+
+  if (config.transport === "stdio") {
+    return {
+      ...baseConfig,
+      transport: "stdio" as const,
+      command: config.command!,
+      args: config.args || [],
+    };
+  } else {
+    // For HTTP/SSE transports
+    return {
+      ...baseConfig,
+      transport: config.transport === "streamable_http" ? "http" : config.transport,
+      url: config.url!,
+    };
+  }
+}
+
+/**
+ * Helper function to connect to MCP server and register selected tools
+ */
+async function connectAndRegisterTools(
+  config: McpServerConfigEntry
+): Promise<void> {
+  // Add server to MCP manager
+  const connection = convertToConnection(config.config);
+  mcpManager.addServer(config.key, connection);
+
+  // Connect to server
+  await mcpManager.connect();
+
+  // Get all available tools
+  const allTools = await mcpManager.getAllTools();
+
+  // Filter to only selected tools
+  const selectedTools = allTools.filter((tool) =>
+    config.selectedTools.includes(tool.name)
+  );
+
+  // Register selected tools to ToolLattice
+  for (const tool of selectedTools) {
+    toolLatticeManager.registerExistingTool(tool.name, tool);
+  }
+}
+
+/**
+ * Register MCP server config routes
+ */
+export function registerMcpServerConfigRoutes(app: any): void {
+  // Get all configs
+  app.get("/api/mcp-servers", getMcpServerConfigList);
+
+  // Get config by key
+  app.get("/api/mcp-servers/:key", getMcpServerConfig);
+
+  // Create config
+  app.post("/api/mcp-servers", createMcpServerConfig);
+
+  // Update config
+  app.put("/api/mcp-servers/:key", updateMcpServerConfig);
+
+  // Delete config by key or id
+  app.delete("/api/mcp-servers/:keyOrId", deleteMcpServerConfig);
+
+  // Test connection
+  app.post("/api/mcp-servers/:key/test", testMcpServerConnection);
+
+  // List available tools
+  app.get("/api/mcp-servers/:key/tools", listMcpServerTools);
+
+  // Connect to server
+  app.post("/api/mcp-servers/:key/connect", connectMcpServer);
+
+  // Disconnect from server
+  app.post("/api/mcp-servers/:key/disconnect", disconnectMcpServer);
+
+  // Test tools without saving config (for multi-step config flow)
+  app.post("/api/mcp-servers/test-tools", testMcpServerTools);
+}