@axiom-lattice/gateway 2.1.33 → 2.1.35

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @axiom-lattice/gateway@2.1.33 build /home/runner/work/agentic/agentic/packages/gateway
+> @axiom-lattice/gateway@2.1.35 build /home/runner/work/agentic/agentic/packages/gateway
 > tsup src/index.ts --format cjs,esm --dts --clean --sourcemap
 
 CLI Building entry: src/index.ts
@@ -9,17 +9,17 @@
 CLI Cleaning output folder
 CJS Build start
 ESM Build start
-CJS dist/index.js     145.49 KB
-CJS dist/index.js.map 316.71 KB
-CJS ⚡️ Build success in 261ms
-ESM dist/index.mjs               138.98 KB
+CJS dist/index.js     158.56 KB
+CJS dist/index.js.map 342.90 KB
+CJS ⚡️ Build success in 299ms
+ESM dist/index.mjs               151.63 KB
 ESM dist/config-F3FCBSPH.mjs     148.00 B
 ESM dist/chunk-FSASG3SB.mjs      2.46 KB
-ESM dist/index.mjs.map           311.30 KB
+ESM dist/index.mjs.map           337.48 KB
 ESM dist/config-F3FCBSPH.mjs.map 71.00 B
 ESM dist/chunk-FSASG3SB.mjs.map  5.33 KB
-ESM ⚡️ Build success in 262ms
+ESM ⚡️ Build success in 309ms
 DTS Build start
-DTS ⚡️ Build success in 9721ms
+DTS ⚡️ Build success in 10351ms
 DTS dist/index.d.ts  3.76 KB
 DTS dist/index.d.mts 3.76 KB

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @axiom-lattice/gateway
 
+## 2.1.35
+
+### Patch Changes
+
+- 078a297: update team ui
+- Updated dependencies [078a297]
+  - @axiom-lattice/protocols@2.1.17
+  - @axiom-lattice/core@2.1.30
+  - @axiom-lattice/queue-redis@1.0.16
+
+## 2.1.34
+
+### Patch Changes
+
+- Updated dependencies [07fc87d]
+  - @axiom-lattice/core@2.1.29
+
 ## 2.1.33
 
 ### Patch Changes

package/dist/index.js

@@ -3659,12 +3659,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 config2 = await store.getConfigByKey(tenantId, key);
+    if (!config2) {
+      return {
+        success: false,
+        message: "MCP server configuration not found"
+      };
+    }
+    return {
+      success: true,
+      message: "MCP server configuration retrieved successfully",
+      data: config2
+    };
+  } 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 config2 = await store.createConfig(tenantId, id, body);
+    try {
+      await connectAndRegisterTools(config2);
+      await store.updateConfig(tenantId, id, { status: "connected" });
+      config2.status = "connected";
+    } catch (error) {
+      console.warn("Failed to auto-connect MCP server:", error);
+      await store.updateConfig(tenantId, id, { status: "error" });
+      config2.status = "error";
+    }
+    reply.code(201);
+    return {
+      success: true,
+      message: "MCP server configuration created successfully",
+      data: config2
+    };
+  } 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 config2 = await store.getConfigByKey(tenantId, keyOrId);
+    let configKey = keyOrId;
+    if (!config2) {
+      config2 = await store.getConfigById(tenantId, keyOrId);
+      if (config2) {
+        configKey = config2.key;
+      }
+    }
+    if (!config2) {
+      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, config2.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 config2 = await store.getConfigByKey(tenantId, key);
+    if (!config2) {
+      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(config2.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 config2 = await store.getConfigByKey(tenantId, key);
+    if (!config2) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "MCP server configuration not found"
+      };
+    }
+    if (!import_core19.mcpManager.hasServer(key)) {
+      await connectAndRegisterTools(config2);
+    }
+    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 config2 = await store.getConfigByKey(tenantId, key);
+    if (!config2) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "MCP server configuration not found"
+      };
+    }
+    await connectAndRegisterTools(config2);
+    const updated = await store.updateConfig(tenantId, config2.id, {
+      status: "connected"
+    });
+    return {
+      success: true,
+      message: "MCP server connected successfully",
+      data: updated || config2
+    };
+  } 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" });
+    }
+    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 config2 = await store.getConfigByKey(tenantId, key);
+    if (!config2) {
+      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, config2.id, {
+      status: "disconnected"
+    });
+    return {
+      success: true,
+      message: "MCP server disconnected successfully",
+      data: updated || config2
+    };
+  } 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(config2) {
+  const baseConfig = {
+    env: config2.env
+  };
+  if (config2.transport === "stdio") {
+    return {
+      ...baseConfig,
+      transport: "stdio",
+      command: config2.command,
+      args: config2.args || []
+    };
+  } else {
+    return {
+      ...baseConfig,
+      transport: config2.transport === "streamable_http" ? "http" : config2.transport,
+      url: config2.url
+    };
+  }
+}
+async function connectAndRegisterTools(config2) {
+  const connection = convertToConnection(config2.config);
+  import_core19.mcpManager.addServer(config2.key, connection);
+  await import_core19.mcpManager.connect();
+  const allTools = await import_core19.mcpManager.getAllTools();
+  const selectedTools = allTools.filter(
+    (tool) => config2.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 +4167,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 +4235,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,
@@ -3819,9 +4244,9 @@ var defaultAuthConfig = {
 };
 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.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 };
   }
   async register(request, reply) {
@@ -4258,6 +4683,7 @@ var registerLatticeRoutes = (app2) => {
   registerWorkspaceRoutes(app2);
   registerDatabaseConfigRoutes(app2);
   registerMetricsServerConfigRoutes(app2);
+  registerMcpServerConfigRoutes(app2);
   registerUserRoutes(app2);
   registerTenantRoutes(app2);
   registerAuthRoutes(app2, {
@@ -4329,7 +4755,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 +4821,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 +4835,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 +4862,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 +4900,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 +5019,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 +5039,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);
@@ -4628,11 +5054,11 @@ 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");
+  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", config2);
+  return (0, import_core24.getLoggerLattice)("default");
 }
 var app = (0, import_fastify.default)({
   logger: false,