@axiom-lattice/gateway 2.1.34 → 2.1.36

package/dist/index.js

@@ -5,9 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -30,106 +27,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/config.ts
-var config_exports = {};
-__export(config_exports, {
-  config: () => config,
-  configService: () => configService
-});
-var ConfigService, configService, config;
-var init_config = __esm({
-  "src/config.ts"() {
-    "use strict";
-    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 };
-      }
-    };
-    configService = new ConfigService();
-    config = {
-      get port() {
-        return configService.getConfig().port;
-      },
-      get queueServiceType() {
-        return configService.getConfig().queueServiceType;
-      },
-      get redisUrl() {
-        return configService.getConfig().redisUrl;
-      },
-      get redisPassword() {
-        return configService.getConfig().redisPassword;
-      },
-      get queueName() {
-        return configService.getConfig().queueName;
-      }
-    };
-  }
-});
-
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -147,31 +44,6 @@ var import_messages = require("@langchain/core/messages");
 var import_langgraph = require("@langchain/langgraph");
 var import_uuid = require("uuid");
 var import_core = require("@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 (!(0, import_core.hasChunkBuffer)("default")) {
     const buffer = new import_core.InMemoryChunkBuffer({
@@ -203,14 +75,6 @@ async function agent_invoke({
   if (!runnable_agent) {
     throw new Error(`Agent ${assistant_id} not found`);
   }
-  const { configService: configService2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-  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,
@@ -264,14 +128,6 @@ async function agent_stream({
     messages = [humanMessage];
   }
   const chunkBuffer = getOrCreateChunkBuffer();
-  const { configService: configService2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-  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,
@@ -429,12 +285,12 @@ async function resume_stream({
 var import_core2 = require("@axiom-lattice/core");
 var import_crypto = require("crypto");
 var import_core3 = require("@axiom-lattice/core");
-function convertAgentConfigToAssistant(config2) {
+function convertAgentConfigToAssistant(config) {
   return {
-    id: config2.key,
-    name: config2.name,
-    description: config2.description,
-    graphDefinition: config2,
+    id: config.key,
+    name: config.name,
+    description: config.description,
+    graphDefinition: config,
     // Store the full config as graphDefinition
     createdAt: /* @__PURE__ */ new Date(0),
     // Code-configured agents have no creation date
@@ -474,7 +330,7 @@ async function getAssistant(request, reply) {
   let assistant = await assistantStore.getAssistantById(id);
   if (!assistant) {
     const agentConfigs = await (0, import_core3.getAllAgentConfigs)();
-    const agentConfig = agentConfigs.find((config2) => config2.key === id);
+    const agentConfig = agentConfigs.find((config) => config.key === id);
     if (agentConfig) {
       assistant = convertAgentConfigToAssistant(agentConfig);
     }
@@ -549,7 +405,7 @@ async function deleteAssistant(request, reply) {
   const storeLattice = (0, import_core2.getStoreLattice)("default", "assistant");
   const assistantStore = storeLattice.store;
   const agentConfigs = await (0, import_core3.getAllAgentConfigs)();
-  const isCodeConfigured = agentConfigs.some((config2) => config2.key === id);
+  const isCodeConfigured = agentConfigs.some((config) => config.key === id);
   if (isCodeConfigured) {
     const exists2 = await assistantStore.hasAssistant(id);
     if (!exists2) {
@@ -1210,8 +1066,77 @@ async function resumeScheduledTask(request, reply) {
   }
 }
 
-// src/controllers/config.ts
-init_config();
+// 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
 var import_core7 = require("@axiom-lattice/core");
@@ -1223,7 +1148,7 @@ var setQueueServiceType = (type) => {
   queueServiceType = type;
   console.log(`Queue service type set to: ${type}`);
   const queueName = process.env.QUEUE_NAME || "tasks";
-  const config2 = {
+  const config = {
     name: "Default Queue Service",
     description: `Default ${type} queue service`,
     type: type === "redis" ? import_protocols.QueueType.REDIS : import_protocols.QueueType.MEMORY,
@@ -1243,7 +1168,7 @@ var setQueueServiceType = (type) => {
       redisPassword: process.env.REDIS_PASSWORD
     });
   }
-  (0, import_core7.registerQueueLattice)(DEFAULT_QUEUE_KEY, config2, client);
+  (0, import_core7.registerQueueLattice)(DEFAULT_QUEUE_KEY, config, client);
 };
 var getQueueService = () => {
   if (!import_core7.queueLatticeManager.hasLattice(DEFAULT_QUEUE_KEY)) {
@@ -1335,18 +1260,18 @@ async function getModels(request, reply) {
   try {
     const allLattices = import_core8.modelLatticeManager.getAllLattices();
     const models = allLattices.map((lattice) => {
-      const config2 = lattice.client.config || {};
+      const config = lattice.client.config || {};
       return {
         key: lattice.key,
-        model: config2.model || "",
-        provider: config2.provider || "openai",
-        streaming: config2.streaming || false,
-        apiKey: config2.apiKey || "",
-        baseURL: config2.baseURL || "",
-        maxTokens: config2.maxTokens,
-        temperature: config2.temperature,
-        timeout: config2.timeout,
-        maxRetries: config2.maxRetries
+        model: config.model || "",
+        provider: config.provider || "openai",
+        streaming: config.streaming || false,
+        apiKey: config.apiKey || "",
+        baseURL: config.baseURL || "",
+        maxTokens: config.maxTokens,
+        temperature: config.temperature,
+        timeout: config.timeout,
+        maxRetries: config.maxRetries
       };
     });
     return reply.send({
@@ -1806,15 +1731,15 @@ async function getToolConfigs(request, reply) {
   try {
     const allLattices = import_core11.toolLatticeManager.getAllLattices();
     const toolConfigs = allLattices.map((lattice) => {
-      const config2 = { ...lattice.config };
-      const serializedSchema = config2.schema ? serializeSchema(config2.schema) : void 0;
+      const config = { ...lattice.config };
+      const serializedSchema = config.schema ? serializeSchema(config.schema) : void 0;
       return {
         id: lattice.key,
-        name: config2.name,
-        description: config2.description,
+        name: config.name,
+        description: config.description,
         schema: serializedSchema,
-        returnDirect: config2.returnDirect,
-        needUserApprove: config2.needUserApprove
+        returnDirect: config.returnDirect,
+        needUserApprove: config.needUserApprove
       };
     });
     return reply.send({
@@ -2871,8 +2796,8 @@ async function getDatabaseConfig(request, reply) {
   try {
     const storeLattice = (0, import_core17.getStoreLattice)("default", "database");
     const store = storeLattice.store;
-    const config2 = await store.getConfigByKey(tenantId, key);
-    if (!config2) {
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
       return {
         success: false,
         message: "Database configuration not found"
@@ -2881,7 +2806,7 @@ async function getDatabaseConfig(request, reply) {
     return {
       success: true,
       message: "Database configuration retrieved successfully",
-      data: config2
+      data: config
     };
   } catch (error) {
     console.error("Failed to get database config:", error);
@@ -2906,9 +2831,9 @@ async function createDatabaseConfig(request, reply) {
       };
     }
     const id = body.id || (0, import_crypto3.randomUUID)();
-    const config2 = await store.createConfig(tenantId, id, body);
+    const config = await store.createConfig(tenantId, id, body);
     try {
-      import_core17.sqlDatabaseManager.registerDatabase(config2.key, config2.config);
+      import_core17.sqlDatabaseManager.registerDatabase(config.key, config.config);
     } catch (error) {
       console.warn("Failed to auto-register database:", error);
     }
@@ -2916,7 +2841,7 @@ async function createDatabaseConfig(request, reply) {
     return {
       success: true,
       message: "Database configuration created successfully",
-      data: config2
+      data: config
     };
   } catch (error) {
     console.error("Failed to create database config:", error);
@@ -2975,23 +2900,23 @@ async function deleteDatabaseConfig(request, reply) {
     const storeLattice = (0, import_core17.getStoreLattice)("default", "database");
     const store = storeLattice.store;
     console.log("Delete request - keyOrId:", keyOrId);
-    let config2 = await store.getConfigByKey(tenantId, keyOrId);
+    let config = await store.getConfigByKey(tenantId, keyOrId);
     let configKey = keyOrId;
-    if (!config2) {
-      config2 = await store.getConfigById(tenantId, keyOrId);
-      if (config2) {
-        configKey = config2.key;
+    if (!config) {
+      config = await store.getConfigById(tenantId, keyOrId);
+      if (config) {
+        configKey = config.key;
       }
     }
-    if (!config2) {
+    if (!config) {
       reply.code(404);
       return {
         success: false,
         message: "Database configuration not found"
       };
     }
-    console.log("Found config to delete:", { id: config2.id, key: config2.key });
-    const deleted = await store.deleteConfig(tenantId, config2.id);
+    console.log("Found config to delete:", { id: config.id, key: config.key });
+    const deleted = await store.deleteConfig(tenantId, config.id);
     if (!deleted) {
       return {
         success: false,
@@ -3023,8 +2948,8 @@ async function testDatabaseConnection(request, reply) {
   try {
     const storeLattice = (0, import_core17.getStoreLattice)("default", "database");
     const store = storeLattice.store;
-    const config2 = await store.getConfigByKey(tenantId, key);
-    if (!config2) {
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
       reply.code(404);
       return {
         success: false,
@@ -3032,7 +2957,7 @@ async function testDatabaseConnection(request, reply) {
       };
     }
     const testKey = `__test_${key}_${Date.now()}`;
-    import_core17.sqlDatabaseManager.registerDatabase(testKey, config2.config);
+    import_core17.sqlDatabaseManager.registerDatabase(testKey, config.config);
     const startTime = Date.now();
     const db = import_core17.sqlDatabaseManager.getDatabase(testKey);
     try {
@@ -3142,8 +3067,8 @@ async function getMetricsServerConfig(request, reply) {
   try {
     const storeLattice = (0, import_core18.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
-    const config2 = await store.getConfigByKey(tenantId, key);
-    if (!config2) {
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
       return {
         success: false,
         message: "Metrics server configuration not found"
@@ -3152,7 +3077,7 @@ async function getMetricsServerConfig(request, reply) {
     return {
       success: true,
       message: "Metrics server configuration retrieved successfully",
-      data: config2
+      data: config
     };
   } catch (error) {
     console.error("Failed to get metrics server config:", error);
@@ -3193,9 +3118,9 @@ async function createMetricsServerConfig(request, reply) {
         selectedDataSources: body.selectedDataSources || []
       } : body.config
     };
-    const config2 = await store.createConfig(tenantId, id, configData);
+    const config = await store.createConfig(tenantId, id, configData);
     try {
-      import_core18.metricsServerManager.registerServer(config2.key, config2.config);
+      import_core18.metricsServerManager.registerServer(config.key, config.config);
     } catch (error) {
       console.warn("Failed to auto-register metrics server:", error);
     }
@@ -3203,7 +3128,7 @@ async function createMetricsServerConfig(request, reply) {
     return {
       success: true,
       message: "Metrics server configuration created successfully",
-      data: config2
+      data: config
     };
   } catch (error) {
     console.error("Failed to create metrics server config:", error);
@@ -3270,22 +3195,22 @@ async function deleteMetricsServerConfig(request, reply) {
   try {
     const storeLattice = (0, import_core18.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
-    let config2 = await store.getConfigByKey(tenantId, keyOrId);
+    let config = await store.getConfigByKey(tenantId, keyOrId);
     let configKey = keyOrId;
-    if (!config2) {
-      config2 = await store.getConfigById(tenantId, keyOrId);
-      if (config2) {
-        configKey = config2.key;
+    if (!config) {
+      config = await store.getConfigById(tenantId, keyOrId);
+      if (config) {
+        configKey = config.key;
       }
     }
-    if (!config2) {
+    if (!config) {
       reply.code(404);
       return {
         success: false,
         message: "Metrics server configuration not found"
       };
     }
-    const deleted = await store.deleteConfig(tenantId, config2.id);
+    const deleted = await store.deleteConfig(tenantId, config.id);
     if (!deleted) {
       return {
         success: false,
@@ -3317,8 +3242,8 @@ async function testMetricsServerConnection(request, reply) {
   try {
     const storeLattice = (0, import_core18.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
-    const config2 = await store.getConfigByKey(tenantId, key);
-    if (!config2) {
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
       reply.code(404);
       return {
         success: false,
@@ -3326,7 +3251,7 @@ async function testMetricsServerConnection(request, reply) {
       };
     }
     const testKey = `__test_${key}_${Date.now()}`;
-    import_core18.metricsServerManager.registerServer(testKey, config2.config);
+    import_core18.metricsServerManager.registerServer(testKey, config.config);
     try {
       const client = import_core18.metricsServerManager.getClient(testKey);
       const result = await client.testConnection();
@@ -3368,8 +3293,8 @@ async function listAvailableMetrics(request, reply) {
   try {
     const storeLattice = (0, import_core18.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
-    const config2 = await store.getConfigByKey(tenantId, key);
-    if (!config2) {
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
       reply.code(404);
       return {
         success: false,
@@ -3377,7 +3302,7 @@ async function listAvailableMetrics(request, reply) {
       };
     }
     if (!import_core18.metricsServerManager.hasServer(key)) {
-      import_core18.metricsServerManager.registerServer(key, config2.config);
+      import_core18.metricsServerManager.registerServer(key, config.config);
     }
     const client = import_core18.metricsServerManager.getClient(key);
     const metrics = await client.listMetrics();
@@ -3407,8 +3332,8 @@ async function queryMetricsData(request, reply) {
   try {
     const storeLattice = (0, import_core18.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
-    const config2 = await store.getConfigByKey(tenantId, key);
-    if (!config2) {
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
       reply.code(404);
       return {
         success: false,
@@ -3423,7 +3348,7 @@ async function queryMetricsData(request, reply) {
       };
     }
     if (!import_core18.metricsServerManager.hasServer(key)) {
-      import_core18.metricsServerManager.registerServer(key, config2.config);
+      import_core18.metricsServerManager.registerServer(key, config.config);
     }
     const client = import_core18.metricsServerManager.getClient(key);
     const result = await client.queryMetricData(metricName, {
@@ -3454,22 +3379,22 @@ async function getDataSources(request, reply) {
   try {
     const storeLattice = (0, import_core18.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
-    const config2 = await store.getConfigByKey(tenantId, key);
-    if (!config2) {
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
       reply.code(404);
       return {
         success: false,
         message: "Metrics server configuration not found"
       };
     }
-    if (config2.config.type !== "semantic") {
+    if (config.config.type !== "semantic") {
       reply.code(400);
       return {
         success: false,
         message: "This endpoint is only available for semantic metrics servers"
       };
     }
-    const semanticConfig = config2.config;
+    const semanticConfig = config.config;
     const client = new import_core18.SemanticMetricsClient(semanticConfig);
     const datasources = await client.getDataSources();
     return {
@@ -3493,22 +3418,22 @@ async function getDatasourceMetrics(request, reply) {
   try {
     const storeLattice = (0, import_core18.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
-    const config2 = await store.getConfigByKey(tenantId, key);
-    if (!config2) {
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
       reply.code(404);
       return {
         success: false,
         message: "Metrics server configuration not found"
       };
     }
-    if (config2.config.type !== "semantic") {
+    if (config.config.type !== "semantic") {
       reply.code(400);
       return {
         success: false,
         message: "This endpoint is only available for semantic metrics servers"
       };
     }
-    const semanticConfig = config2.config;
+    const semanticConfig = config.config;
     const client = new import_core18.SemanticMetricsClient(semanticConfig);
     const metrics = await client.getDatasourceMetrics(datasourceId);
     return {
@@ -3531,15 +3456,15 @@ async function querySemanticMetrics(request, reply) {
   try {
     const storeLattice = (0, import_core18.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
-    const config2 = await store.getConfigByKey(tenantId, key);
-    if (!config2) {
+    const config = await store.getConfigByKey(tenantId, key);
+    if (!config) {
       reply.code(404);
       return {
         success: false,
         message: "Metrics server configuration not found"
       };
     }
-    if (config2.config.type !== "semantic") {
+    if (config.config.type !== "semantic") {
       reply.code(400);
       return {
         success: false,
@@ -3553,7 +3478,7 @@ async function querySemanticMetrics(request, reply) {
         message: "datasourceId and metrics array are required"
       };
     }
-    const semanticConfig = config2.config;
+    const semanticConfig = config.config;
     const client = new import_core18.SemanticMetricsClient(semanticConfig);
     const result = await client.semanticQuery(body);
     return {
@@ -3659,12 +3584,437 @@ function registerMetricsServerConfigRoutes(app2) {
   app2.post("/api/metrics-configs/test-datasources/:datasourceId/meta", testDatasourceMetrics);
 }
 
-// src/controllers/users.ts
+// src/controllers/mcp-configs.ts
 var import_core19 = require("@axiom-lattice/core");
+var import_crypto5 = require("crypto");
+function getTenantId3(request) {
+  return request.headers["x-tenant-id"] || "default";
+}
+async function getMcpServerConfigList(request, reply) {
+  const tenantId = getTenantId3(request);
+  try {
+    const storeLattice = (0, import_core19.getStoreLattice)("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 = (0, import_core19.getStoreLattice)("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 = (0, import_core19.getStoreLattice)("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 || (0, import_crypto5.randomUUID)();
+    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 = (0, import_core19.getStoreLattice)("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 (import_core19.mcpManager.hasServer(key)) {
+          await import_core19.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 = (0, import_core19.getStoreLattice)("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 (import_core19.mcpManager.hasServer(configKey)) {
+        await import_core19.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 = (0, import_core19.getStoreLattice)("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);
+      import_core19.mcpManager.addServer(testKey, connection);
+      await import_core19.mcpManager.connect();
+      const tools = await import_core19.mcpManager.getAllTools();
+      const latency = Date.now() - startTime;
+      await import_core19.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 = (0, import_core19.getStoreLattice)("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 (!import_core19.mcpManager.hasServer(key)) {
+      await connectAndRegisterTools(config);
+    }
+    const tools = await import_core19.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 = (0, import_core19.getStoreLattice)("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 = (0, import_core19.getStoreLattice)("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 = (0, import_core19.getStoreLattice)("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 (import_core19.mcpManager.hasServer(key)) {
+      await import_core19.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);
+    import_core19.mcpManager.addServer(testKey, connection);
+    await import_core19.mcpManager.connect();
+    const tools = await import_core19.mcpManager.getAllTools();
+    await import_core19.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);
+  import_core19.mcpManager.addServer(config.key, connection);
+  await import_core19.mcpManager.connect();
+  const allTools = await import_core19.mcpManager.getAllTools();
+  const selectedTools = allTools.filter(
+    (tool) => config.selectedTools.includes(tool.name)
+  );
+  for (const tool of selectedTools) {
+    import_core19.toolLatticeManager.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
+var import_core20 = require("@axiom-lattice/core");
 var import_uuid4 = require("uuid");
 var UsersController = class {
   constructor() {
-    this.userStore = (0, import_core19.getStoreLattice)("default", "user").store;
+    this.userStore = (0, import_core20.getStoreLattice)("default", "user").store;
   }
   async listUsers(request, reply) {
     const { email } = request.query;
@@ -3742,11 +4092,11 @@ function registerUserRoutes(app2) {
 }
 
 // src/controllers/tenants.ts
-var import_core20 = require("@axiom-lattice/core");
+var import_core21 = require("@axiom-lattice/core");
 var import_uuid5 = require("uuid");
 var TenantsController = class {
   constructor() {
-    this.tenantStore = (0, import_core20.getStoreLattice)("default", "tenant").store;
+    this.tenantStore = (0, import_core21.getStoreLattice)("default", "tenant").store;
   }
   // ==================== Tenant CRUD ====================
   async listTenants(request, reply) {
@@ -3810,7 +4160,7 @@ function registerTenantRoutes(app2) {
 }
 
 // src/controllers/auth.ts
-var import_core21 = require("@axiom-lattice/core");
+var import_core22 = require("@axiom-lattice/core");
 var import_uuid6 = require("uuid");
 var defaultAuthConfig = {
   autoApproveUsers: true,
@@ -3818,11 +4168,11 @@ var defaultAuthConfig = {
   tokenExpiration: 86400
 };
 var AuthController = class {
-  constructor(config2 = {}) {
-    this.userStore = (0, import_core21.getStoreLattice)("default", "user").store;
-    this.tenantStore = (0, import_core21.getStoreLattice)("default", "tenant").store;
-    this.userTenantLinkStore = (0, import_core21.getStoreLattice)("default", "userTenantLink").store;
-    this.config = { ...defaultAuthConfig, ...config2 };
+  constructor(config = {}) {
+    this.userStore = (0, import_core22.getStoreLattice)("default", "user").store;
+    this.tenantStore = (0, import_core22.getStoreLattice)("default", "tenant").store;
+    this.userTenantLinkStore = (0, import_core22.getStoreLattice)("default", "userTenantLink").store;
+    this.config = { ...defaultAuthConfig, ...config };
   }
   async register(request, reply) {
     const { email, password, name } = request.body;
@@ -4097,8 +4447,8 @@ var AuthController = class {
     return btoa(JSON.stringify(payload));
   }
 };
-function registerAuthRoutes(app2, config2) {
-  const controller = new AuthController(config2);
+function registerAuthRoutes(app2, config) {
+  const controller = new AuthController(config);
   const authHook = async (request, reply) => {
     const authHeader = request.headers.authorization;
     if (!authHeader || !authHeader.startsWith("Bearer ")) {
@@ -4258,6 +4608,7 @@ var registerLatticeRoutes = (app2) => {
   registerWorkspaceRoutes(app2);
   registerDatabaseConfigRoutes(app2);
   registerMetricsServerConfigRoutes(app2);
+  registerMcpServerConfigRoutes(app2);
   registerUserRoutes(app2);
   registerTenantRoutes(app2);
   registerAuthRoutes(app2, {
@@ -4329,7 +4680,7 @@ var configureSwagger = async (app2, customSwaggerConfig, customSwaggerUiConfig)
 };
 
 // src/services/agent_task_consumer.ts
-var import_core22 = require("@axiom-lattice/core");
+var import_core23 = require("@axiom-lattice/core");
 var handleAgentTask = async (taskRequest, retryCount = 0) => {
   const {
     assistant_id,
@@ -4395,7 +4746,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       }
       if (callback_event) {
         const state = await agent_state({ assistant_id, thread_id });
-        import_core22.eventBus.publish(callback_event, {
+        import_core23.eventBus.publish(callback_event, {
           success: true,
           state,
           config: { assistant_id, thread_id, tenant_id }
@@ -4409,7 +4760,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       await response.text();
       if (callback_event) {
         const state = await agent_state({ assistant_id, thread_id });
-        import_core22.eventBus.publish(callback_event, {
+        import_core23.eventBus.publish(callback_event, {
           success: true,
           state,
           config: { assistant_id, thread_id, tenant_id }
@@ -4436,7 +4787,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       return handleAgentTask(taskRequest, nextRetryCount);
     }
     if (callback_event) {
-      import_core22.eventBus.publish(callback_event, {
+      import_core23.eventBus.publish(callback_event, {
         success: false,
         error: error instanceof Error ? error.message : String(error),
         config: { assistant_id, thread_id, tenant_id }
@@ -4474,7 +4825,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
    * 初始化事件监听和队列轮询
    */
   initialize() {
-    import_core22.eventBus.subscribe(import_core22.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
+    import_core23.eventBus.subscribe(import_core23.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
     this.startPollingQueue();
     console.log("Agent\u4EFB\u52A1\u6D88\u8D39\u8005\u5DF2\u542F\u52A8\u5E76\u76D1\u542C\u4EFB\u52A1\u4E8B\u4EF6\u548C\u961F\u5217");
   }
@@ -4593,7 +4944,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
     handleAgentTask(taskRequest).catch((error) => {
       console.error("\u5904\u7406Agent\u4EFB\u52A1\u65F6\u53D1\u751F\u672A\u6355\u83B7\u7684\u9519\u8BEF:", error);
       if (taskRequest.callback_event) {
-        import_core22.eventBus.publish(taskRequest.callback_event, {
+        import_core23.eventBus.publish(taskRequest.callback_event, {
           success: false,
           error: error instanceof Error ? error.message : String(error),
           config: {
@@ -4613,7 +4964,7 @@ _AgentTaskConsumer.agent_run_endpoint = "http://localhost:4001/api/runs";
 var AgentTaskConsumer = _AgentTaskConsumer;
 
 // src/index.ts
-var import_core23 = require("@axiom-lattice/core");
+var import_core24 = require("@axiom-lattice/core");
 var import_protocols2 = require("@axiom-lattice/protocols");
 process.on("unhandledRejection", (reason, promise) => {
   console.error("\u672A\u5904\u7406\u7684Promise\u62D2\u7EDD:", reason);
@@ -4627,12 +4978,12 @@ var DEFAULT_LOGGER_CONFIG = {
 };
 var loggerLattice = initializeLogger(DEFAULT_LOGGER_CONFIG);
 var logger = loggerLattice.client;
-function initializeLogger(config2) {
-  if (import_core23.loggerLatticeManager.hasLattice("default")) {
-    import_core23.loggerLatticeManager.removeLattice("default");
+function initializeLogger(config) {
+  if (import_core24.loggerLatticeManager.hasLattice("default")) {
+    import_core24.loggerLatticeManager.removeLattice("default");
   }
-  (0, import_core23.registerLoggerLattice)("default", config2);
-  return (0, import_core23.getLoggerLattice)("default");
+  (0, import_core24.registerLoggerLattice)("default", config);
+  return (0, import_core24.getLoggerLattice)("default");
 }
 var app = (0, import_fastify.default)({
   logger: false,
@@ -4709,23 +5060,23 @@ app.setErrorHandler((error, request, reply) => {
     error: error.message || "\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF"
   });
 });
-var start = async (config2) => {
+var start = async (config) => {
   try {
-    if (config2?.loggerConfig) {
+    if (config?.loggerConfig) {
       const loggerConfig = {
         ...DEFAULT_LOGGER_CONFIG,
-        ...config2.loggerConfig,
+        ...config.loggerConfig,
         // Merge file config if provided
-        file: config2.loggerConfig.file || DEFAULT_LOGGER_CONFIG.file
+        file: config.loggerConfig.file || DEFAULT_LOGGER_CONFIG.file
       };
       loggerLattice = initializeLogger(loggerConfig);
       logger = loggerLattice.client;
     }
     app.decorate("loggerLattice", loggerLattice);
-    const target_port = config2?.port || Number(process.env.PORT) || 4001;
+    const target_port = config?.port || Number(process.env.PORT) || 4001;
     await app.listen({ port: target_port, host: "0.0.0.0" });
     logger.info(`Lattice Gateway is running on port: ${target_port}`);
-    const queueServiceConfig = config2?.queueServiceConfig;
+    const queueServiceConfig = config?.queueServiceConfig;
     if (queueServiceConfig) {
       setQueueServiceType(queueServiceConfig.type);
       if (queueServiceConfig.defaultStartPollingQueue) {