@axiom-lattice/core 2.1.41 → 2.1.42

package/dist/index.js

@@ -10949,13 +10949,13 @@ var StoreBackend = class {
    * @returns List of all items matching the search criteria
    */
   async searchStorePaginated(store, namespace, options = {}) {
-    const { query, filter, pageSize = 100 } = options;
+    const { query, filter: filter2, pageSize = 100 } = options;
     const allItems = [];
     let offset = 0;
     while (true) {
       const pageItems = await store.search(namespace, {
         query,
-        filter,
+        filter: filter2,
         limit: pageSize,
         offset
       });
@@ -14625,7 +14625,10 @@ var ChunkBuffer = class {
 };
 
 // src/chunk_buffer_lattice/InMemoryChunkBuffer.ts
+var import_protocols5 = require("@axiom-lattice/protocols");
 var import_rxjs = require("rxjs");
+var import_rxjs_for_await = require("rxjs-for-await");
+var import_operators = require("rxjs/operators");
 var InMemoryChunkBuffer = class extends ChunkBuffer {
   constructor(config) {
     super();
@@ -14710,7 +14713,7 @@ var InMemoryChunkBuffer = class extends ChunkBuffer {
     let chunk;
     if (typeof arg2 === "string" && arg3 !== void 0) {
       chunk = {
-        type: "message_chunk",
+        type: import_protocols5.MessageChunkTypes.AI,
         data: {
           id: arg2,
           content: arg3
@@ -14726,7 +14729,6 @@ var InMemoryChunkBuffer = class extends ChunkBuffer {
     buffer2.status = "active" /* ACTIVE */;
   }
   async completeThread(threadId) {
-    console.log("completeThread");
     const buffer2 = this.getBufferIfValid(threadId);
     if (buffer2) {
       buffer2.status = "completed" /* COMPLETED */;
@@ -14825,75 +14827,27 @@ var InMemoryChunkBuffer = class extends ChunkBuffer {
       buffer2.updatedAt = Date.now();
     }
   }
-  async *getNewChunksSinceContentIterator(threadId, messageId, knownContent) {
+  async *getNewChunksSinceContentIterator(threadId, messageId, knownContent, stopTypes) {
     const buffer2 = this.getBufferIfValid(threadId);
     if (!buffer2) return;
-    let accumulatedContent = "";
-    const queue = [];
-    let resolveNext = null;
-    let errorNext = null;
-    let isCompleted = false;
-    let pendingError = null;
-    const subscription = buffer2.chunks$.pipe((0, import_rxjs.observeOn)(import_rxjs.asyncScheduler)).subscribe({
-      next: (chunk) => {
-        queue.push(chunk);
-        if (resolveNext) {
-          const resolve3 = resolveNext;
-          resolveNext = null;
-          resolve3();
-        }
-      },
-      error: (err) => {
-        pendingError = err;
-        if (errorNext) {
-          const reject = errorNext;
-          errorNext = null;
-          reject(err);
-        } else if (resolveNext) {
-          const resolve3 = resolveNext;
-          resolveNext = null;
-          resolve3();
-        }
-      },
-      complete: () => {
-        isCompleted = true;
-        if (resolveNext) {
-          const resolve3 = resolveNext;
-          resolveNext = null;
-          resolve3();
-        }
-      }
-    });
+    const defaultStopTypes = [
+      import_protocols5.MessageChunkTypes.MESSAGE_COMPLETED,
+      import_protocols5.MessageChunkTypes.THREAD_IDLE
+    ];
+    const typesToStop = stopTypes ?? defaultStopTypes;
     let startYieldChunk = false;
-    try {
-      while (true) {
-        if (pendingError) {
-          throw pendingError;
-        }
-        if (queue.length === 0) {
-          if (isCompleted) break;
-          await new Promise((resolve3, reject) => {
-            resolveNext = resolve3;
-            errorNext = reject;
-          });
-        }
-        if (pendingError) {
-          throw pendingError;
-        }
-        while (queue.length > 0) {
-          const chunk = queue.shift();
-          if (!chunk) continue;
-          if (chunk.data?.id === messageId) {
-            startYieldChunk = true;
-          }
-          if (startYieldChunk) {
-            yield chunk;
-          }
-        }
-      }
-    } finally {
-      subscription.unsubscribe();
-    }
+    console.log("start from messageId", messageId);
+    const filtered$ = buffer2.chunks$.pipe(
+      (0, import_rxjs.observeOn)(import_rxjs.asyncScheduler),
+      // 1. 从指定 messageId 开始
+      (0, import_operators.filter)((chunk) => {
+        if (chunk.data?.id === messageId) startYieldChunk = true;
+        return startYieldChunk;
+      }),
+      // 2. 包含指定的停止类型，但收到后停止
+      (0, import_operators.takeWhile)((chunk) => !typesToStop.includes(chunk.type), true)
+    );
+    yield* (0, import_rxjs_for_await.eachValueFrom)(filtered$);
   }
   getStats() {
     let activeCount = 0;
@@ -14973,13 +14927,13 @@ var buffer = new InMemoryChunkBuffer({
 registerChunkBuffer("default", buffer);
 
 // src/schedule_lattice/ScheduleLatticeManager.ts
-var import_protocols7 = require("@axiom-lattice/protocols");
+var import_protocols8 = require("@axiom-lattice/protocols");
 
 // src/schedule_lattice/DefaultScheduleClient.ts
-var import_protocols6 = require("@axiom-lattice/protocols");
+var import_protocols7 = require("@axiom-lattice/protocols");
 
 // src/schedule_lattice/MemoryScheduleStorage.ts
-var import_protocols5 = require("@axiom-lattice/protocols");
+var import_protocols6 = require("@axiom-lattice/protocols");
 var MemoryScheduleStorage = class {
   constructor() {
     this.tasks = /* @__PURE__ */ new Map();
@@ -15022,7 +14976,7 @@ var MemoryScheduleStorage = class {
   async getActiveTasks() {
     const result = [];
     for (const task of this.tasks.values()) {
-      if (task.status === import_protocols5.ScheduledTaskStatus.PENDING || task.status === import_protocols5.ScheduledTaskStatus.PAUSED) {
+      if (task.status === import_protocols6.ScheduledTaskStatus.PENDING || task.status === import_protocols6.ScheduledTaskStatus.PAUSED) {
         result.push({ ...task });
       }
     }
@@ -15165,7 +15119,7 @@ var MemoryScheduleStorage = class {
     const cutoff = Date.now() - olderThanMs;
     let deleted = 0;
     for (const [taskId, task] of this.tasks.entries()) {
-      if ((task.status === import_protocols5.ScheduledTaskStatus.COMPLETED || task.status === import_protocols5.ScheduledTaskStatus.CANCELLED || task.status === import_protocols5.ScheduledTaskStatus.FAILED) && task.updatedAt < cutoff) {
+      if ((task.status === import_protocols6.ScheduledTaskStatus.COMPLETED || task.status === import_protocols6.ScheduledTaskStatus.CANCELLED || task.status === import_protocols6.ScheduledTaskStatus.FAILED) && task.updatedAt < cutoff) {
         this.tasks.delete(taskId);
         deleted++;
       }
@@ -15446,10 +15400,10 @@ var _DefaultScheduleClient = class _DefaultScheduleClient {
       tenantId: options.tenantId ?? "default",
       assistantId: options.assistantId,
       threadId: options.threadId,
-      executionType: import_protocols6.ScheduleExecutionType.ONCE,
+      executionType: import_protocols7.ScheduleExecutionType.ONCE,
       executeAt,
       delayMs: options.delayMs,
-      status: import_protocols6.ScheduledTaskStatus.PENDING,
+      status: import_protocols7.ScheduledTaskStatus.PENDING,
       runCount: 0,
       retryCount: 0,
       maxRetries: options.maxRetries ?? 0,
@@ -15492,11 +15446,11 @@ var _DefaultScheduleClient = class _DefaultScheduleClient {
       tenantId: options.tenantId ?? "default",
       assistantId: options.assistantId,
       threadId: options.threadId,
-      executionType: import_protocols6.ScheduleExecutionType.CRON,
+      executionType: import_protocols7.ScheduleExecutionType.CRON,
       cronExpression: options.cronExpression,
       timezone: options.timezone,
       nextRunAt: nextRunAt.getTime(),
-      status: import_protocols6.ScheduledTaskStatus.PENDING,
+      status: import_protocols7.ScheduledTaskStatus.PENDING,
       runCount: 0,
       maxRuns: options.maxRuns,
       retryCount: 0,
@@ -15523,7 +15477,7 @@ var _DefaultScheduleClient = class _DefaultScheduleClient {
     const task = await this.storage.get(taskId);
     if (task) {
       await this.storage.update(taskId, {
-        status: import_protocols6.ScheduledTaskStatus.CANCELLED
+        status: import_protocols7.ScheduledTaskStatus.CANCELLED
       });
       console.log(`[Scheduler] Task cancelled: ${taskId}`);
       return true;
@@ -15532,11 +15486,11 @@ var _DefaultScheduleClient = class _DefaultScheduleClient {
   }
   async pause(taskId) {
     const task = await this.storage.get(taskId);
-    if (!task || task.executionType !== import_protocols6.ScheduleExecutionType.CRON) {
+    if (!task || task.executionType !== import_protocols7.ScheduleExecutionType.CRON) {
       console.error(`[Scheduler] Can only pause CRON tasks: ${taskId}`);
       return false;
     }
-    if (task.status !== import_protocols6.ScheduledTaskStatus.PENDING) {
+    if (task.status !== import_protocols7.ScheduledTaskStatus.PENDING) {
       console.error(`[Scheduler] Can only pause PENDING tasks: ${taskId}`);
       return false;
     }
@@ -15546,24 +15500,24 @@ var _DefaultScheduleClient = class _DefaultScheduleClient {
       this.timers.delete(taskId);
     }
     await this.storage.update(taskId, {
-      status: import_protocols6.ScheduledTaskStatus.PAUSED
+      status: import_protocols7.ScheduledTaskStatus.PAUSED
     });
     console.log(`[Scheduler] Task paused: ${taskId}`);
     return true;
   }
   async resume(taskId) {
     const task = await this.storage.get(taskId);
-    if (!task || task.executionType !== import_protocols6.ScheduleExecutionType.CRON) {
+    if (!task || task.executionType !== import_protocols7.ScheduleExecutionType.CRON) {
       console.error(`[Scheduler] Can only resume CRON tasks: ${taskId}`);
       return false;
     }
-    if (task.status !== import_protocols6.ScheduledTaskStatus.PAUSED) {
+    if (task.status !== import_protocols7.ScheduledTaskStatus.PAUSED) {
       console.error(`[Scheduler] Can only resume PAUSED tasks: ${taskId}`);
       return false;
     }
     const nextRunAt = getNextCronTime(task.cronExpression);
     await this.storage.update(taskId, {
-      status: import_protocols6.ScheduledTaskStatus.PENDING,
+      status: import_protocols7.ScheduledTaskStatus.PENDING,
       nextRunAt: nextRunAt.getTime()
     });
     const updatedTask = await this.storage.get(taskId);
@@ -15585,7 +15539,7 @@ var _DefaultScheduleClient = class _DefaultScheduleClient {
     if (!task) {
       return -1;
     }
-    const targetTime = task.executionType === import_protocols6.ScheduleExecutionType.CRON ? task.nextRunAt : task.executeAt;
+    const targetTime = task.executionType === import_protocols7.ScheduleExecutionType.CRON ? task.nextRunAt : task.executeAt;
     if (targetTime === void 0) {
       return -1;
     }
@@ -15607,7 +15561,7 @@ var _DefaultScheduleClient = class _DefaultScheduleClient {
     const activeTasks = await this.storage.getActiveTasks();
     for (const task of activeTasks) {
       await this.storage.update(task.taskId, {
-        status: import_protocols6.ScheduledTaskStatus.CANCELLED
+        status: import_protocols7.ScheduledTaskStatus.CANCELLED
       });
     }
     console.log(`[Scheduler] All tasks cancelled`);
@@ -15623,10 +15577,10 @@ var _DefaultScheduleClient = class _DefaultScheduleClient {
         );
         continue;
       }
-      if (task.status === import_protocols6.ScheduledTaskStatus.PAUSED) {
+      if (task.status === import_protocols7.ScheduledTaskStatus.PAUSED) {
         continue;
       }
-      if (task.executionType === import_protocols6.ScheduleExecutionType.ONCE) {
+      if (task.executionType === import_protocols7.ScheduleExecutionType.ONCE) {
         if (task.executeAt && task.executeAt <= Date.now()) {
           console.log(
             `[Scheduler] Executing overdue one-time task: ${task.taskId}`
@@ -15635,7 +15589,7 @@ var _DefaultScheduleClient = class _DefaultScheduleClient {
         } else {
           this.scheduleTimer(task);
         }
-      } else if (task.executionType === import_protocols6.ScheduleExecutionType.CRON) {
+      } else if (task.executionType === import_protocols7.ScheduleExecutionType.CRON) {
         const nextRunAt = getNextCronTime(task.cronExpression);
         await this.storage.update(task.taskId, {
           nextRunAt: nextRunAt.getTime()
@@ -15659,7 +15613,7 @@ var _DefaultScheduleClient = class _DefaultScheduleClient {
   }
   // ===== Private Methods =====
   scheduleTimer(task) {
-    const targetTime = task.executionType === import_protocols6.ScheduleExecutionType.CRON ? task.nextRunAt : task.executeAt;
+    const targetTime = task.executionType === import_protocols7.ScheduleExecutionType.CRON ? task.nextRunAt : task.executeAt;
     if (targetTime === void 0) {
       console.error(`[Scheduler] No execution time for task: ${task.taskId}`);
       return;
@@ -15680,13 +15634,13 @@ var _DefaultScheduleClient = class _DefaultScheduleClient {
         `[Scheduler] No handler for task type: ${task.taskType}, task: ${task.taskId}`
       );
       await this.storage.update(task.taskId, {
-        status: import_protocols6.ScheduledTaskStatus.FAILED,
+        status: import_protocols7.ScheduledTaskStatus.FAILED,
         lastError: `No handler registered for task type: ${task.taskType}`
       });
       return;
     }
     await this.storage.update(task.taskId, {
-      status: import_protocols6.ScheduledTaskStatus.RUNNING
+      status: import_protocols7.ScheduledTaskStatus.RUNNING
     });
     console.log(`[Scheduler] Executing task: ${task.taskId}`);
     try {
@@ -15698,17 +15652,17 @@ var _DefaultScheduleClient = class _DefaultScheduleClient {
       await handler(latestTask.payload, latestTask);
       const newRunCount = latestTask.runCount + 1;
       console.log(`[Scheduler] Task completed: ${task.taskId}`);
-      if (task.executionType === import_protocols6.ScheduleExecutionType.ONCE) {
+      if (task.executionType === import_protocols7.ScheduleExecutionType.ONCE) {
         await this.storage.update(task.taskId, {
-          status: import_protocols6.ScheduledTaskStatus.COMPLETED,
+          status: import_protocols7.ScheduledTaskStatus.COMPLETED,
           runCount: newRunCount,
           lastRunAt: Date.now()
         });
         this.timers.delete(task.taskId);
-      } else if (task.executionType === import_protocols6.ScheduleExecutionType.CRON) {
+      } else if (task.executionType === import_protocols7.ScheduleExecutionType.CRON) {
         if (task.maxRuns !== void 0 && newRunCount >= task.maxRuns) {
           await this.storage.update(task.taskId, {
-            status: import_protocols6.ScheduledTaskStatus.COMPLETED,
+            status: import_protocols7.ScheduledTaskStatus.COMPLETED,
             runCount: newRunCount,
             lastRunAt: Date.now()
           });
@@ -15720,7 +15674,7 @@ var _DefaultScheduleClient = class _DefaultScheduleClient {
         }
         if (task.expiresAt !== void 0 && Date.now() >= task.expiresAt) {
           await this.storage.update(task.taskId, {
-            status: import_protocols6.ScheduledTaskStatus.COMPLETED,
+            status: import_protocols7.ScheduledTaskStatus.COMPLETED,
             runCount: newRunCount,
             lastRunAt: Date.now()
           });
@@ -15732,7 +15686,7 @@ var _DefaultScheduleClient = class _DefaultScheduleClient {
         }
         const nextRunAt = getNextCronTime(task.cronExpression);
         await this.storage.update(task.taskId, {
-          status: import_protocols6.ScheduledTaskStatus.PENDING,
+          status: import_protocols7.ScheduledTaskStatus.PENDING,
           runCount: newRunCount,
           lastRunAt: Date.now(),
           nextRunAt: nextRunAt.getTime(),
@@ -15758,7 +15712,7 @@ var _DefaultScheduleClient = class _DefaultScheduleClient {
           `[Scheduler] Retrying task: ${task.taskId} (attempt ${newRetryCount}/${latestTask.maxRetries})`
         );
         await this.storage.update(task.taskId, {
-          status: import_protocols6.ScheduledTaskStatus.PENDING,
+          status: import_protocols7.ScheduledTaskStatus.PENDING,
           retryCount: newRetryCount,
           lastError: errorMessage
         });
@@ -15768,7 +15722,7 @@ var _DefaultScheduleClient = class _DefaultScheduleClient {
         );
         const retryTask = await this.storage.get(task.taskId);
         if (retryTask) {
-          if (task.executionType === import_protocols6.ScheduleExecutionType.ONCE) {
+          if (task.executionType === import_protocols7.ScheduleExecutionType.ONCE) {
             retryTask.executeAt = Date.now() + retryDelay;
           } else {
             retryTask.nextRunAt = Date.now() + retryDelay;
@@ -15781,7 +15735,7 @@ var _DefaultScheduleClient = class _DefaultScheduleClient {
         }
       } else {
         await this.storage.update(task.taskId, {
-          status: import_protocols6.ScheduledTaskStatus.FAILED,
+          status: import_protocols7.ScheduledTaskStatus.FAILED,
           retryCount: newRetryCount,
           lastError: errorMessage
         });
@@ -15833,9 +15787,9 @@ var ScheduleLatticeManager = class _ScheduleLatticeManager extends BaseLatticeMa
       } else {
         storage = new MemoryScheduleStorage();
       }
-      if (config.type === import_protocols7.ScheduleType.MEMORY) {
+      if (config.type === import_protocols8.ScheduleType.MEMORY) {
         scheduleClient = new DefaultScheduleClient(storage);
-      } else if (config.type === import_protocols7.ScheduleType.POSTGRES) {
+      } else if (config.type === import_protocols8.ScheduleType.POSTGRES) {
         if (!config.storage) {
           throw new Error(
             `PostgreSQL schedule storage must be provided. Please install @axiom-lattice/pg-stores and pass the storage in config.storage.`
@@ -16145,7 +16099,7 @@ var getVectorStoreLattice = (key) => vectorStoreLatticeManager.getVectorStoreLat
 var getVectorStoreClient = (key) => vectorStoreLatticeManager.getVectorStoreClient(key);
 
 // src/logger_lattice/LoggerLatticeManager.ts
-var import_protocols8 = require("@axiom-lattice/protocols");
+var import_protocols9 = require("@axiom-lattice/protocols");
 
 // src/logger_lattice/PinoLoggerClient.ts
 var import_pino = __toESM(require("pino"));
@@ -16367,11 +16321,11 @@ var LoggerLatticeManager = class _LoggerLatticeManager extends BaseLatticeManage
     if (client) {
       loggerClient = client;
     } else {
-      if (config.type === import_protocols8.LoggerType.PINO) {
+      if (config.type === import_protocols9.LoggerType.PINO) {
         loggerClient = new PinoLoggerClient(config);
-      } else if (config.type === import_protocols8.LoggerType.CONSOLE) {
+      } else if (config.type === import_protocols9.LoggerType.CONSOLE) {
         loggerClient = new ConsoleLoggerClient(config);
-      } else if (config.type === import_protocols8.LoggerType.CUSTOM) {
+      } else if (config.type === import_protocols9.LoggerType.CUSTOM) {
         throw new Error(
           `Custom logger client must be provided. Please pass the client to registerLattice.`
         );
@@ -17090,9 +17044,7 @@ var Agent = class {
               };
             }
             if (data) {
-              if (data.type !== "interrupt") {
-                await lifecycleManager.addChunk(data);
-              }
+              lifecycleManager.addChunk(data);
             }
           }
         } catch (error) {
@@ -17109,8 +17061,8 @@ var Agent = class {
       while (!signal?.aborted) {
         const pendings = await this.getPendingMessages();
         if (pendings.length === 0) {
-          await this.tryToCompleteThread();
           const state = await this.getCurrentState();
+          const runStatus = await this.getRunStatus();
           const pendingCount = await this.getQueueStore().getQueueSize(this.thread_id);
           this.publish("thread:idle", {
             type: "thread:idle",
@@ -17118,6 +17070,15 @@ var Agent = class {
             pendingCount,
             state
           });
+          if (runStatus === "idle" /* IDLE */) {
+            this.addChunk({
+              type: "thread_idle",
+              data: {
+                id: this.thread_id,
+                content: ""
+              }
+            });
+          }
           break;
         }
         const firstMessage = pendings[0];
@@ -17144,16 +17105,41 @@ var Agent = class {
                 command: p.content.command
               }, signal);
               await this.queueStore?.markCompleted(p.id);
+              const runStatus = await this.getRunStatus();
               const state = await this.getCurrentState();
-              this.publish("message:completed", {
-                type: "message:completed",
-                messageId: p.content.id,
-                timestamp: /* @__PURE__ */ new Date(),
-                duration: Date.now() - startTime,
-                state
-              });
+              if (runStatus === "interrupted" /* INTERRUPTED */) {
+                this.publish("message:interrupted", {
+                  type: "message:interrupted",
+                  messageId: p.content.id,
+                  timestamp: /* @__PURE__ */ new Date(),
+                  duration: Date.now() - startTime,
+                  state
+                });
+              } else {
+                this.addChunk({
+                  type: "message_completed",
+                  data: {
+                    id: p.content.id,
+                    content: ""
+                  }
+                });
+                this.publish("message:completed", {
+                  type: "message:completed",
+                  messageId: p.content.id,
+                  timestamp: /* @__PURE__ */ new Date(),
+                  duration: Date.now() - startTime,
+                  state
+                });
+              }
             } catch (error) {
               console.error(`STEER/Command message ${p.id} execution failed:`, error);
+              this.addChunk({
+                type: "message_failed",
+                data: {
+                  id: p.content.id,
+                  content: error instanceof Error ? error.message : String(error)
+                }
+              });
               this.publish("message:failed", {
                 type: "message:failed",
                 messageId: p.content.id,
@@ -17182,20 +17168,45 @@ var Agent = class {
             });
             try {
               await this.agentStreamExecutor({ input: { messages: userMessages } }, signal);
+              const runStatus = await this.getRunStatus();
               const state = await this.getCurrentState();
               for (const p of remainingPendings) {
                 await this.queueStore?.markCompleted(p.id);
-                this.publish("message:completed", {
-                  type: "message:completed",
-                  messageId: p.content.id,
-                  timestamp: /* @__PURE__ */ new Date(),
-                  duration: Date.now() - startTime,
-                  state
-                });
+                if (runStatus === "interrupted" /* INTERRUPTED */) {
+                  this.publish("message:interrupted", {
+                    type: "message:interrupted",
+                    messageId: p.content.id,
+                    timestamp: /* @__PURE__ */ new Date(),
+                    duration: Date.now() - startTime,
+                    state
+                  });
+                } else {
+                  this.addChunk({
+                    type: "message_completed",
+                    data: {
+                      id: p.content.id,
+                      content: ""
+                    }
+                  });
+                  this.publish("message:completed", {
+                    type: "message:completed",
+                    messageId: p.content.id,
+                    timestamp: /* @__PURE__ */ new Date(),
+                    duration: Date.now() - startTime,
+                    state
+                  });
+                }
               }
             } catch (error) {
               console.error(`COLLECT mode execution failed:`, error);
               for (const p of remainingPendings) {
+                this.addChunk({
+                  type: "message_failed",
+                  data: {
+                    id: p.content.id,
+                    content: error instanceof Error ? error.message : String(error)
+                  }
+                });
                 this.publish("message:failed", {
                   type: "message:failed",
                   messageId: p.content.id,
@@ -17221,16 +17232,41 @@ var Agent = class {
               try {
                 await this.agentStreamExecutor({ input: { messages: [message] } }, signal);
                 await this.queueStore?.markCompleted(p.id);
+                const runStatus = await this.getRunStatus();
                 const state = await this.getCurrentState();
-                this.publish("message:completed", {
-                  type: "message:completed",
-                  messageId: p.content.id,
-                  timestamp: /* @__PURE__ */ new Date(),
-                  duration: Date.now() - startTime,
-                  state
-                });
+                if (runStatus === "interrupted" /* INTERRUPTED */) {
+                  this.publish("message:interrupted", {
+                    type: "message:interrupted",
+                    messageId: p.content.id,
+                    timestamp: /* @__PURE__ */ new Date(),
+                    duration: Date.now() - startTime,
+                    state
+                  });
+                } else {
+                  this.addChunk({
+                    type: "message_completed",
+                    data: {
+                      id: p.content.id,
+                      content: ""
+                    }
+                  });
+                  this.publish("message:completed", {
+                    type: "message:completed",
+                    messageId: p.content.id,
+                    timestamp: /* @__PURE__ */ new Date(),
+                    duration: Date.now() - startTime,
+                    state
+                  });
+                }
               } catch (error) {
                 console.error(`FOLLOWUP mode message ${p.id} execution failed:`, error);
+                this.addChunk({
+                  type: "message_failed",
+                  data: {
+                    id: p.content.id,
+                    content: error instanceof Error ? error.message : String(error)
+                  }
+                });
                 this.publish("message:failed", {
                   type: "message:failed",
                   messageId: p.content.id,
@@ -17260,11 +17296,12 @@ var Agent = class {
   addChunk(content) {
     return this.chunkBuffer.addChunk(this.thread_id, content);
   }
-  chunkStream(message_id, known_content = "") {
+  chunkStream(message_id, stopTypes) {
     const stream = this.chunkBuffer.getNewChunksSinceContentIterator(
       this.thread_id,
       message_id,
-      known_content
+      "",
+      stopTypes
     );
     return {
       [Symbol.asyncIterator]: async function* () {
@@ -17319,11 +17356,6 @@ var Agent = class {
     const store = this.getQueueStore();
     return await store.getPendingMessages(this.thread_id);
   }
-  async tryToCompleteThread() {
-    setTimeout(async () => {
-      await this.chunkBuffer.completeThread(this.thread_id);
-    }, 100);
-  }
   getQueueStore() {
     if (!this.queueStore) {
       try {
@@ -17542,6 +17574,7 @@ var Agent = class {
    */
   publish(eventName, data) {
     const namespacedEvent = `${eventName}:${this.tenant_id}:${this.thread_id}`;
+    console.log(namespacedEvent);
     event_bus_default.publish(namespacedEvent, data);
   }
 };