@axiom-lattice/gateway 2.1.12 → 2.1.14

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @axiom-lattice/gateway@2.1.12 build /home/runner/work/agentic/agentic/packages/gateway
+> @axiom-lattice/gateway@2.1.14 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,13 +9,13 @@
 CLI Cleaning output folder
 CJS Build start
 ESM Build start
-ESM dist/index.mjs     46.92 KB
-ESM dist/index.mjs.map 100.58 KB
-ESM ⚡️ Build success in 131ms
-CJS dist/index.js     49.24 KB
-CJS dist/index.js.map 100.67 KB
-CJS ⚡️ Build success in 131ms
+ESM dist/index.mjs     56.17 KB
+ESM dist/index.mjs.map 121.06 KB
+ESM ⚡️ Build success in 149ms
+CJS dist/index.js     58.53 KB
+CJS dist/index.js.map 121.16 KB
+CJS ⚡️ Build success in 153ms
 DTS Build start
-DTS ⚡️ Build success in 7072ms
+DTS ⚡️ Build success in 7922ms
 DTS dist/index.d.ts  3.32 KB
 DTS dist/index.d.mts 3.32 KB

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @axiom-lattice/gateway
 
+## 2.1.14
+
+### Patch Changes
+
+- 38cc75d: change shell menu collapse
+- Updated dependencies [38cc75d]
+  - @axiom-lattice/queue-redis@1.0.4
+  - @axiom-lattice/protocols@2.1.5
+  - @axiom-lattice/core@2.1.10
+
+## 2.1.13
+
+### Patch Changes
+
+- d9beb3a: update setting
+- Updated dependencies [d9beb3a]
+  - @axiom-lattice/core@2.1.9
+  - @axiom-lattice/protocols@2.1.4
+  - @axiom-lattice/queue-redis@1.0.3
+
 ## 2.1.12
 
 ### Patch Changes

package/README.md

@@ -29,6 +29,59 @@ pnpm start
 
 ## API 接口
 
+### Configuration API
+
+The gateway supports dynamic configuration updates via JSON. You can update environment variables at runtime without restarting the server.
+
+#### Get Configuration
+
+```bash
+GET /api/config
+```
+
+Returns the current configuration (sensitive values are masked).
+
+#### Update Configuration
+
+```bash
+PUT /api/config
+Content-Type: application/json
+
+{
+  "config": {
+    "port": 4001,
+    "queueServiceType": "redis",
+    "redisUrl": "redis://localhost:6379",
+    "redisPassword": "your-password",
+    "queueName": "tasks"
+  }
+}
+```
+
+**Note**: When updating `queueServiceType`, the queue service will be automatically reconfigured.
+
+**Example**:
+
+```typescript
+// Update configuration from frontend
+const response = await fetch("http://localhost:4001/api/config", {
+  method: "PUT",
+  headers: {
+    "Content-Type": "application/json",
+  },
+  body: JSON.stringify({
+    config: {
+      queueServiceType: "redis",
+      redisUrl: "redis://localhost:6379",
+      redisPassword: "your-password",
+    },
+  }),
+});
+
+const result = await response.json();
+console.log(result); // { success: true, message: "Configuration updated successfully", data: {...} }
+```
+
 ### 代理调用
 
 - `POST /api/v1/run`: 运行代理

package/dist/index.js

@@ -952,6 +952,296 @@ async function deleteThread(request, reply) {
   };
 }
 
+// src/config.ts
+var ConfigService = class {
+  constructor() {
+    this.config = this.loadFromEnv();
+  }
+  /**
+   * Load configuration from environment variables
+   */
+  loadFromEnv() {
+    return {
+      port: process.env.PORT ? Number(process.env.PORT) : void 0,
+      queueServiceType: process.env.QUEUE_SERVICE_TYPE,
+      redisUrl: process.env.REDIS_URL,
+      redisPassword: process.env.REDIS_PASSWORD,
+      queueName: process.env.QUEUE_NAME
+    };
+  }
+  /**
+   * Update configuration from JSON object
+   * This will update both the internal config and process.env
+   */
+  updateConfig(jsonConfig) {
+    for (const [key, value] of Object.entries(jsonConfig)) {
+      if (value !== null && value !== void 0) {
+        if (typeof value === "object" && !Array.isArray(value)) {
+          for (const [nestedKey, nestedValue] of Object.entries(value)) {
+            const envKey = `${key.toUpperCase()}_${nestedKey.toUpperCase()}`;
+            process.env[envKey] = String(nestedValue);
+          }
+        } else {
+          process.env[key.toUpperCase()] = String(value);
+        }
+      }
+    }
+    this.config = this.loadFromEnv();
+    this.config = this.deepMerge(this.config, jsonConfig);
+  }
+  /**
+   * Deep merge two objects
+   */
+  deepMerge(target, source) {
+    const output = { ...target };
+    if (this.isObject(target) && this.isObject(source)) {
+      Object.keys(source).forEach((key) => {
+        if (this.isObject(source[key])) {
+          if (!(key in target)) {
+            Object.assign(output, { [key]: source[key] });
+          } else {
+            output[key] = this.deepMerge(target[key], source[key]);
+          }
+        } else {
+          Object.assign(output, { [key]: source[key] });
+        }
+      });
+    }
+    return output;
+  }
+  /**
+   * Check if value is a plain object
+   */
+  isObject(item) {
+    return item && typeof item === "object" && !Array.isArray(item);
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+var configService = new ConfigService();
+
+// src/services/queue_service.ts
+var import_core4 = require("@axiom-lattice/core");
+var import_protocols = require("@axiom-lattice/protocols");
+var import_queue_redis = require("@axiom-lattice/queue-redis");
+var DEFAULT_QUEUE_KEY = "default";
+var queueServiceType = process.env.QUEUE_SERVICE_TYPE || "memory";
+var setQueueServiceType = (type) => {
+  queueServiceType = type;
+  console.log(`Queue service type set to: ${type}`);
+  const queueName = process.env.QUEUE_NAME || "tasks";
+  const config = {
+    name: "Default Queue Service",
+    description: `Default ${type} queue service`,
+    type: type === "redis" ? import_protocols.QueueType.REDIS : import_protocols.QueueType.MEMORY,
+    queueName,
+    options: type === "redis" ? {
+      redisUrl: process.env.REDIS_URL,
+      redisPassword: process.env.REDIS_PASSWORD
+    } : void 0
+  };
+  if (import_core4.queueLatticeManager.hasLattice(DEFAULT_QUEUE_KEY)) {
+    import_core4.queueLatticeManager.removeLattice(DEFAULT_QUEUE_KEY);
+  }
+  let client;
+  if (type === "redis") {
+    client = new import_queue_redis.RedisQueueClient(queueName, {
+      redisUrl: process.env.REDIS_URL,
+      redisPassword: process.env.REDIS_PASSWORD
+    });
+  }
+  (0, import_core4.registerQueueLattice)(DEFAULT_QUEUE_KEY, config, client);
+};
+var getQueueService = () => {
+  if (!import_core4.queueLatticeManager.hasLattice(DEFAULT_QUEUE_KEY)) {
+    setQueueServiceType(queueServiceType);
+  }
+  return (0, import_core4.getQueueLattice)(DEFAULT_QUEUE_KEY);
+};
+var popAgentTaskFromQueue = async () => {
+  const queue = getQueueService();
+  const result = await queue.pop();
+  return result;
+};
+
+// src/controllers/config.ts
+async function updateConfig(request, reply) {
+  try {
+    const { config: jsonConfig } = request.body;
+    if (!jsonConfig || typeof jsonConfig !== "object") {
+      return reply.status(400).send({
+        success: false,
+        error: "Invalid configuration: config must be an object"
+      });
+    }
+    configService.updateConfig(jsonConfig);
+    const warnings = [];
+    const requiresRestart = [];
+    if (jsonConfig.port !== void 0) {
+      requiresRestart.push("PORT");
+      warnings.push("Port change requires server restart to take effect");
+    }
+    if (jsonConfig.queueServiceType) {
+      setQueueServiceType(jsonConfig.queueServiceType);
+    }
+    if ((jsonConfig.redisUrl || jsonConfig.redisPassword) && (process.env.QUEUE_SERVICE_TYPE === "redis" || jsonConfig.queueServiceType === "redis")) {
+      const currentType = jsonConfig.queueServiceType || process.env.QUEUE_SERVICE_TYPE || "memory";
+      if (currentType === "redis") {
+        setQueueServiceType("redis");
+      }
+    }
+    const updatedConfig = configService.getConfig();
+    const safeConfig = {
+      ...updatedConfig,
+      redisPassword: updatedConfig.redisPassword ? "***" : updatedConfig.redisPassword
+    };
+    return reply.send({
+      success: true,
+      message: "Configuration updated successfully",
+      data: safeConfig,
+      warnings: warnings.length > 0 ? warnings : void 0,
+      requiresRestart: requiresRestart.length > 0 ? requiresRestart : void 0
+    });
+  } catch (error) {
+    console.error("Failed to update configuration", {
+      error: error.message,
+      stack: error.stack
+    });
+    return reply.status(500).send({
+      success: false,
+      error: error.message || "Failed to update configuration"
+    });
+  }
+}
+async function getConfig(request, reply) {
+  try {
+    const currentConfig = configService.getConfig();
+    const safeConfig = {
+      ...currentConfig,
+      redisPassword: currentConfig.redisPassword ? "***" : currentConfig.redisPassword
+    };
+    return reply.send({
+      success: true,
+      data: safeConfig
+    });
+  } catch (error) {
+    console.error("Failed to get configuration", {
+      error: error.message,
+      stack: error.stack
+    });
+    return reply.status(500).send({
+      success: false,
+      error: error.message || "Failed to get configuration"
+    });
+  }
+}
+
+// src/controllers/models.ts
+var import_core5 = require("@axiom-lattice/core");
+async function getModels(request, reply) {
+  try {
+    const allLattices = import_core5.modelLatticeManager.getAllLattices();
+    const models = allLattices.map((lattice) => {
+      const config = lattice.client.config || {};
+      return {
+        key: lattice.key,
+        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({
+      success: true,
+      data: models
+    });
+  } catch (error) {
+    console.error("Failed to get models", {
+      error: error.message,
+      stack: error.stack
+    });
+    return reply.status(500).send({
+      success: false,
+      error: error.message || "Failed to get models"
+    });
+  }
+}
+async function updateModels(request, reply) {
+  try {
+    const { models } = request.body;
+    if (!models || !Array.isArray(models)) {
+      return reply.status(400).send({
+        success: false,
+        error: "Invalid request: models must be an array"
+      });
+    }
+    const registeredModels = [];
+    const errors = [];
+    for (const modelConfig of models) {
+      if (!modelConfig.key || !modelConfig.model || !modelConfig.provider) {
+        errors.push(
+          `Model configuration is incomplete: key, model, and provider are required`
+        );
+        continue;
+      }
+      try {
+        if (import_core5.modelLatticeManager.hasLattice(modelConfig.key)) {
+          import_core5.modelLatticeManager.removeLattice(modelConfig.key);
+        }
+        const llmConfig = {
+          provider: modelConfig.provider,
+          model: modelConfig.model,
+          streaming: modelConfig.streaming ?? false,
+          apiKey: modelConfig.apiKey,
+          baseURL: modelConfig.baseURL,
+          maxTokens: modelConfig.maxTokens,
+          temperature: modelConfig.temperature,
+          timeout: modelConfig.timeout,
+          maxRetries: modelConfig.maxRetries
+        };
+        (0, import_core5.registerModelLattice)(modelConfig.key, llmConfig);
+        registeredModels.push(modelConfig.key);
+      } catch (error) {
+        errors.push(
+          `Failed to register model ${modelConfig.key}: ${error.message}`
+        );
+      }
+    }
+    if (errors.length > 0 && registeredModels.length === 0) {
+      return reply.status(400).send({
+        success: false,
+        error: errors.join("; ")
+      });
+    }
+    return reply.send({
+      success: true,
+      message: `Successfully registered ${registeredModels.length} model(s)`,
+      data: {
+        registered: registeredModels,
+        errors: errors.length > 0 ? errors : void 0
+      }
+    });
+  } catch (error) {
+    console.error("Failed to update models", {
+      error: error.message,
+      stack: error.stack
+    });
+    return reply.status(500).send({
+      success: false,
+      error: error.message || "Failed to update models"
+    });
+  }
+}
+
 // src/schemas/index.ts
 var getAllMemoryItemsSchema = {
   description: "Get all memory items for an assistant thread",
@@ -1120,6 +1410,77 @@ var triggerAgentTaskSchema = {
     }
   }
 };
+var updateConfigSchema = {
+  description: "Update gateway configuration",
+  tags: ["Configuration"],
+  summary: "Update Configuration",
+  body: {
+    type: "object",
+    properties: {
+      config: {
+        type: "object",
+        description: "Configuration object to update",
+        properties: {
+          port: { type: "number", description: "Server port" },
+          queueServiceType: {
+            type: "string",
+            enum: ["memory", "redis"],
+            description: "Queue service type"
+          },
+          redisUrl: { type: "string", description: "Redis URL" },
+          redisPassword: { type: "string", description: "Redis password" },
+          queueName: { type: "string", description: "Queue name" }
+        }
+      }
+    },
+    required: ["config"]
+  },
+  response: {
+    200: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        message: { type: "string" },
+        data: { type: "object" }
+      }
+    },
+    400: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        error: { type: "string" }
+      }
+    },
+    500: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        error: { type: "string" }
+      }
+    }
+  }
+};
+var getConfigSchema = {
+  description: "Get current gateway configuration",
+  tags: ["Configuration"],
+  summary: "Get Configuration",
+  response: {
+    200: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        data: { type: "object" }
+      }
+    },
+    500: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        error: { type: "string" }
+      }
+    }
+  }
+};
 
 // src/routes/index.ts
 var registerLatticeRoutes = (app2) => {
@@ -1184,6 +1545,18 @@ var registerLatticeRoutes = (app2) => {
     "/api/assistants/:assistantId/threads/:threadId",
     deleteThread
   );
+  app2.get(
+    "/api/config",
+    { schema: getConfigSchema },
+    getConfig
+  );
+  app2.put(
+    "/api/config",
+    { schema: updateConfigSchema },
+    updateConfig
+  );
+  app2.get("/api/models", getModels);
+  app2.put("/api/models", updateModels);
 };
 
 // src/logger/Logger.ts
@@ -1386,52 +1759,8 @@ var configureSwagger = async (app2, customSwaggerConfig, customSwaggerUiConfig)
   await app2.register(import_swagger_ui.default, swaggerUiConfig);
 };
 
-// src/services/queue_service.ts
-var import_core4 = require("@axiom-lattice/core");
-var import_protocols = require("@axiom-lattice/protocols");
-var import_queue_redis = require("@axiom-lattice/queue-redis");
-var DEFAULT_QUEUE_KEY = "default";
-var queueServiceType = process.env.QUEUE_SERVICE_TYPE || "memory";
-var setQueueServiceType = (type) => {
-  queueServiceType = type;
-  console.log(`Queue service type set to: ${type}`);
-  const queueName = process.env.QUEUE_NAME || "tasks";
-  const config = {
-    name: "Default Queue Service",
-    description: `Default ${type} queue service`,
-    type: type === "redis" ? import_protocols.QueueType.REDIS : import_protocols.QueueType.MEMORY,
-    queueName,
-    options: type === "redis" ? {
-      redisUrl: process.env.REDIS_URL,
-      redisPassword: process.env.REDIS_PASSWORD
-    } : void 0
-  };
-  if (import_core4.queueLatticeManager.hasLattice(DEFAULT_QUEUE_KEY)) {
-    import_core4.queueLatticeManager.removeLattice(DEFAULT_QUEUE_KEY);
-  }
-  let client;
-  if (type === "redis") {
-    client = new import_queue_redis.RedisQueueClient(queueName, {
-      redisUrl: process.env.REDIS_URL,
-      redisPassword: process.env.REDIS_PASSWORD
-    });
-  }
-  (0, import_core4.registerQueueLattice)(DEFAULT_QUEUE_KEY, config, client);
-};
-var getQueueService = () => {
-  if (!import_core4.queueLatticeManager.hasLattice(DEFAULT_QUEUE_KEY)) {
-    setQueueServiceType(queueServiceType);
-  }
-  return (0, import_core4.getQueueLattice)(DEFAULT_QUEUE_KEY);
-};
-var popAgentTaskFromQueue = async () => {
-  const queue = getQueueService();
-  const result = await queue.pop();
-  return result;
-};
-
 // src/services/agent_task_consumer.ts
-var import_core5 = require("@axiom-lattice/core");
+var import_core6 = require("@axiom-lattice/core");
 var handleAgentTask = async (taskRequest, retryCount = 0) => {
   const {
     assistant_id,
@@ -1495,7 +1824,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       }
       if (callback_event) {
         const state = await agent_state({ assistant_id, thread_id });
-        import_core5.eventBus.publish(callback_event, {
+        import_core6.eventBus.publish(callback_event, {
           success: true,
           state,
           config: { assistant_id, thread_id, tenant_id }
@@ -1509,7 +1838,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       await response.text();
       if (callback_event) {
         const state = await agent_state({ assistant_id, thread_id });
-        import_core5.eventBus.publish(callback_event, {
+        import_core6.eventBus.publish(callback_event, {
           success: true,
           state,
           config: { assistant_id, thread_id, tenant_id }
@@ -1536,7 +1865,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       return handleAgentTask(taskRequest, nextRetryCount);
     }
     if (callback_event) {
-      import_core5.eventBus.publish(callback_event, {
+      import_core6.eventBus.publish(callback_event, {
         success: false,
         error: error instanceof Error ? error.message : String(error),
         config: { assistant_id, thread_id, tenant_id }
@@ -1574,7 +1903,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
    * 初始化事件监听和队列轮询
    */
   initialize() {
-    import_core5.eventBus.subscribe(import_core5.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
+    import_core6.eventBus.subscribe(import_core6.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");
   }
@@ -1693,7 +2022,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_core5.eventBus.publish(taskRequest.callback_event, {
+        import_core6.eventBus.publish(taskRequest.callback_event, {
           success: false,
           error: error instanceof Error ? error.message : String(error),
           config: {