@axiom-lattice/gateway 2.1.4 → 2.1.6

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @axiom-lattice/gateway@2.1.4 build /home/runner/work/agentic/agentic/packages/gateway
+> @axiom-lattice/gateway@2.1.6 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     39.83 KB
-ESM dist/index.mjs.map 82.56 KB
-ESM ⚡️ Build success in 117ms
-CJS dist/index.js     41.78 KB
-CJS dist/index.js.map 82.64 KB
-CJS ⚡️ Build success in 119ms
+CJS dist/index.js     38.84 KB
+CJS dist/index.js.map 76.54 KB
+CJS ⚡️ Build success in 142ms
+ESM dist/index.mjs     36.61 KB
+ESM dist/index.mjs.map 76.45 KB
+ESM ⚡️ Build success in 149ms
 DTS Build start
-DTS ⚡️ Build success in 9672ms
+DTS ⚡️ Build success in 5936ms
 DTS dist/index.d.ts  3.32 KB
 DTS dist/index.d.mts 3.32 KB

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @axiom-lattice/gateway
 
+## 2.1.6
+
+### Patch Changes
+
+- ee11051: run subagent in another thread
+- Updated dependencies [ee11051]
+  - @axiom-lattice/protocols@2.1.2
+  - @axiom-lattice/core@2.1.4
+  - @axiom-lattice/queue-redis@1.0.1
+
+## 2.1.5
+
+### Patch Changes
+
+- e26477f: fix redis connect issue
+
 ## 2.1.4
 
 ### Patch Changes

package/dist/index.js

@@ -534,245 +534,8 @@ var getAgentGraph = async (request, reply) => {
   }
 };
 
-// src/services/agent_task_types.ts
-var AGENT_TASK_EVENT = "agent:execute";
-
-// src/services/event_bus.ts
-var import_events = require("events");
-
-// src/services/queue_service_memory.ts
-var queue_service_memory_exports = {};
-__export(queue_service_memory_exports, {
-  popAgentTaskFromQueue: () => popAgentTaskFromQueue,
-  pushAgentTaskToQueue: () => pushAgentTaskToQueue
-});
-var queue_name = process.env.QUEUE_NAME || "tasks";
-var queues = /* @__PURE__ */ new Map();
-var ensureQueue = (queueName) => {
-  if (!queues.has(queueName)) {
-    queues.set(queueName, []);
-  }
-};
-var sendToQueue = async (queueName, message) => {
-  try {
-    ensureQueue(queueName);
-    const queue = queues.get(queueName);
-    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 };
-  }
-};
-var popFromQueue = async (queueName) => {
-  try {
-    ensureQueue(queueName);
-    const queue = queues.get(queueName);
-    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 };
-  }
-};
-var createTenantQueue = async () => {
-  try {
-    ensureQueue(queue_name);
-    const queue = queues.get(queue_name);
-    const exists = queue !== void 0;
-    return { success: true, queue_name };
-  } catch (error) {
-    console.error(error);
-    return { success: false, error };
-  }
-};
-var pushAgentTaskToQueue = async (agentTask) => {
-  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;
-  }
-};
-var popAgentTaskFromQueue = async () => {
-  const result = await popFromQueue(`${queue_name}`);
-  return result;
-};
-
-// src/services/queue_service_redis.ts
-var queue_service_redis_exports = {};
-__export(queue_service_redis_exports, {
-  popAgentTaskFromQueue: () => popAgentTaskFromQueue2,
-  pushAgentTaskToQueue: () => pushAgentTaskToQueue2
-});
-var import_redis = require("redis");
-var queue_name2 = process.env.QUEUE_NAME || "tasks";
-var redisOptions = {
-  url: process.env.REDIS_URL || "redis://localhost:6379",
-  password: process.env.REDIS_PASSWORD
-};
-var redisClient = (0, import_redis.createClient)(redisOptions);
-(async () => {
-  redisClient.on(
-    "error",
-    (err) => console.error("Redis Client Error", err)
-  );
-  try {
-    await redisClient.connect();
-    console.log("Redis connection successful");
-  } catch (error) {
-    console.error("Redis connection failed:", error);
-  }
-})();
-var sendToQueue2 = async (queueName, message) => {
-  try {
-    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 };
-  }
-};
-var popFromQueue2 = async (queueName) => {
-  try {
-    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 };
-  }
-};
-var createTenantQueue2 = async () => {
-  try {
-    const exists = await redisClient.exists(queue_name2);
-    return { success: true, queue_name: queue_name2 };
-  } catch (error) {
-    console.error(error);
-    return { success: false, error };
-  }
-};
-var pushAgentTaskToQueue2 = async (agentTask) => {
-  const tenantId = agentTask["x-tenant-id"];
-  try {
-    await createTenantQueue2();
-    const result = await sendToQueue2(`${queue_name2}`, agentTask);
-    return result;
-  } catch (error) {
-    console.error(error);
-    return null;
-  }
-};
-var popAgentTaskFromQueue2 = async () => {
-  const result = await popFromQueue2(`${queue_name2}`);
-  return result;
-};
-
-// src/services/queue_service.ts
-var queueServiceType = process.env.QUEUE_SERVICE_TYPE || "memory";
-var setQueueServiceType = (type) => {
-  queueServiceType = type;
-  console.log(`Queue service type set to: ${type}`);
-};
-var getQueueService = () => {
-  return queueServiceType === "redis" ? queue_service_redis_exports : queue_service_memory_exports;
-};
-var pushAgentTaskToQueue3 = async (agentTask) => {
-  const service = getQueueService();
-  return service.pushAgentTaskToQueue(agentTask);
-};
-var popAgentTaskFromQueue3 = async () => {
-  const service = getQueueService();
-  return service.popAgentTaskFromQueue();
-};
-
-// src/services/event_bus.ts
-var EventBus = class {
-  constructor() {
-    this.emitter = new import_events.EventEmitter();
-    this.emitter.setMaxListeners(100);
-  }
-  /**
-   * 发布事件
-   * @param eventName 事件名称
-   * @param data 事件数据
-   */
-  publish(eventName, data, useQueue = false) {
-    if (useQueue) {
-      pushAgentTaskToQueue3(data);
-    } else {
-      this.emitter.emit(eventName, data);
-    }
-  }
-  /**
-   * 订阅事件
-   * @param eventName 事件名称
-   * @param callback 回调函数
-   */
-  subscribe(eventName, callback) {
-    this.emitter.on(eventName, callback);
-  }
-  /**
-   * 取消订阅事件
-   * @param eventName 事件名称
-   * @param callback 回调函数
-   */
-  unsubscribe(eventName, callback) {
-    this.emitter.off(eventName, callback);
-  }
-  /**
-   * 只订阅一次事件
-   * @param eventName 事件名称
-   * @param callback 回调函数
-   */
-  subscribeOnce(eventName, callback) {
-    this.emitter.once(eventName, callback);
-  }
-};
-var eventBus = new EventBus();
-var event_bus_default = eventBus;
-
-// src/services/AgentManager.ts
-var AgentManager = class _AgentManager {
-  constructor() {
-    this.agents = [];
-  }
-  static getInstance() {
-    if (!_AgentManager.instance) {
-      _AgentManager.instance = new _AgentManager();
-    }
-    return _AgentManager.instance;
-  }
-  callAgentInQueue(queue) {
-    return new Promise((resolve, reject) => {
-      try {
-        event_bus_default.publish(
-          AGENT_TASK_EVENT,
-          {
-            ...queue
-          },
-          true
-        );
-        resolve(true);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  }
-};
-
 // src/controllers/agent_task.ts
+var import_core2 = require("@axiom-lattice/core");
 var triggerAgentTask = async (request, reply) => {
   try {
     const { assistant_id, thread_id, input, command } = request.body;
@@ -791,7 +554,7 @@ var triggerAgentTask = async (request, reply) => {
       });
       return;
     }
-    const agentManager = AgentManager.getInstance();
+    const agentManager = import_core2.AgentManager.getInstance();
     const result = await agentManager.callAgentInQueue({
       assistant_id,
       thread_id,
@@ -1225,7 +988,52 @@ var configureSwagger = async (app2, customSwaggerConfig, customSwaggerUiConfig)
   await app2.register(import_swagger_ui.default, swaggerUiConfig);
 };
 
+// src/services/queue_service.ts
+var import_core3 = 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_core3.queueLatticeManager.hasLattice(DEFAULT_QUEUE_KEY)) {
+    import_core3.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_core3.registerQueueLattice)(DEFAULT_QUEUE_KEY, config, client);
+};
+var getQueueService = () => {
+  if (!import_core3.queueLatticeManager.hasLattice(DEFAULT_QUEUE_KEY)) {
+    setQueueServiceType(queueServiceType);
+  }
+  return (0, import_core3.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_core4 = require("@axiom-lattice/core");
 var handleAgentTask = async (taskRequest, retryCount = 0) => {
   const {
     assistant_id,
@@ -1261,16 +1069,59 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
     if (!response.ok) {
       throw new Error(`API\u8BF7\u6C42\u5931\u8D25: ${response.status} ${response.statusText}`);
     }
-    if (callback_event) {
-      event_bus_default.publish(callback_event, {
-        success: true,
-        config: { assistant_id, thread_id, tenant_id }
-      });
+    const contentType = response.headers.get("content-type");
+    if (contentType?.includes("text/event-stream")) {
+      const reader = response.body?.getReader();
+      const decoder = new TextDecoder();
+      if (!reader) {
+        throw new Error("Response body is not readable");
+      }
+      let buffer = "";
+      let streamEnded = false;
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            streamEnded = true;
+            console.log(
+              `SSE\u6D41\u5DF2\u7ED3\u675F [assistant_id: ${assistant_id}, thread_id: ${thread_id}]`
+            );
+            break;
+          }
+        }
+      } catch (streamError) {
+        console.error("Error reading SSE stream:", streamError);
+        throw streamError;
+      } finally {
+        reader.releaseLock();
+      }
+      if (callback_event) {
+        const state = await agent_state({ assistant_id, thread_id });
+        import_core4.eventBus.publish(callback_event, {
+          success: true,
+          state,
+          config: { assistant_id, thread_id, tenant_id }
+        });
+      }
+      console.log(
+        `\u4EFB\u52A1\u5904\u7406\u6210\u529F [assistant_id: ${assistant_id}, thread_id: ${thread_id}]`
+      );
+      return true;
+    } else {
+      await response.text();
+      if (callback_event) {
+        const state = await agent_state({ assistant_id, thread_id });
+        import_core4.eventBus.publish(callback_event, {
+          success: true,
+          state,
+          config: { assistant_id, thread_id, tenant_id }
+        });
+      }
+      console.log(
+        `\u4EFB\u52A1\u5904\u7406\u6210\u529F [assistant_id: ${assistant_id}, thread_id: ${thread_id}]`
+      );
+      return true;
     }
-    console.log(
-      `\u4EFB\u52A1\u5904\u7406\u6210\u529F [assistant_id: ${assistant_id}, thread_id: ${thread_id}]`
-    );
-    return true;
   } catch (error) {
     console.error(
       `Agent\u4EFB\u52A1\u6267\u884C\u5931\u8D25: ${assistant_id}, \u7EBF\u7A0B: ${thread_id}`,
@@ -1287,7 +1138,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       return handleAgentTask(taskRequest, nextRetryCount);
     }
     if (callback_event) {
-      event_bus_default.publish(callback_event, {
+      import_core4.eventBus.publish(callback_event, {
         success: false,
         error: error instanceof Error ? error.message : String(error),
         config: { assistant_id, thread_id, tenant_id }
@@ -1325,7 +1176,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
    * 初始化事件监听和队列轮询
    */
   initialize() {
-    event_bus_default.subscribe(AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
+    import_core4.eventBus.subscribe(import_core4.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");
   }
@@ -1368,7 +1219,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
    */
   async processNextTask() {
     try {
-      const queueResult = await popAgentTaskFromQueue3();
+      const queueResult = await popAgentTaskFromQueue();
       if (queueResult && queueResult.data) {
         const taskItem = queueResult.data;
         if (taskItem && typeof taskItem === "object") {
@@ -1444,7 +1295,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) {
-        event_bus_default.publish(taskRequest.callback_event, {
+        import_core4.eventBus.publish(taskRequest.callback_event, {
           success: false,
           error: error instanceof Error ? error.message : String(error),
           config: {