@axiom-lattice/gateway 2.1.35 → 2.1.37

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,29 +3379,31 @@ 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();
+    const allDatasources = await client.getDataSources();
+    const selectedIds = semanticConfig.selectedDataSources || [];
+    const filteredDatasources = selectedIds.length > 0 ? allDatasources.filter((ds) => selectedIds.includes(String(ds.id))) : allDatasources;
     return {
       success: true,
       message: "Data sources retrieved successfully",
       data: {
-        datasources
+        datasources: filteredDatasources
       }
     };
   } catch (error) {
@@ -3493,22 +3420,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 +3458,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 +3480,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 {
@@ -3697,8 +3624,8 @@ async function getMcpServerConfig(request, reply) {
   try {
     const storeLattice = (0, import_core19.getStoreLattice)("default", "mcp");
     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: "MCP server configuration not found"
@@ -3707,7 +3634,7 @@ async function getMcpServerConfig(request, reply) {
     return {
       success: true,
       message: "MCP server configuration retrieved successfully",
-      data: config2
+      data: config
     };
   } catch (error) {
     console.error("Failed to get MCP server config:", error);
@@ -3732,21 +3659,21 @@ async function createMcpServerConfig(request, reply) {
       };
     }
     const id = body.id || (0, import_crypto5.randomUUID)();
-    const config2 = await store.createConfig(tenantId, id, body);
+    const config = await store.createConfig(tenantId, id, body);
     try {
-      await connectAndRegisterTools(config2);
+      await connectAndRegisterTools(config);
       await store.updateConfig(tenantId, id, { status: "connected" });
-      config2.status = "connected";
+      config.status = "connected";
     } catch (error) {
       console.warn("Failed to auto-connect MCP server:", error);
       await store.updateConfig(tenantId, id, { status: "error" });
-      config2.status = "error";
+      config.status = "error";
     }
     reply.code(201);
     return {
       success: true,
       message: "MCP server configuration created successfully",
-      data: config2
+      data: config
     };
   } catch (error) {
     console.error("Failed to create MCP server config:", error);
@@ -3812,15 +3739,15 @@ async function deleteMcpServerConfig(request, reply) {
   try {
     const storeLattice = (0, import_core19.getStoreLattice)("default", "mcp");
     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,
@@ -3834,7 +3761,7 @@ async function deleteMcpServerConfig(request, reply) {
     } catch (error) {
       console.warn("Failed to remove from MCP manager:", error);
     }
-    const deleted = await store.deleteConfig(tenantId, config2.id);
+    const deleted = await store.deleteConfig(tenantId, config.id);
     if (!deleted) {
       return {
         success: false,
@@ -3859,8 +3786,8 @@ async function testMcpServerConnection(request, reply) {
   try {
     const storeLattice = (0, import_core19.getStoreLattice)("default", "mcp");
     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,
@@ -3870,7 +3797,7 @@ async function testMcpServerConnection(request, reply) {
     const startTime = Date.now();
     try {
       const testKey = `__test_${key}_${Date.now()}`;
-      const connection = convertToConnection(config2.config);
+      const connection = convertToConnection(config.config);
       import_core19.mcpManager.addServer(testKey, connection);
       await import_core19.mcpManager.connect();
       const tools = await import_core19.mcpManager.getAllTools();
@@ -3912,8 +3839,8 @@ async function listMcpServerTools(request, reply) {
   try {
     const storeLattice = (0, import_core19.getStoreLattice)("default", "mcp");
     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,
@@ -3921,7 +3848,7 @@ async function listMcpServerTools(request, reply) {
       };
     }
     if (!import_core19.mcpManager.hasServer(key)) {
-      await connectAndRegisterTools(config2);
+      await connectAndRegisterTools(config);
     }
     const tools = await import_core19.mcpManager.getAllTools();
     return {
@@ -3945,30 +3872,30 @@ async function connectMcpServer(request, reply) {
   try {
     const storeLattice = (0, import_core19.getStoreLattice)("default", "mcp");
     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: "MCP server configuration not found"
       };
     }
-    await connectAndRegisterTools(config2);
-    const updated = await store.updateConfig(tenantId, config2.id, {
+    await connectAndRegisterTools(config);
+    const updated = await store.updateConfig(tenantId, config.id, {
       status: "connected"
     });
     return {
       success: true,
       message: "MCP server connected successfully",
-      data: updated || config2
+      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 config2 = await store.getConfigByKey(tenantId, key);
-    if (config2) {
-      await store.updateConfig(tenantId, config2.id, { status: "error" });
+    const config = await store.getConfigByKey(tenantId, key);
+    if (config) {
+      await store.updateConfig(tenantId, config.id, { status: "error" });
     }
     return {
       success: false,
@@ -3982,8 +3909,8 @@ async function disconnectMcpServer(request, reply) {
   try {
     const storeLattice = (0, import_core19.getStoreLattice)("default", "mcp");
     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,
@@ -3993,13 +3920,13 @@ async function disconnectMcpServer(request, reply) {
     if (import_core19.mcpManager.hasServer(key)) {
       await import_core19.mcpManager.removeServer(key);
     }
-    const updated = await store.updateConfig(tenantId, config2.id, {
+    const updated = await store.updateConfig(tenantId, config.id, {
       status: "disconnected"
     });
     return {
       success: true,
       message: "MCP server disconnected successfully",
-      data: updated || config2
+      data: updated || config
     };
   } catch (error) {
     console.error("Failed to disconnect MCP server:", error);
@@ -4040,32 +3967,32 @@ async function testMcpServerTools(request, reply) {
     };
   }
 }
-function convertToConnection(config2) {
+function convertToConnection(config) {
   const baseConfig = {
-    env: config2.env
+    env: config.env
   };
-  if (config2.transport === "stdio") {
+  if (config.transport === "stdio") {
     return {
       ...baseConfig,
       transport: "stdio",
-      command: config2.command,
-      args: config2.args || []
+      command: config.command,
+      args: config.args || []
     };
   } else {
     return {
       ...baseConfig,
-      transport: config2.transport === "streamable_http" ? "http" : config2.transport,
-      url: config2.url
+      transport: config.transport === "streamable_http" ? "http" : config.transport,
+      url: config.url
     };
   }
 }
-async function connectAndRegisterTools(config2) {
-  const connection = convertToConnection(config2.config);
-  import_core19.mcpManager.addServer(config2.key, connection);
+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) => config2.selectedTools.includes(tool.name)
+    (tool) => config.selectedTools.includes(tool.name)
   );
   for (const tool of selectedTools) {
     import_core19.toolLatticeManager.registerExistingTool(tool.name, tool);
@@ -4243,11 +4170,11 @@ var defaultAuthConfig = {
   tokenExpiration: 86400
 };
 var AuthController = class {
-  constructor(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, ...config2 };
+    this.config = { ...defaultAuthConfig, ...config };
   }
   async register(request, reply) {
     const { email, password, name } = request.body;
@@ -4522,8 +4449,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 ")) {
@@ -5053,11 +4980,11 @@ var DEFAULT_LOGGER_CONFIG = {
 };
 var loggerLattice = initializeLogger(DEFAULT_LOGGER_CONFIG);
 var logger = loggerLattice.client;
-function initializeLogger(config2) {
+function initializeLogger(config) {
   if (import_core24.loggerLatticeManager.hasLattice("default")) {
     import_core24.loggerLatticeManager.removeLattice("default");
   }
-  (0, import_core24.registerLoggerLattice)("default", config2);
+  (0, import_core24.registerLoggerLattice)("default", config);
   return (0, import_core24.getLoggerLattice)("default");
 }
 var app = (0, import_fastify.default)({
@@ -5135,23 +5062,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) {