@axiom-lattice/gateway 2.1.5 → 2.1.7

package/src/services/queue_service.ts

@@ -1,11 +1,19 @@
-// Queue service adapter that supports both Redis and memory implementations
-// Defaults to memory implementation
+// Queue service adapter that uses QueueLatticeManager from core package
+// Provides backward-compatible API for gateway services
 
-import * as memoryQueueService from "./queue_service_memory";
-import * as redisQueueService from "./queue_service_redis";
+import {
+  queueLatticeManager,
+  registerQueueLattice,
+  getQueueLattice,
+} from "@axiom-lattice/core";
+import { QueueType, QueueConfig, QueueClient } from "@axiom-lattice/protocols";
+import { RedisQueueClient } from "@axiom-lattice/queue-redis";
 
 export type QueueServiceType = "memory" | "redis";
 
+// Default queue key
+const DEFAULT_QUEUE_KEY = "default";
+
 // Global configuration for queue service type
 // Can be set via environment variable QUEUE_SERVICE_TYPE or via LatticeGateway configuration
 let queueServiceType: QueueServiceType =
@@ -13,11 +21,45 @@ let queueServiceType: QueueServiceType =
 
 /**
  * Configure the queue service type
+ * This will register or update the default queue service
  * @param type - "memory" or "redis"
  */
 export const setQueueServiceType = (type: QueueServiceType): void => {
   queueServiceType = type;
   console.log(`Queue service type set to: ${type}`);
+
+  // Register or update the queue service
+  const queueName = process.env.QUEUE_NAME || "tasks";
+  const config: QueueConfig = {
+    name: "Default Queue Service",
+    description: `Default ${type} queue service`,
+    type: type === "redis" ? QueueType.REDIS : QueueType.MEMORY,
+    queueName,
+    options:
+      type === "redis"
+        ? {
+            redisUrl: process.env.REDIS_URL,
+            redisPassword: process.env.REDIS_PASSWORD,
+          }
+        : undefined,
+  };
+
+  // Remove existing queue if it exists
+  if (queueLatticeManager.hasLattice(DEFAULT_QUEUE_KEY)) {
+    queueLatticeManager.removeLattice(DEFAULT_QUEUE_KEY);
+  }
+
+  // Create client for Redis type
+  let client: QueueClient | undefined;
+  if (type === "redis") {
+    client = new RedisQueueClient(queueName, {
+      redisUrl: process.env.REDIS_URL,
+      redisPassword: process.env.REDIS_PASSWORD,
+    });
+  }
+
+  // Register the new queue service
+  registerQueueLattice(DEFAULT_QUEUE_KEY, config, client);
 };
 
 /**
@@ -27,17 +69,35 @@ export const getQueueServiceType = (): QueueServiceType => {
   return queueServiceType;
 };
 
-// Select the appropriate implementation based on configuration
+/**
+ * Get the default queue service
+ * If not registered, register it with the current configuration
+ */
 const getQueueService = () => {
-  return queueServiceType === "redis" ? redisQueueService : memoryQueueService;
+  // Check if queue is already registered
+  if (!queueLatticeManager.hasLattice(DEFAULT_QUEUE_KEY)) {
+    // Auto-register with current configuration
+    setQueueServiceType(queueServiceType);
+  }
+
+  return getQueueLattice(DEFAULT_QUEUE_KEY);
 };
 
+/**
+ * Push agent task to queue
+ * @param agentTask - Agent task to push
+ */
 export const pushAgentTaskToQueue = async (agentTask: any) => {
-  const service = getQueueService();
-  return service.pushAgentTaskToQueue(agentTask);
+  const queue = getQueueService();
+  const result = await queue.push(agentTask);
+  return result;
 };
 
+/**
+ * Pop agent task from queue
+ */
 export const popAgentTaskFromQueue = async () => {
-  const service = getQueueService();
-  return service.popAgentTaskFromQueue();
+  const queue = getQueueService();
+  const result = await queue.pop();
+  return result;
 };

package/src/services/AgentManager.ts

@@ -1,46 +0,0 @@
-import { AGENT_TASK_EVENT } from "./agent_task_types";
-import eventBus from "./event_bus";
-
-export class AgentManager {
-  private static instance: AgentManager;
-  private constructor() {}
-  private agents: { name: string; agent: any }[] = [];
-  public static getInstance(): AgentManager {
-    if (!AgentManager.instance) {
-      AgentManager.instance = new AgentManager();
-    }
-    return AgentManager.instance;
-  }
-  callAgentInQueue(queue: {
-    assistant_id: string;
-    input?: any;
-    thread_id: string;
-    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);
-      //   }
-      // });
-      try {
-        eventBus.publish(
-          AGENT_TASK_EVENT,
-          {
-            ...queue,
-          },
-          true
-        );
-        resolve(true);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  }
-}

package/src/services/agent_task_types.ts

@@ -1,2 +0,0 @@
-// 任务事件名称
-export const AGENT_TASK_EVENT = "agent:execute";

package/src/services/event_bus.ts

@@ -1,62 +0,0 @@
-import { EventEmitter } from "events";
-import { pushAgentTaskToQueue } from "./queue_service";
-
-/**
- * 事件总线服务
- * 用于系统内部组件间的事件发布与订阅
- */
-class EventBus {
-  private emitter: EventEmitter;
-
-  constructor() {
-    this.emitter = new EventEmitter();
-    // 设置最大监听器数量，避免内存泄漏警告
-    this.emitter.setMaxListeners(100);
-  }
-
-  /**
-   * 发布事件
-   * @param eventName 事件名称
-   * @param data 事件数据
-   */
-  publish(eventName: string, data: any, useQueue: boolean = false): void {
-    //console.log(`发布事件: ${eventName}`, data);
-    if (useQueue) {
-      pushAgentTaskToQueue(data);
-    } else {
-      this.emitter.emit(eventName, data);
-    }
-  }
-
-  /**
-   * 订阅事件
-   * @param eventName 事件名称
-   * @param callback 回调函数
-   */
-  subscribe(eventName: string, callback: (data: any) => void): void {
-    this.emitter.on(eventName, callback);
-  }
-
-  /**
-   * 取消订阅事件
-   * @param eventName 事件名称
-   * @param callback 回调函数
-   */
-  unsubscribe(eventName: string, callback: (data: any) => void): void {
-    this.emitter.off(eventName, callback);
-  }
-
-  /**
-   * 只订阅一次事件
-   * @param eventName 事件名称
-   * @param callback 回调函数
-   */
-  subscribeOnce(eventName: string, callback: (data: any) => void): void {
-    this.emitter.once(eventName, callback);
-  }
-}
-
-// 创建单例实例
-const eventBus = new EventBus();
-
-export default eventBus;

package/src/services/queue_service_memory.ts

@@ -1,85 +0,0 @@
-// 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

@@ -1,116 +0,0 @@
-import { createClient, RedisClientType } 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
-
-// Redis client - initialized lazily only when needed
-let redisClient: RedisClientType | null = null;
-let isConnecting = false;
-let connectionPromise: Promise<void> | null = null;
-
-// Lazy initialization of Redis client
-const getRedisClient = async (): Promise<RedisClientType> => {
-  // If client is already connected, return it
-  if (redisClient?.isOpen) {
-    return redisClient;
-  }
-
-  // If connection is in progress, wait for it
-  if (isConnecting && connectionPromise) {
-    await connectionPromise;
-    if (redisClient?.isOpen) {
-      return redisClient;
-    }
-  }
-
-  // Create and connect to Redis client
-  isConnecting = true;
-  connectionPromise = (async () => {
-    try {
-      const redisOptions: any = {
-        url: process.env.REDIS_URL || "redis://localhost:6379",
-        password: process.env.REDIS_PASSWORD,
-      };
-
-      redisClient = createClient(redisOptions) as RedisClientType;
-
-      redisClient.on("error", (err: Error) =>
-        console.error("Redis Client Error", err)
-      );
-
-      await redisClient.connect();
-      console.log("Redis connection successful");
-      isConnecting = false;
-    } catch (error) {
-      console.error("Redis connection failed:", error);
-      isConnecting = false;
-      throw error;
-    }
-  })();
-
-  await connectionPromise;
-  return redisClient!;
-};
-
-// Enqueue Message
-const sendToQueue = async (queueName: string, message: any) => {
-  try {
-    const client = await getRedisClient();
-    // Push message to queue
-    const result = await client.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 {
-    const client = await getRedisClient();
-    // Get message from queue
-    const message = await client.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 client = await getRedisClient();
-    const exists = await client.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;
-};