@axiom-lattice/gateway 2.1.3 → 2.1.4

package/src/services/AgentManager.ts

@@ -13,30 +13,34 @@ export class AgentManager {
   }
   callAgentInQueue(queue: {
     assistant_id: string;
-    input: any;
+    input?: any;
     thread_id: string;
-    "x-tenant-id": number;
+    command?: any;
+    "x-tenant-id"?: string;
   }) {
     return new Promise((resolve, reject) => {
-      const callback_event = `${queue.assistant_id}::${queue.thread_id}`;
-      eventBus.subscribeOnce(callback_event, (data) => {
-        if (data.success) {
-          console.log("AgentManager callAgentInQueue success", data);
-          resolve(data.result);
-        } else {
-          console.log("AgentManager callAgentInQueue error", data);
-          reject(data.error);
-        }
-      });
-      eventBus.publish(
-        AGENT_TASK_EVENT,
-        {
-          ...queue,
-          thread_id: callback_event,
-          callback_event,
-        },
-        true
-      );
+      //const callback_event = `${queue.assistant_id}::${queue.thread_id}`;
+      // eventBus.subscribeOnce(callback_event, (data) => {
+      //   if (data.success) {
+      //     console.log("AgentManager callAgentInQueue success", data);
+      //     resolve(data.result);
+      //   } else {
+      //     console.log("AgentManager callAgentInQueue error", data);
+      //     reject(data.error);
+      //   }
+      // });
+      try {
+        eventBus.publish(
+          AGENT_TASK_EVENT,
+          {
+            ...queue,
+          },
+          true
+        );
+        resolve(true);
+      } catch (error) {
+        reject(error);
+      }
     });
   }
 }

package/src/services/agent_task_consumer.ts

@@ -0,0 +1,325 @@
+import eventBus from "./event_bus";
+import { AGENT_TASK_EVENT } from "./agent_task_types";
+import { popAgentTaskFromQueue } from "./queue_service";
+
+// 任务请求结构
+export interface AgentTaskRequest {
+  assistant_id: string;
+  input: any;
+  thread_id: string;
+  "x-tenant-id": string;
+  command?: any;
+  callback_event?: string; // 可选的回调事件名称
+}
+
+/**
+ * 处理Agent任务事件
+ * @param taskRequest 任务请求
+ * @param retryCount 重试次数
+ */
+const handleAgentTask = async (
+  taskRequest: AgentTaskRequest,
+  retryCount: number = 0
+): Promise<boolean> => {
+  const {
+    assistant_id,
+    input = {},
+    thread_id,
+    "x-tenant-id": tenant_id,
+    command,
+    callback_event,
+  } = taskRequest;
+
+  try {
+    console.log(
+      `开始处理任务 [assistant_id: ${assistant_id}, thread_id: ${thread_id}]`
+    );
+
+    // 检查API服务器是否可用
+    const apiUrl = AgentTaskConsumer.agent_run_endpoint;
+
+    console.log(`apiUrl: ${apiUrl}`);
+
+    const response = await fetch(apiUrl, {
+      method: "POST",
+      body: JSON.stringify({
+        assistant_id,
+        streaming: true,
+        ...input,
+        thread_id,
+        command,
+      }),
+      headers: {
+        "Content-Type": "application/json",
+        "x-tenant-id": tenant_id,
+      },
+    }).catch((err) => {
+      console.error(`fetch请求失败: ${err.message || String(err)}`);
+      throw new Error(`fetch失败: ${err.message || String(err)}`);
+    });
+
+    if (!response.ok) {
+      throw new Error(`API请求失败: ${response.status} ${response.statusText}`);
+    }
+
+    if (callback_event) {
+      eventBus.publish(callback_event, {
+        success: true,
+        config: { assistant_id, thread_id, tenant_id },
+      });
+    }
+
+    console.log(
+      `任务处理成功 [assistant_id: ${assistant_id}, thread_id: ${thread_id}]`
+    );
+    return true;
+  } catch (error) {
+    console.error(
+      `Agent任务执行失败: ${assistant_id}, 线程: ${thread_id}`,
+      error
+    );
+
+    // 重试逻辑，暂不用重试
+    const maxRetries = 0;
+    if (retryCount < maxRetries) {
+      const nextRetryCount = retryCount + 1;
+      const delayMs = Math.pow(2, nextRetryCount) * 1000; // 指数退避策略
+
+      console.log(
+        `将在 ${delayMs}ms 后重试任务 (${nextRetryCount}/${maxRetries})`
+      );
+
+      // 延迟后重试
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+      return handleAgentTask(taskRequest, nextRetryCount);
+    }
+
+    if (callback_event) {
+      eventBus.publish(callback_event, {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        config: { assistant_id, thread_id, tenant_id },
+      });
+    }
+
+    console.error(
+      `任务处理失败，已达到最大重试次数 [assistant_id: ${assistant_id}, thread_id: ${thread_id}]`
+    );
+    return false;
+  }
+};
+
+/**
+ * Agent任务消费者
+ * 负责监听和执行Agent任务事件，同时从队列中消费任务
+ */
+export class AgentTaskConsumer {
+  private isPolling: boolean = false;
+  private pollingInterval: NodeJS.Timeout | null = null;
+  private pollingIntervalMs: number = 5000; // 默认5秒轮询一次
+  private maxConcurrentTasks: number = 15; // 最大并发任务数
+  private activeTasks: number = 0; // 当前活跃的任务数
+  private processing: boolean = false; // 是否正在处理任务批次
+  private immediateProcessingEnabled: boolean = true; // 是否启用即时处理模式
+  public gatewayPort: number = 4001;
+  public static agent_run_endpoint: string = "http://localhost:4001/api/runs";
+
+  constructor(gatewayPort: number, pollingIntervalMs?: number) {
+    this.gatewayPort = gatewayPort;
+    AgentTaskConsumer.agent_run_endpoint = `http://localhost:${this.gatewayPort}/api/runs`;
+    if (pollingIntervalMs) {
+      this.pollingIntervalMs = pollingIntervalMs;
+    }
+    this.initialize();
+  }
+
+  /**
+   * 初始化事件监听和队列轮询
+   */
+  private initialize(): void {
+    // 监听事件总线上的任务
+    eventBus.subscribe(AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
+
+    // 启动队列轮询
+    this.startPollingQueue();
+
+    console.log("Agent任务消费者已启动并监听任务事件和队列");
+  }
+
+  /**
+   * 启动队列轮询
+   */
+  startPollingQueue(): void {
+    if (this.isPolling) {
+      return;
+    }
+
+    this.isPolling = true;
+
+    this.pollingInterval = setInterval(async () => {
+      try {
+        // 如果上一批次任务还在处理中，跳过本次轮询
+        if (this.processing) {
+          console.log("队列处理中，跳过本次轮询");
+          return;
+        }
+
+        await this.consumeFromQueue();
+      } catch (error) {
+        console.error("队列轮询出错:", error);
+      }
+    }, this.pollingIntervalMs);
+
+    console.log(
+      `开始轮询队列，间隔: ${this.pollingIntervalMs}ms，最大并发任务数: ${this.maxConcurrentTasks}`
+    );
+  }
+
+  /**
+   * 停止队列轮询
+   */
+  stopPollingQueue(): void {
+    if (this.pollingInterval) {
+      clearInterval(this.pollingInterval);
+      this.pollingInterval = null;
+      this.isPolling = false;
+      console.log("已停止队列轮询");
+    }
+  }
+
+  /**
+   * 处理单个任务并在完成后立即尝试处理下一个
+   */
+  async processNextTask(): Promise<boolean> {
+    try {
+      // 从队列中获取任务
+      const queueResult = await popAgentTaskFromQueue();
+
+      // 检查队列结果
+      if (queueResult && queueResult.data) {
+        const taskItem = queueResult.data;
+
+        if (taskItem && typeof taskItem === "object") {
+          const taskRequest = taskItem as AgentTaskRequest;
+
+          console.log(
+            `从队列中获取到任务 [assistant: ${taskRequest.assistant_id}, thread: ${taskRequest.thread_id}]`
+          );
+
+          // 增加活跃任务计数
+          this.activeTasks++;
+
+          // 处理任务（不使用await，允许并发执行）
+          handleAgentTask(taskRequest)
+            .then((success) => {
+              if (!success) {
+                console.error(`任务 处理失败`);
+                // 可以在这里记录失败任务或执行补偿逻辑
+              } else {
+                console.log(`任务 处理成功`);
+              }
+            })
+            .catch((error) => {
+              console.error(`任务 处理时出错:`, error);
+            })
+            .finally(() => {
+              // 减少活跃任务计数
+              this.activeTasks--;
+
+              // 如果启用了即时处理模式，尝试处理更多任务
+              if (this.immediateProcessingEnabled && !this.processing) {
+                this.checkQueueForTasks();
+              }
+            });
+
+          // 任务已派发，返回true表示有任务被处理
+          return true;
+        } else {
+          console.log("队列任务格式无效:", taskItem);
+          return false;
+        }
+      } else {
+        // 队列为空
+        return false;
+      }
+    } catch (error) {
+      console.error("处理任务失败:", error);
+      return false;
+    }
+  }
+
+  /**
+   * 检查队列中是否有任务并处理
+   */
+  async checkQueueForTasks(): Promise<void> {
+    // 如果已经在处理中或者并发任务已达上限，则不处理
+    if (this.processing || this.activeTasks >= this.maxConcurrentTasks) {
+      return;
+    }
+
+    this.processing = true;
+
+    try {
+      // 尝试获取并处理任务，直到达到并发上限
+      while (this.activeTasks < this.maxConcurrentTasks) {
+        const taskProcessed = await this.processNextTask();
+        if (!taskProcessed) {
+          // 没有更多任务，退出循环
+          break;
+        }
+      }
+    } catch (error) {
+      console.error("检查队列任务失败:", error);
+    } finally {
+      this.processing = false;
+    }
+  }
+
+  /**
+   * 从队列中消费任务
+   */
+  async consumeFromQueue(): Promise<void> {
+    // 如果已经在处理中，跳过
+    if (this.processing) {
+      return;
+    }
+
+    // 调用任务检查方法
+    await this.checkQueueForTasks();
+  }
+
+  /**
+   * 处理通过事件触发的任务
+   */
+  trigger_agent_task(taskRequest: AgentTaskRequest): void {
+    console.log(
+      `通过事件触发任务: [assistant: ${taskRequest.assistant_id}, thread: ${taskRequest.thread_id}]`
+    );
+
+    // 处理任务，不阻塞事件处理流程
+    handleAgentTask(taskRequest).catch((error) => {
+      console.error("处理Agent任务时发生未捕获的错误:", error);
+
+      // 如果有回调事件，确保即使发生错误也能通知
+      if (taskRequest.callback_event) {
+        eventBus.publish(taskRequest.callback_event, {
+          success: false,
+          error: error instanceof Error ? error.message : String(error),
+          config: {
+            assistant_id: taskRequest.assistant_id,
+            thread_id: taskRequest.thread_id,
+            tenant_id: taskRequest["x-tenant-id"],
+          },
+        });
+      }
+    });
+
+    // 如果启用了即时处理且当前活跃任务数低于阈值，检查队列
+    if (
+      this.immediateProcessingEnabled &&
+      this.activeTasks < this.maxConcurrentTasks
+    ) {
+      setImmediate(() => this.checkQueueForTasks());
+    }
+  }
+}

package/src/services/queue_service.ts

@@ -1,82 +1,43 @@
-import { createClient } from "redis";
-
-// 创建Redis客户端 - 使用正确的密码
-const redisOptions: any = {
-  url: process.env.REDIS_URL || "redis://localhost:6379",
-  password: process.env.REDIS_PASSWORD,
+// Queue service adapter that supports both Redis and memory implementations
+// Defaults to memory implementation
+
+import * as memoryQueueService from "./queue_service_memory";
+import * as redisQueueService from "./queue_service_redis";
+
+export type QueueServiceType = "memory" | "redis";
+
+// Global configuration for queue service type
+// Can be set via environment variable QUEUE_SERVICE_TYPE or via LatticeGateway configuration
+let queueServiceType: QueueServiceType =
+  (process.env.QUEUE_SERVICE_TYPE as QueueServiceType) || "memory";
+
+/**
+ * Configure the queue service type
+ * @param type - "memory" or "redis"
+ */
+export const setQueueServiceType = (type: QueueServiceType): void => {
+  queueServiceType = type;
+  console.log(`Queue service type set to: ${type}`);
 };
 
-const redisClient = createClient(redisOptions);
-
-// 连接Redis
-(async () => {
-  redisClient.on("error", (err: Error) =>
-    console.error("Redis Client Error", err)
-  );
-  try {
-    await redisClient.connect();
-    console.log("Redis连接成功");
-  } catch (error) {
-    console.error("Redis连接失败:", error);
-  }
-})();
-
-const queue_name = process.env.QUEUE_NAME || "tasks"; // 队列名称,本地开发需要自己配置自己的队列
-
-//Enqueue Message
-const sendToQueue = async (queue_name: string, message: any) => {
-  try {
-    // 将消息推送到队列
-    const result = await redisClient.lPush(queue_name, JSON.stringify(message));
-    console.log("lPush", result);
-    return { data: result, error: null };
-  } catch (error) {
-    console.error(error);
-    return { data: null, error };
-  }
+/**
+ * Get the current queue service type
+ */
+export const getQueueServiceType = (): QueueServiceType => {
+  return queueServiceType;
 };
 
-//Dequeue Message
-const popFromQueue = async (queue_name: string) => {
-  try {
-    // 从队列中获取消息
-    const message = await redisClient.rPop(queue_name);
-    if (message) {
-      return { data: JSON.parse(message), error: null };
-    }
-    return { data: null, error: null };
-  } catch (error) {
-    console.error(error);
-    return { data: null, error };
-  }
-};
-
-const createTenantQueue = async () => {
-  // Redis不需要显式创建队列，但我们可以保留这个函数以保持API兼容
-  // 可以进行一些初始化操作，如检查队列是否存在
-  try {
-    const exists = await redisClient.exists(queue_name);
-    return { success: true, queue_name };
-  } catch (error) {
-    console.error(error);
-    return { success: false, error };
-  }
+// Select the appropriate implementation based on configuration
+const getQueueService = () => {
+  return queueServiceType === "redis" ? redisQueueService : memoryQueueService;
 };
 
 export const pushAgentTaskToQueue = async (agentTask: any) => {
-  const tenantId = agentTask["x-tenant-id"];
-
-  try {
-    await createTenantQueue();
-    const result = await sendToQueue(`${queue_name}`, agentTask);
-    return result;
-  } catch (error) {
-    console.error(error);
-    return null;
-  }
+  const service = getQueueService();
+  return service.pushAgentTaskToQueue(agentTask);
 };
 
 export const popAgentTaskFromQueue = async () => {
-  const result = await popFromQueue(`${queue_name}`);
-  return result;
+  const service = getQueueService();
+  return service.popAgentTaskFromQueue();
 };

package/src/services/queue_service_memory.ts

@@ -0,0 +1,85 @@
+// In-memory queue service implementation
+// This is a memory-based alternative to the Redis queue service
+
+const queue_name = process.env.QUEUE_NAME || "tasks"; // Queue name, local development needs to configure its own queue
+
+// In-memory storage for queues: Map<queue_name, message[]>
+// Using Map to support multiple queues (e.g., per tenant)
+const queues = new Map<string, any[]>();
+
+// Initialize queue if it doesn't exist
+const ensureQueue = (queueName: string): void => {
+  if (!queues.has(queueName)) {
+    queues.set(queueName, []);
+  }
+};
+
+// Enqueue Message (equivalent to lPush - push to left/beginning)
+const sendToQueue = async (queueName: string, message: any) => {
+  try {
+    ensureQueue(queueName);
+    const queue = queues.get(queueName)!;
+    
+    // lPush behavior: add to the beginning of the array
+    queue.unshift(message);
+    
+    const result = queue.length;
+    console.log("lPush (memory)", result);
+    return { data: result, error: null };
+  } catch (error) {
+    console.error(error);
+    return { data: null, error };
+  }
+};
+
+// Dequeue Message (equivalent to rPop - pop from right/end)
+const popFromQueue = async (queueName: string) => {
+  try {
+    ensureQueue(queueName);
+    const queue = queues.get(queueName)!;
+    
+    // rPop behavior: remove from the end of the array
+    // This creates FIFO behavior when combined with lPush (unshift + pop = FIFO)
+    const message = queue.pop();
+    
+    if (message) {
+      return { data: message, error: null };
+    }
+    return { data: null, error: null };
+  } catch (error) {
+    console.error(error);
+    return { data: null, error };
+  }
+};
+
+const createTenantQueue = async () => {
+  // Initialize the queue in memory
+  try {
+    ensureQueue(queue_name);
+    const queue = queues.get(queue_name)!;
+    const exists = queue !== undefined;
+    return { success: true, queue_name };
+  } catch (error) {
+    console.error(error);
+    return { success: false, error };
+  }
+};
+
+export const pushAgentTaskToQueue = async (agentTask: any) => {
+  const tenantId = agentTask["x-tenant-id"];
+
+  try {
+    await createTenantQueue();
+    const result = await sendToQueue(`${queue_name}`, agentTask);
+    return result;
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+};
+
+export const popAgentTaskFromQueue = async () => {
+  const result = await popFromQueue(`${queue_name}`);
+  return result;
+};
+

package/src/services/queue_service_redis.ts

@@ -0,0 +1,86 @@
+import { createClient } from "redis";
+
+// Redis queue service implementation
+// This is a Redis-based queue service
+
+const queue_name = process.env.QUEUE_NAME || "tasks"; // Queue name, local development needs to configure its own queue
+
+// Create Redis client with correct password
+const redisOptions: any = {
+  url: process.env.REDIS_URL || "redis://localhost:6379",
+  password: process.env.REDIS_PASSWORD,
+};
+
+const redisClient = createClient(redisOptions);
+
+// Connect to Redis
+(async () => {
+  redisClient.on("error", (err: Error) =>
+    console.error("Redis Client Error", err)
+  );
+  try {
+    await redisClient.connect();
+    console.log("Redis connection successful");
+  } catch (error) {
+    console.error("Redis connection failed:", error);
+  }
+})();
+
+// Enqueue Message
+const sendToQueue = async (queueName: string, message: any) => {
+  try {
+    // Push message to queue
+    const result = await redisClient.lPush(queueName, JSON.stringify(message));
+    console.log("lPush", result);
+    return { data: result, error: null };
+  } catch (error) {
+    console.error(error);
+    return { data: null, error };
+  }
+};
+
+// Dequeue Message
+const popFromQueue = async (queueName: string) => {
+  try {
+    // Get message from queue
+    const message = await redisClient.rPop(queueName);
+    if (message) {
+      return { data: JSON.parse(message), error: null };
+    }
+    return { data: null, error: null };
+  } catch (error) {
+    console.error(error);
+    return { data: null, error };
+  }
+};
+
+const createTenantQueue = async () => {
+  // Redis doesn't need explicit queue creation, but we keep this function for API compatibility
+  // Can perform some initialization operations, such as checking if queue exists
+  try {
+    const exists = await redisClient.exists(queue_name);
+    return { success: true, queue_name };
+  } catch (error) {
+    console.error(error);
+    return { success: false, error };
+  }
+};
+
+export const pushAgentTaskToQueue = async (agentTask: any) => {
+  const tenantId = agentTask["x-tenant-id"];
+
+  try {
+    await createTenantQueue();
+    const result = await sendToQueue(`${queue_name}`, agentTask);
+    return result;
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+};
+
+export const popAgentTaskFromQueue = async () => {
+  const result = await popFromQueue(`${queue_name}`);
+  return result;
+};
+