@axiom-lattice/gateway 2.1.34 → 2.1.36

package/dist/index.mjs

@@ -1,7 +1,3 @@
-import {
-  configService
-} from "./chunk-FSASG3SB.mjs";
-
 // src/index.ts
 import fastify from "fastify";
 import cors from "@fastify/cors";
@@ -24,31 +20,6 @@ import {
   getChunkBuffer,
   hasChunkBuffer
 } from "@axiom-lattice/core";
-async function fetchDatabaseConfigs(baseURL, apiKey, tenantId) {
-  try {
-    const headers = {};
-    if (apiKey) {
-      headers["Authorization"] = `Bearer ${apiKey}`;
-    }
-    if (tenantId) {
-      headers["x-tenant-id"] = tenantId;
-    }
-    const response = await fetch(`${baseURL}/api/database-configs`, { headers });
-    if (response.ok) {
-      const data = await response.json();
-      if (data.success && data.data && Array.isArray(data.data.records)) {
-        return data.data.records.map((record) => ({
-          key: record.key,
-          name: record.name,
-          description: record.description
-        }));
-      }
-    }
-  } catch (error) {
-    console.error("Failed to fetch database configs:", error);
-  }
-  return [];
-}
 function getOrCreateChunkBuffer() {
   if (!hasChunkBuffer("default")) {
     const buffer = new InMemoryChunkBuffer({
@@ -80,14 +51,6 @@ async function agent_invoke({
   if (!runnable_agent) {
     throw new Error(`Agent ${assistant_id} not found`);
   }
-  const { configService: configService2 } = await import("./config-F3FCBSPH.mjs");
-  const gatewayConfig = configService2.getConfig();
-  const databaseConfigs = await fetchDatabaseConfigs(
-    gatewayConfig.baseURL || "http://localhost:4001",
-    void 0,
-    tenant_id
-  );
-  global.__DATABASE_CONFIGS__ = databaseConfigs;
   const runConfig = {
     ...agentLattice?.config?.runConfig || {},
     workspaceId: workspace_id,
@@ -141,14 +104,6 @@ async function agent_stream({
     messages = [humanMessage];
   }
   const chunkBuffer = getOrCreateChunkBuffer();
-  const { configService: configService2 } = await import("./config-F3FCBSPH.mjs");
-  const gatewayConfig = configService2.getConfig();
-  const databaseConfigs = await fetchDatabaseConfigs(
-    gatewayConfig.baseURL || "http://localhost:4001",
-    void 0,
-    tenant_id
-  );
-  global.__DATABASE_CONFIGS__ = databaseConfigs;
   const runConfig = {
     ...agentLattice?.config?.runConfig || {},
     workspaceId: workspace_id,
@@ -1087,6 +1042,78 @@ async function resumeScheduledTask(request, reply) {
   }
 }
 
+// src/config.ts
+var ConfigService = class {
+  constructor() {
+    this.config = this.loadFromEnv();
+  }
+  /**
+   * Load configuration from environment variables
+   */
+  loadFromEnv() {
+    return {
+      port: process.env.PORT ? Number(process.env.PORT) : void 0,
+      queueServiceType: process.env.QUEUE_SERVICE_TYPE,
+      redisUrl: process.env.REDIS_URL,
+      redisPassword: process.env.REDIS_PASSWORD,
+      queueName: process.env.QUEUE_NAME
+    };
+  }
+  /**
+   * Update configuration from JSON object
+   * This will update both the internal config and process.env
+   */
+  updateConfig(jsonConfig) {
+    for (const [key, value] of Object.entries(jsonConfig)) {
+      if (value !== null && value !== void 0) {
+        if (typeof value === "object" && !Array.isArray(value)) {
+          for (const [nestedKey, nestedValue] of Object.entries(value)) {
+            const envKey = `${key.toUpperCase()}_${nestedKey.toUpperCase()}`;
+            process.env[envKey] = String(nestedValue);
+          }
+        } else {
+          process.env[key.toUpperCase()] = String(value);
+        }
+      }
+    }
+    this.config = this.loadFromEnv();
+    this.config = this.deepMerge(this.config, jsonConfig);
+  }
+  /**
+   * Deep merge two objects
+   */
+  deepMerge(target, source) {
+    const output = { ...target };
+    if (this.isObject(target) && this.isObject(source)) {
+      Object.keys(source).forEach((key) => {
+        if (this.isObject(source[key])) {
+          if (!(key in target)) {
+            Object.assign(output, { [key]: source[key] });
+          } else {
+            output[key] = this.deepMerge(target[key], source[key]);
+          }
+        } else {
+          Object.assign(output, { [key]: source[key] });
+        }
+      });
+    }
+    return output;
+  }
+  /**
+   * Check if value is a plain object
+   */
+  isObject(item) {
+    return item && typeof item === "object" && !Array.isArray(item);
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+var configService = new ConfigService();
+
 // src/services/queue_service.ts
 import {
   queueLatticeManager,
@@ -3544,12 +3571,441 @@ function registerMetricsServerConfigRoutes(app2) {
   app2.post("/api/metrics-configs/test-datasources/:datasourceId/meta", testDatasourceMetrics);
 }
 
+// src/controllers/mcp-configs.ts
+import {
+  getStoreLattice as getStoreLattice8,
+  mcpManager,
+  toolLatticeManager as toolLatticeManager2
+} from "@axiom-lattice/core";
+import { randomUUID as randomUUID5 } from "crypto";
+function getTenantId3(request) {
+  return request.headers["x-tenant-id"] || "default";
+}
+async function getMcpServerConfigList(request, reply) {
+  const tenantId = getTenantId3(request);
+  try {
+    const storeLattice = getStoreLattice8("default", "mcp");
+    const store = 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
+      }
+    };
+  }
+}
+async function getMcpServerConfig(request, reply) {
+  const tenantId = getTenantId3(request);
+  const { key } = request.params;
+  try {
+    const storeLattice = getStoreLattice8("default", "mcp");
+    const store = 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"
+    };
+  }
+}
+async function createMcpServerConfig(request, reply) {
+  const tenantId = getTenantId3(request);
+  const body = request.body;
+  try {
+    const storeLattice = getStoreLattice8("default", "mcp");
+    const store = storeLattice.store;
+    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 || randomUUID5();
+    const config = await store.createConfig(tenantId, id, body);
+    try {
+      await connectAndRegisterTools(config);
+      await store.updateConfig(tenantId, id, { status: "connected" });
+      config.status = "connected";
+    } catch (error) {
+      console.warn("Failed to auto-connect MCP server:", error);
+      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"
+    };
+  }
+}
+async function updateMcpServerConfig(request, reply) {
+  const tenantId = getTenantId3(request);
+  const { key } = request.params;
+  const updates = request.body;
+  try {
+    const storeLattice = getStoreLattice8("default", "mcp");
+    const store = storeLattice.store;
+    const existing = await store.getConfigByKey(tenantId, key);
+    if (!existing) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "MCP server configuration not found"
+      };
+    }
+    const shouldReconnect = updates.config !== void 0;
+    const updated = await store.updateConfig(tenantId, existing.id, updates);
+    if (!updated) {
+      return {
+        success: false,
+        message: "Failed to update MCP server configuration"
+      };
+    }
+    if (shouldReconnect) {
+      try {
+        if (mcpManager.hasServer(key)) {
+          await mcpManager.removeServer(key);
+        }
+        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"
+    };
+  }
+}
+async function deleteMcpServerConfig(request, reply) {
+  const tenantId = getTenantId3(request);
+  const { keyOrId } = request.params;
+  try {
+    const storeLattice = getStoreLattice8("default", "mcp");
+    const store = storeLattice.store;
+    let config = await store.getConfigByKey(tenantId, keyOrId);
+    let configKey = keyOrId;
+    if (!config) {
+      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"
+      };
+    }
+    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"
+    };
+  }
+}
+async function testMcpServerConnection(request, reply) {
+  const tenantId = getTenantId3(request);
+  const { key } = request.params;
+  try {
+    const storeLattice = getStoreLattice8("default", "mcp");
+    const store = 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();
+    try {
+      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;
+      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"
+      }
+    };
+  }
+}
+async function listMcpServerTools(request, reply) {
+  const tenantId = getTenantId3(request);
+  const { key } = request.params;
+  try {
+    const storeLattice = getStoreLattice8("default", "mcp");
+    const store = storeLattice.store;
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "MCP server configuration not found"
+      };
+    }
+    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"
+    };
+  }
+}
+async function connectMcpServer(request, reply) {
+  const tenantId = getTenantId3(request);
+  const { key } = request.params;
+  try {
+    const storeLattice = getStoreLattice8("default", "mcp");
+    const store = 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);
+    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);
+    const storeLattice = getStoreLattice8("default", "mcp");
+    const store = 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"}`
+    };
+  }
+}
+async function disconnectMcpServer(request, reply) {
+  const tenantId = getTenantId3(request);
+  const { key } = request.params;
+  try {
+    const storeLattice = getStoreLattice8("default", "mcp");
+    const store = storeLattice.store;
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "MCP server configuration not found"
+      };
+    }
+    if (mcpManager.hasServer(key)) {
+      await mcpManager.removeServer(key);
+    }
+    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"
+    };
+  }
+}
+async function testMcpServerTools(request, reply) {
+  const body = request.body;
+  try {
+    if (!body.config) {
+      reply.code(400);
+      return {
+        success: false,
+        message: "config is required"
+      };
+    }
+    const testKey = `__test_${Date.now()}`;
+    const connection = convertToConnection(body.config);
+    mcpManager.addServer(testKey, connection);
+    await mcpManager.connect();
+    const tools = await mcpManager.getAllTools();
+    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)}`
+    };
+  }
+}
+function convertToConnection(config) {
+  const baseConfig = {
+    env: config.env
+  };
+  if (config.transport === "stdio") {
+    return {
+      ...baseConfig,
+      transport: "stdio",
+      command: config.command,
+      args: config.args || []
+    };
+  } else {
+    return {
+      ...baseConfig,
+      transport: config.transport === "streamable_http" ? "http" : config.transport,
+      url: config.url
+    };
+  }
+}
+async function connectAndRegisterTools(config) {
+  const connection = convertToConnection(config.config);
+  mcpManager.addServer(config.key, connection);
+  await mcpManager.connect();
+  const allTools = await mcpManager.getAllTools();
+  const selectedTools = allTools.filter(
+    (tool) => config.selectedTools.includes(tool.name)
+  );
+  for (const tool of selectedTools) {
+    toolLatticeManager2.registerExistingTool(tool.name, tool);
+  }
+}
+function registerMcpServerConfigRoutes(app2) {
+  app2.get("/api/mcp-servers", getMcpServerConfigList);
+  app2.get("/api/mcp-servers/:key", getMcpServerConfig);
+  app2.post("/api/mcp-servers", createMcpServerConfig);
+  app2.put("/api/mcp-servers/:key", updateMcpServerConfig);
+  app2.delete("/api/mcp-servers/:keyOrId", deleteMcpServerConfig);
+  app2.post("/api/mcp-servers/:key/test", testMcpServerConnection);
+  app2.get("/api/mcp-servers/:key/tools", listMcpServerTools);
+  app2.post("/api/mcp-servers/:key/connect", connectMcpServer);
+  app2.post("/api/mcp-servers/:key/disconnect", disconnectMcpServer);
+  app2.post("/api/mcp-servers/test-tools", testMcpServerTools);
+}
+
 // src/controllers/users.ts
-import { getStoreLattice as getStoreLattice8 } from "@axiom-lattice/core";
+import { getStoreLattice as getStoreLattice9 } from "@axiom-lattice/core";
 import { v4 as uuidv42 } from "uuid";
 var UsersController = class {
   constructor() {
-    this.userStore = getStoreLattice8("default", "user").store;
+    this.userStore = getStoreLattice9("default", "user").store;
   }
   async listUsers(request, reply) {
     const { email } = request.query;
@@ -3627,11 +4083,11 @@ function registerUserRoutes(app2) {
 }
 
 // src/controllers/tenants.ts
-import { getStoreLattice as getStoreLattice9 } from "@axiom-lattice/core";
+import { getStoreLattice as getStoreLattice10 } from "@axiom-lattice/core";
 import { v4 as uuidv43 } from "uuid";
 var TenantsController = class {
   constructor() {
-    this.tenantStore = getStoreLattice9("default", "tenant").store;
+    this.tenantStore = getStoreLattice10("default", "tenant").store;
   }
   // ==================== Tenant CRUD ====================
   async listTenants(request, reply) {
@@ -3695,7 +4151,7 @@ function registerTenantRoutes(app2) {
 }
 
 // src/controllers/auth.ts
-import { getStoreLattice as getStoreLattice10 } from "@axiom-lattice/core";
+import { getStoreLattice as getStoreLattice11 } from "@axiom-lattice/core";
 import { v4 as uuidv44 } from "uuid";
 var defaultAuthConfig = {
   autoApproveUsers: true,
@@ -3704,9 +4160,9 @@ var defaultAuthConfig = {
 };
 var AuthController = class {
   constructor(config = {}) {
-    this.userStore = getStoreLattice10("default", "user").store;
-    this.tenantStore = getStoreLattice10("default", "tenant").store;
-    this.userTenantLinkStore = getStoreLattice10("default", "userTenantLink").store;
+    this.userStore = getStoreLattice11("default", "user").store;
+    this.tenantStore = getStoreLattice11("default", "tenant").store;
+    this.userTenantLinkStore = getStoreLattice11("default", "userTenantLink").store;
     this.config = { ...defaultAuthConfig, ...config };
   }
   async register(request, reply) {
@@ -4143,6 +4599,7 @@ var registerLatticeRoutes = (app2) => {
   registerWorkspaceRoutes(app2);
   registerDatabaseConfigRoutes(app2);
   registerMetricsServerConfigRoutes(app2);
+  registerMcpServerConfigRoutes(app2);
   registerUserRoutes(app2);
   registerTenantRoutes(app2);
   registerAuthRoutes(app2, {