@axiom-lattice/gateway 2.1.18 → 2.1.20

package/dist/index.js

@@ -62,13 +62,15 @@ async function agent_invoke({
   command,
   run_id
 }) {
-  const runnable_agent = (0, import_core.getAgentClient)(assistant_id);
+  const agentLattice = (0, import_core.getAgentLattice)(assistant_id);
+  const runnable_agent = agentLattice?.client;
   const { message, ...rest } = input;
   const humanMessage = new import_messages.HumanMessage(message || "");
   const messages = [humanMessage];
   if (!runnable_agent) {
     throw new Error(`Agent ${assistant_id} not found`);
   }
+  const runConfig = agentLattice?.config?.runConfig || {};
   const result = await runnable_agent.invoke(
     command ? new import_langgraph.Command(command) : { ...rest, messages, "x-tenant-id": tenant_id },
     {
@@ -77,7 +79,9 @@ async function agent_invoke({
         run_id: run_id || (0, import_uuid.v4)(),
         "x-tenant-id": tenant_id,
         "x-request-id": run_id,
-        "x-thread-id": thread_id
+        "x-thread-id": thread_id,
+        runConfig
+        // Inject runConfig for tools to access
       },
       recursionLimit: 200
     }
@@ -100,6 +104,7 @@ async function agent_stream({
   run_id
 }) {
   const runnable_agent = (0, import_core.getAgentClient)(assistant_id);
+  const agentLattice = (0, import_core.getAgentLattice)(assistant_id);
   const { message, ...rest } = input;
   let messages = [];
   if (!command) {
@@ -107,6 +112,7 @@ async function agent_stream({
     messages = [humanMessage];
   }
   const chunkBuffer = getOrCreateChunkBuffer();
+  const runConfig = agentLattice?.config?.runConfig || {};
   try {
     if (!runnable_agent) {
       throw new Error(`Agent ${assistant_id} not found`);
@@ -123,7 +129,9 @@ async function agent_stream({
           run_id: run_id || (0, import_uuid.v4)(),
           "x-tenant-id": tenant_id,
           "x-request-id": run_id,
-          "x-thread-id": thread_id
+          "x-thread-id": thread_id,
+          runConfig
+          // Inject runConfig for tools to access
         },
         streamMode: ["updates", "messages"],
         subgraphs: false,
@@ -823,6 +831,201 @@ async function deleteThread(request, reply) {
   };
 }
 
+// src/controllers/schedules.ts
+var import_core6 = require("@axiom-lattice/core");
+function getScheduleLattice() {
+  const keys = import_core6.scheduleLatticeManager.getLatticeKeys();
+  if (keys.length === 0) {
+    return null;
+  }
+  if (import_core6.scheduleLatticeManager.hasLattice("default")) {
+    return import_core6.scheduleLatticeManager.getScheduleLattice("default");
+  }
+  return import_core6.scheduleLatticeManager.getScheduleLattice(keys[0]);
+}
+async function getThreadSchedules(request, reply) {
+  const { assistantId, threadId } = request.params;
+  const { status, limit, offset } = request.query;
+  try {
+    const scheduleLattice = getScheduleLattice();
+    if (!scheduleLattice) {
+      return {
+        success: true,
+        message: "No schedule lattice configured",
+        data: {
+          records: [],
+          total: 0
+        }
+      };
+    }
+    const storage = scheduleLattice.client.getStorage();
+    if (!storage) {
+      return {
+        success: true,
+        message: "No schedule storage configured",
+        data: {
+          records: [],
+          total: 0
+        }
+      };
+    }
+    const filters = {
+      threadId,
+      assistantId
+    };
+    if (status) {
+      filters.status = status;
+    }
+    if (limit) {
+      filters.limit = parseInt(limit, 10);
+    }
+    if (offset) {
+      filters.offset = parseInt(offset, 10);
+    }
+    const tasks = await storage.getAllTasks(filters);
+    const total = await storage.countTasks({
+      threadId,
+      assistantId,
+      status
+    });
+    return {
+      success: true,
+      message: "Successfully retrieved scheduled tasks",
+      data: {
+        records: tasks,
+        total
+      }
+    };
+  } catch (error) {
+    request.log.error(error, "Failed to get thread schedules");
+    return reply.status(500).send({
+      success: false,
+      message: "Failed to retrieve scheduled tasks",
+      data: {
+        records: [],
+        total: 0
+      }
+    });
+  }
+}
+async function getScheduledTask(request, reply) {
+  const { taskId } = request.params;
+  try {
+    const scheduleLattice = getScheduleLattice();
+    if (!scheduleLattice) {
+      return reply.status(404).send({
+        success: false,
+        message: "No schedule lattice configured"
+      });
+    }
+    const task = await scheduleLattice.client.getTask(taskId);
+    if (!task) {
+      return reply.status(404).send({
+        success: false,
+        message: "Scheduled task not found"
+      });
+    }
+    return {
+      success: true,
+      message: "Successfully retrieved scheduled task",
+      data: task
+    };
+  } catch (error) {
+    request.log.error(error, "Failed to get scheduled task");
+    return reply.status(500).send({
+      success: false,
+      message: "Failed to retrieve scheduled task"
+    });
+  }
+}
+async function cancelScheduledTask(request, reply) {
+  const { taskId } = request.params;
+  try {
+    const scheduleLattice = getScheduleLattice();
+    if (!scheduleLattice) {
+      return reply.status(404).send({
+        success: false,
+        message: "No schedule lattice configured"
+      });
+    }
+    const result = await scheduleLattice.client.cancel(taskId);
+    if (!result) {
+      return reply.status(404).send({
+        success: false,
+        message: "Scheduled task not found or already cancelled"
+      });
+    }
+    return {
+      success: true,
+      message: "Successfully cancelled scheduled task"
+    };
+  } catch (error) {
+    request.log.error(error, "Failed to cancel scheduled task");
+    return reply.status(500).send({
+      success: false,
+      message: "Failed to cancel scheduled task"
+    });
+  }
+}
+async function pauseScheduledTask(request, reply) {
+  const { taskId } = request.params;
+  try {
+    const scheduleLattice = getScheduleLattice();
+    if (!scheduleLattice) {
+      return reply.status(404).send({
+        success: false,
+        message: "No schedule lattice configured"
+      });
+    }
+    const result = await scheduleLattice.client.pause(taskId);
+    if (!result) {
+      return reply.status(404).send({
+        success: false,
+        message: "Scheduled task not found or cannot be paused"
+      });
+    }
+    return {
+      success: true,
+      message: "Successfully paused scheduled task"
+    };
+  } catch (error) {
+    request.log.error(error, "Failed to pause scheduled task");
+    return reply.status(500).send({
+      success: false,
+      message: "Failed to pause scheduled task"
+    });
+  }
+}
+async function resumeScheduledTask(request, reply) {
+  const { taskId } = request.params;
+  try {
+    const scheduleLattice = getScheduleLattice();
+    if (!scheduleLattice) {
+      return reply.status(404).send({
+        success: false,
+        message: "No schedule lattice configured"
+      });
+    }
+    const result = await scheduleLattice.client.resume(taskId);
+    if (!result) {
+      return reply.status(404).send({
+        success: false,
+        message: "Scheduled task not found or cannot be resumed"
+      });
+    }
+    return {
+      success: true,
+      message: "Successfully resumed scheduled task"
+    };
+  } catch (error) {
+    request.log.error(error, "Failed to resume scheduled task");
+    return reply.status(500).send({
+      success: false,
+      message: "Failed to resume scheduled task"
+    });
+  }
+}
+
 // src/config.ts
 var ConfigService = class {
   constructor() {
@@ -896,7 +1099,7 @@ var ConfigService = class {
 var configService = new ConfigService();
 
 // src/services/queue_service.ts
-var import_core6 = require("@axiom-lattice/core");
+var import_core7 = 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";
@@ -915,8 +1118,8 @@ var setQueueServiceType = (type) => {
       redisPassword: process.env.REDIS_PASSWORD
     } : void 0
   };
-  if (import_core6.queueLatticeManager.hasLattice(DEFAULT_QUEUE_KEY)) {
-    import_core6.queueLatticeManager.removeLattice(DEFAULT_QUEUE_KEY);
+  if (import_core7.queueLatticeManager.hasLattice(DEFAULT_QUEUE_KEY)) {
+    import_core7.queueLatticeManager.removeLattice(DEFAULT_QUEUE_KEY);
   }
   let client;
   if (type === "redis") {
@@ -925,13 +1128,13 @@ var setQueueServiceType = (type) => {
       redisPassword: process.env.REDIS_PASSWORD
     });
   }
-  (0, import_core6.registerQueueLattice)(DEFAULT_QUEUE_KEY, config, client);
+  (0, import_core7.registerQueueLattice)(DEFAULT_QUEUE_KEY, config, client);
 };
 var getQueueService = () => {
-  if (!import_core6.queueLatticeManager.hasLattice(DEFAULT_QUEUE_KEY)) {
+  if (!import_core7.queueLatticeManager.hasLattice(DEFAULT_QUEUE_KEY)) {
     setQueueServiceType(queueServiceType);
   }
-  return (0, import_core6.getQueueLattice)(DEFAULT_QUEUE_KEY);
+  return (0, import_core7.getQueueLattice)(DEFAULT_QUEUE_KEY);
 };
 var popAgentTaskFromQueue = async () => {
   const queue = getQueueService();
@@ -1012,10 +1215,10 @@ async function getConfig(request, reply) {
 }
 
 // src/controllers/models.ts
-var import_core7 = require("@axiom-lattice/core");
+var import_core8 = require("@axiom-lattice/core");
 async function getModels(request, reply) {
   try {
-    const allLattices = import_core7.modelLatticeManager.getAllLattices();
+    const allLattices = import_core8.modelLatticeManager.getAllLattices();
     const models = allLattices.map((lattice) => {
       const config = lattice.client.config || {};
       return {
@@ -1065,8 +1268,8 @@ async function updateModels(request, reply) {
         continue;
       }
       try {
-        if (import_core7.modelLatticeManager.hasLattice(modelConfig.key)) {
-          import_core7.modelLatticeManager.removeLattice(modelConfig.key);
+        if (import_core8.modelLatticeManager.hasLattice(modelConfig.key)) {
+          import_core8.modelLatticeManager.removeLattice(modelConfig.key);
         }
         const llmConfig = {
           provider: modelConfig.provider,
@@ -1079,7 +1282,7 @@ async function updateModels(request, reply) {
           timeout: modelConfig.timeout,
           maxRetries: modelConfig.maxRetries
         };
-        (0, import_core7.registerModelLattice)(modelConfig.key, llmConfig);
+        (0, import_core8.registerModelLattice)(modelConfig.key, llmConfig);
         registeredModels.push(modelConfig.key);
       } catch (error) {
         errors.push(
@@ -1487,144 +1690,14 @@ var registerLatticeRoutes = (app2) => {
     { schema: getHealthSchema },
     getHealth
   );
-};
-
-// src/logger/Logger.ts
-var import_pino = __toESM(require("pino"));
-var import_pino_pretty = require("pino-pretty");
-var import_pino_roll = require("pino-roll");
-var PinoLoggerFactory = class _PinoLoggerFactory {
-  constructor() {
-    const isProd = process.env.NODE_ENV === "production";
-    const loggerConfig = {
-      // 自定义时间戳格式
-      timestamp: () => `,"@timestamp":"${(/* @__PURE__ */ new Date()).toISOString()}"`,
-      // 关闭默认的时间戳键
-      base: {
-        "@version": "1",
-        app_name: "lattice",
-        service_name: "lattice/graph-server",
-        thread_name: "main",
-        logger_name: "lattice-graph-logger"
-      },
-      formatters: {
-        level: (label, number) => {
-          return {
-            level: label.toUpperCase(),
-            level_value: number * 1e3
-          };
-        }
-      }
-    };
-    if (isProd) {
-      try {
-        this.pinoLogger = (0, import_pino.default)(
-          loggerConfig,
-          import_pino.default.transport({
-            target: "pino-roll",
-            options: {
-              file: "./logs/fin_ai_graph_server",
-              frequency: "daily",
-              mkdir: true
-            }
-          })
-        );
-      } catch (error) {
-        console.error(
-          "\u65E0\u6CD5\u521D\u59CB\u5316 pino-roll \u65E5\u5FD7\u8BB0\u5F55\u5668\uFF0C\u56DE\u9000\u5230\u63A7\u5236\u53F0\u65E5\u5FD7",
-          error
-        );
-        this.pinoLogger = (0, import_pino.default)({
-          ...loggerConfig,
-          transport: {
-            target: "pino-pretty",
-            options: {
-              colorize: true
-            }
-          }
-        });
-      }
-    } else {
-      this.pinoLogger = (0, import_pino.default)({
-        ...loggerConfig,
-        transport: {
-          target: "pino-pretty",
-          options: {
-            colorize: true
-          }
-        }
-      });
-    }
-  }
-  static getInstance() {
-    if (!_PinoLoggerFactory.instance) {
-      _PinoLoggerFactory.instance = new _PinoLoggerFactory();
-    }
-    return _PinoLoggerFactory.instance;
-  }
-  getPinoLogger() {
-    return this.pinoLogger;
-  }
-};
-var Logger = class _Logger {
-  constructor(options) {
-    this.context = options?.context || {};
-    this.name = options?.name || "lattice-graph-logger";
-    this.serviceName = options?.serviceName || "lattice/graph-server";
-  }
-  /**
-   * 获取合并了上下文的日志对象
-   * @param additionalContext 额外的上下文数据
-   * @returns 带有上下文的pino日志对象
-   */
-  getContextualLogger(additionalContext) {
-    const pinoLogger = PinoLoggerFactory.getInstance().getPinoLogger();
-    const contextObj = {
-      "x-user-id": this.context["x-user-id"] || "",
-      "x-tenant-id": this.context["x-tenant-id"] || "",
-      "x-request-id": this.context["x-request-id"] || "",
-      "x-task-id": this.context["x-task-id"] || "",
-      "x-thread-id": this.context["x-thread-id"] || "",
-      service_name: this.serviceName,
-      logger_name: this.name,
-      ...additionalContext
-    };
-    return pinoLogger.child(contextObj);
-  }
-  info(msg, obj) {
-    this.getContextualLogger(obj).info(msg);
-  }
-  error(msg, obj) {
-    this.getContextualLogger(obj).error(msg);
-  }
-  warn(msg, obj) {
-    this.getContextualLogger(obj).warn(msg);
-  }
-  debug(msg, obj) {
-    this.getContextualLogger(obj).debug(msg);
-  }
-  /**
-   * 更新Logger实例的上下文
-   */
-  updateContext(context) {
-    this.context = {
-      ...this.context,
-      ...context
-    };
-  }
-  /**
-   * 创建一个新的Logger实例，继承当前Logger的上下文
-   */
-  child(options) {
-    return new _Logger({
-      name: options.name || this.name,
-      serviceName: options.serviceName || this.serviceName,
-      context: {
-        ...this.context,
-        ...options.context
-      }
-    });
-  }
+  app2.get(
+    "/api/assistants/:assistantId/threads/:threadId/schedules",
+    getThreadSchedules
+  );
+  app2.get("/api/schedules/:taskId", getScheduledTask);
+  app2.post("/api/schedules/:taskId/cancel", cancelScheduledTask);
+  app2.post("/api/schedules/:taskId/pause", pauseScheduledTask);
+  app2.post("/api/schedules/:taskId/resume", resumeScheduledTask);
 };
 
 // src/swagger.ts
@@ -1690,7 +1763,7 @@ var configureSwagger = async (app2, customSwaggerConfig, customSwaggerUiConfig)
 };
 
 // src/services/agent_task_consumer.ts
-var import_core8 = require("@axiom-lattice/core");
+var import_core9 = require("@axiom-lattice/core");
 var handleAgentTask = async (taskRequest, retryCount = 0) => {
   const {
     assistant_id,
@@ -1754,7 +1827,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       }
       if (callback_event) {
         const state = await agent_state({ assistant_id, thread_id });
-        import_core8.eventBus.publish(callback_event, {
+        import_core9.eventBus.publish(callback_event, {
           success: true,
           state,
           config: { assistant_id, thread_id, tenant_id }
@@ -1768,7 +1841,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       await response.text();
       if (callback_event) {
         const state = await agent_state({ assistant_id, thread_id });
-        import_core8.eventBus.publish(callback_event, {
+        import_core9.eventBus.publish(callback_event, {
           success: true,
           state,
           config: { assistant_id, thread_id, tenant_id }
@@ -1795,7 +1868,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       return handleAgentTask(taskRequest, nextRetryCount);
     }
     if (callback_event) {
-      import_core8.eventBus.publish(callback_event, {
+      import_core9.eventBus.publish(callback_event, {
         success: false,
         error: error instanceof Error ? error.message : String(error),
         config: { assistant_id, thread_id, tenant_id }
@@ -1833,7 +1906,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
    * 初始化事件监听和队列轮询
    */
   initialize() {
-    import_core8.eventBus.subscribe(import_core8.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
+    import_core9.eventBus.subscribe(import_core9.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");
   }
@@ -1952,7 +2025,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_core8.eventBus.publish(taskRequest.callback_event, {
+        import_core9.eventBus.publish(taskRequest.callback_event, {
           success: false,
           error: error instanceof Error ? error.message : String(error),
           config: {
@@ -1972,13 +2045,27 @@ _AgentTaskConsumer.agent_run_endpoint = "http://localhost:4001/api/runs";
 var AgentTaskConsumer = _AgentTaskConsumer;
 
 // src/index.ts
+var import_core10 = 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);
 });
-var logger = new Logger({
-  serviceName: "lattice-gateway",
-  name: "fastify-server"
-});
+var DEFAULT_LOGGER_CONFIG = {
+  name: "default",
+  description: "Default logger for lattice-gateway service",
+  type: import_protocols2.LoggerType.PINO,
+  serviceName: "lattice/gateway",
+  loggerName: "lattice/gateway"
+};
+var loggerLattice = initializeLogger(DEFAULT_LOGGER_CONFIG);
+var logger = loggerLattice.client;
+function initializeLogger(config) {
+  if (import_core10.loggerLatticeManager.hasLattice("default")) {
+    import_core10.loggerLatticeManager.removeLattice("default");
+  }
+  (0, import_core10.registerLoggerLattice)("default", config);
+  return (0, import_core10.getLoggerLattice)("default");
+}
 var app = (0, import_fastify.default)({
   logger: false,
   // 禁用内置日志记录器
@@ -1986,17 +2073,33 @@ var app = (0, import_fastify.default)({
   // Default 50MB, configurable via BODY_LIMIT env var
 });
 app.addHook("onRequest", (request, reply, done) => {
+  const getHeaderValue = (header) => {
+    if (Array.isArray(header)) {
+      return header[0];
+    }
+    return header;
+  };
   const context = {
-    "x-tenant-id": request.headers["x-tenant-id"],
-    "x-request-id": request.headers["x-request-id"]
+    "x-tenant-id": getHeaderValue(request.headers["x-tenant-id"]),
+    "x-request-id": getHeaderValue(request.headers["x-request-id"])
   };
+  if (loggerLattice.updateContext) {
+    loggerLattice.updateContext(context);
+  }
   done();
 });
 app.addHook("onResponse", (request, reply, done) => {
+  const getHeaderValue = (header) => {
+    if (Array.isArray(header)) {
+      return header[0];
+    }
+    return header;
+  };
   const context = {
-    "x-tenant-id": request.headers["x-tenant-id"],
-    "x-request-id": request.headers["x-request-id"]
+    "x-tenant-id": getHeaderValue(request.headers["x-tenant-id"]),
+    "x-request-id": getHeaderValue(request.headers["x-request-id"])
   };
+  loggerLattice.info(`${request.method} ${request.url} - ${reply.statusCode}`);
   done();
 });
 app.register(import_cors.default, {
@@ -2014,9 +2117,15 @@ app.register(import_cors.default, {
 });
 app.register(import_sensible.default);
 app.setErrorHandler((error, request, reply) => {
+  const getHeaderValue = (header) => {
+    if (Array.isArray(header)) {
+      return header[0];
+    }
+    return header;
+  };
   const context = {
-    "x-tenant-id": request.headers["x-tenant-id"],
-    "x-request-id": request.headers["x-request-id"]
+    "x-tenant-id": getHeaderValue(request.headers["x-tenant-id"]),
+    "x-request-id": getHeaderValue(request.headers["x-request-id"])
   };
   logger.error(
     `\u8BF7\u6C42\u9519\u8BEF: ${request.method} ${request.url} error:${error.message}`,
@@ -2032,9 +2141,19 @@ app.setErrorHandler((error, request, reply) => {
     error: error.message || "\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF"
   });
 });
-app.decorate("logger", logger);
 var start = async (config) => {
   try {
+    if (config?.loggerConfig) {
+      const loggerConfig = {
+        ...DEFAULT_LOGGER_CONFIG,
+        ...config.loggerConfig,
+        // Merge file config if provided
+        file: config.loggerConfig.file || DEFAULT_LOGGER_CONFIG.file
+      };
+      loggerLattice = initializeLogger(loggerConfig);
+      logger = loggerLattice.client;
+    }
+    app.decorate("loggerLattice", loggerLattice);
     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}`);