@axiom-lattice/core 2.1.41 → 2.1.43

package/dist/index.js

@@ -6654,36 +6654,35 @@ var InMemoryThreadMessageQueueStore = class {
   }
   async addMessageAtHead(threadId, content, type = "system") {
     const threadMessages = this.getMessagesForThread(threadId);
-    threadMessages.forEach((msg) => {
-      msg.sequence += 1;
-    });
     let tenantId = "default";
     let assistantId = "";
     if (threadMessages.length > 0) {
       tenantId = threadMessages[0].tenantId || "default";
       assistantId = threadMessages[0].assistantId || "";
     }
+    const nextSequence = threadMessages.length;
     const message = {
       id: this.generateId(),
       content,
       type,
-      sequence: 0,
+      sequence: nextSequence,
       createdAt: /* @__PURE__ */ new Date(),
       status: "pending",
       tenantId,
       assistantId,
-      priority: 0
+      priority: 100
+      // High priority for head messages (STEER/Command)
     };
-    threadMessages.unshift(message);
+    threadMessages.push(message);
     return message;
   }
   async getPendingMessages(threadId) {
     const threadMessages = this.getMessagesForThread(threadId);
-    return threadMessages.filter((msg) => msg.status === "pending" || !msg.status).sort((a, b) => a.sequence - b.sequence).map(({ status, tenantId, assistantId, ...message }) => message);
+    return threadMessages.filter((msg) => msg.status === "pending" || !msg.status).sort((a, b) => (b.priority || 0) - (a.priority || 0) || a.sequence - b.sequence).map(({ status, tenantId, assistantId, ...message }) => message);
   }
   async getProcessingMessages(threadId) {
     const threadMessages = this.getMessagesForThread(threadId);
-    return threadMessages.filter((msg) => msg.status === "processing").sort((a, b) => a.sequence - b.sequence).map(({ status, tenantId, assistantId, ...message }) => message);
+    return threadMessages.filter((msg) => msg.status === "processing").sort((a, b) => (b.priority || 0) - (a.priority || 0) || a.sequence - b.sequence).map(({ status, tenantId, assistantId, ...message }) => message);
   }
   async getQueueSize(threadId) {
     const pending = await this.getPendingMessages(threadId);
@@ -6692,11 +6691,11 @@ var InMemoryThreadMessageQueueStore = class {
   async getThreadsWithPendingMessages() {
     const result = [];
     for (const [threadId, messages] of this.messages.entries()) {
-      const pendingMessages = messages.filter(
-        (msg) => msg.status === "pending" || !msg.status
+      const pendingOrProcessingMessages = messages.filter(
+        (msg) => msg.status === "pending" || msg.status === "processing" || !msg.status
       );
-      if (pendingMessages.length > 0) {
-        const firstMessage = pendingMessages[0];
+      if (pendingOrProcessingMessages.length > 0) {
+        const firstMessage = pendingOrProcessingMessages[0];
         result.push({
           tenantId: firstMessage.tenantId || "default",
           assistantId: firstMessage.assistantId || "",
@@ -6746,6 +6745,20 @@ var InMemoryThreadMessageQueueStore = class {
       this.messages.set(threadId, filtered);
     }
   }
+  async resetProcessingToPending(threadId) {
+    const messages = this.messages.get(threadId);
+    if (!messages) {
+      return 0;
+    }
+    let count = 0;
+    for (const msg of messages) {
+      if (msg.status === "processing") {
+        msg.status = "pending";
+        count++;
+      }
+    }
+    return count;
+  }
 };
 
 // src/store_lattice/StoreLatticeManager.ts
@@ -10760,6 +10773,9 @@ function createTaskTool(options) {
         }
         return returnCommandWithStateUpdate(result, config.toolCall.id);
       } catch (error) {
+        if (error instanceof import_langgraph7.GraphInterrupt) {
+          throw error;
+        }
         return new import_langgraph7.Command({
           update: {
             messages: [
@@ -10949,13 +10965,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
       });
@@ -14105,7 +14121,7 @@ var AgentParamsBuilder = class {
    * @param options build options
    * @returns Agent build parameters
    */
-  buildParams(agentLattice, options) {
+  async buildParams(agentLattice, options) {
     const skills = (0, import_protocols4.isDeepAgentConfig)(agentLattice.config) ? agentLattice.config.skillCategories : void 0;
     const toolKeys = options?.overrideTools || (0, import_protocols4.getToolsFromConfig)(agentLattice.config);
     const tools = toolKeys.map((toolKey) => {
@@ -14125,8 +14141,8 @@ var AgentParamsBuilder = class {
       throw new Error(`Model "${modelKey}" does not exist`);
     }
     const subAgentKeys = (0, import_protocols4.getSubAgentsFromConfig)(agentLattice.config);
-    const subAgents = subAgentKeys.map((agentKey) => {
-      const subAgentLattice = this.getAgentLatticeFunc(agentKey);
+    const subAgents = await Promise.all(subAgentKeys.map(async (agentKey) => {
+      const subAgentLattice = await this.getAgentLatticeFunc(agentKey);
       if (!subAgentLattice) {
         throw new Error(`SubAgent "${agentKey}" does not exist`);
       }
@@ -14135,7 +14151,7 @@ var AgentParamsBuilder = class {
         config: subAgentLattice.config,
         client: subAgentLattice.client
       };
-    });
+    }));
     let internalSubAgents = [];
     if ((0, import_protocols4.isDeepAgentConfig)(agentLattice.config)) {
       internalSubAgents = agentLattice.config.internalSubAgents?.map((i) => ({
@@ -14213,7 +14229,7 @@ var AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager
       }
       const config = assistantToConfig(assistant);
       const agentLattice = {
-        config,
+        config: { ...config, tenantId },
         client: void 0
       };
       return agentLattice;
@@ -14520,13 +14536,13 @@ var AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager
    * @param options 构建选项
    * @returns 返回Agent构建参数
    */
-  buildAgentParams(agentLattice, options) {
+  async buildAgentParams(agentLattice, options) {
     const tenantId = agentLattice.config.tenantId || "default";
-    const paramsBuilder = new AgentParamsBuilder((key) => {
-      this.initializeClient(tenantId, key);
+    const paramsBuilder = new AgentParamsBuilder(async (key) => {
+      await this.initializeClientAsync(tenantId, key);
       return this.getAgentLatticeWithTenant(tenantId, key);
     });
-    const params = paramsBuilder.buildParams(agentLattice, options);
+    const params = await paramsBuilder.buildParams(agentLattice, options);
     return {
       ...params,
       tenantId
@@ -14547,7 +14563,7 @@ var AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager
     };
     const factory = AgentGraphBuilderFactory.getInstance();
     const builder = factory.getBuilder(resolvedConfig.type);
-    const params = this.buildAgentParams(resolvedLattice, options);
+    const params = await this.buildAgentParams(resolvedLattice, options);
     return await builder.build(resolvedLattice, params);
   }
   /**
@@ -14625,7 +14641,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 +14729,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 +14745,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 +14843,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 +14943,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 +14992,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 +15135,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 +15416,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 +15462,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 +15493,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 +15502,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 +15516,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 +15555,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 +15577,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 +15593,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 +15605,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 +15629,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 +15650,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 +15668,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 +15690,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 +15702,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 +15728,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 +15738,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 +15751,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 +15803,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 +16115,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 +16337,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.`
         );
@@ -17008,7 +16978,7 @@ var Agent = class {
       command,
       custom_run_config
     }, signal) => {
-      const runnable_agent = await getAgentClient(this.tenant_id, this.assistant_id);
+      const runnable_agent = await getAgentClientAsync(this.tenant_id, this.assistant_id);
       const agentLattice = agentLatticeManager.getAgentLatticeWithTenant(this.tenant_id, this.assistant_id);
       const { messages, ...rest } = input;
       const lifecycleManager = this;
@@ -17090,9 +17060,7 @@ var Agent = class {
               };
             }
             if (data) {
-              if (data.type !== "interrupt") {
-                await lifecycleManager.addChunk(data);
-              }
+              lifecycleManager.addChunk(data);
             }
           }
         } catch (error) {
@@ -17109,8 +17077,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 +17086,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];
@@ -17138,22 +17115,49 @@ var Agent = class {
             const input = {
               messages: [new import_langchain61.HumanMessage({ id: p.content.id, content: p.content.message })]
             };
+            const queueMessageData = p.content.queueMessage || {};
             try {
               await this.agentStreamExecutor({
                 input,
-                command: p.content.command
+                command: queueMessageData.command || p.content.command,
+                custom_run_config: queueMessageData.custom_run_config
               }, 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,
@@ -17180,22 +17184,51 @@ var Agent = class {
                 queueMode: "collect" /* COLLECT */
               });
             });
+            const firstQueueMessage = remainingPendings[0]?.content?.queueMessage || {};
             try {
-              await this.agentStreamExecutor({ input: { messages: userMessages } }, signal);
+              await this.agentStreamExecutor({
+                input: { messages: userMessages },
+                custom_run_config: firstQueueMessage.custom_run_config
+              }, 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,
@@ -17218,19 +17251,48 @@ var Agent = class {
                 timestamp: /* @__PURE__ */ new Date(),
                 queueMode: "followup" /* FOLLOWUP */
               });
+              const queueMessageData = p.content.queueMessage || {};
               try {
-                await this.agentStreamExecutor({ input: { messages: [message] } }, signal);
+                await this.agentStreamExecutor({
+                  input: { messages: [message] },
+                  custom_run_config: queueMessageData.custom_run_config
+                }, 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 +17322,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 +17382,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 {
@@ -17379,11 +17437,14 @@ var Agent = class {
     }
     const content = {
       message: queueMessage.input.message,
-      id: messageId
+      id: messageId,
+      // Store complete queue message data for recovery
+      queueMessage: {
+        input: queueMessage.input,
+        command: queueMessage.command,
+        custom_run_config: queueMessage.custom_run_config
+      }
     };
-    if (queueMessage.command) {
-      content.command = queueMessage.command;
-    }
     if (isHighPriority) {
       await store.addMessageAtHead(this.thread_id, content, "human");
     } else {
@@ -17411,7 +17472,7 @@ var Agent = class {
   }
   /**
    * Start queue processor if not already running
-   * Private method used internally by addMessage
+   * Public method to allow external triggering (e.g., from recovery)
    */
   async startQueueProcessorIfNeeded() {
     const store = this.getQueueStore();
@@ -17499,6 +17560,30 @@ var Agent = class {
     }
     return "idle" /* IDLE */;
   }
+  /**
+   * Resume task processing after server restart
+   * Resets any stuck processing messages to pending and starts queue processing
+   * Note: Does not rely on LangGraph state as it may be stale after crash/restart
+   */
+  async resumeTask() {
+    try {
+      await agentLatticeManager.initializeClientAsync(this.tenant_id, this.assistant_id);
+    } catch (error) {
+      console.error(`[Agent] Failed to initialize agent lattice for ${this.assistant_id} (tenant: ${this.tenant_id}):`, error);
+      throw error;
+    }
+    const runStatus = await this.getRunStatus();
+    if (runStatus === "interrupted" /* INTERRUPTED */) {
+      console.log(`[Agent] Skipping resume for ${this.assistant_id} (tenant: ${this.tenant_id}) - agent is in interrupted state`);
+      return;
+    }
+    const store = this.getQueueStore();
+    const resetCount = await store.resetProcessingToPending(this.thread_id);
+    if (resetCount > 0) {
+      console.log(`[Agent] Reset ${resetCount} processing messages to pending for thread ${this.thread_id}`);
+    }
+    await this.startQueueProcessorIfNeeded();
+  }
   /**
    * Abort the current agent execution
    * This will cancel any ongoing invoke or stream operations
@@ -17542,6 +17627,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);
   }
 };
@@ -17607,6 +17693,57 @@ var AgentInstanceManager = class _AgentInstanceManager {
     });
     this.agents.clear();
   }
+  /**
+   * Restore agent instances for threads with pending messages after server restart
+   * Queries the message queue store for threads with pending/processing messages
+   * and recreates agent instances to resume processing
+   */
+  async restore() {
+    const stats = { restored: 0, errors: 0 };
+    try {
+      const queueStoreLattice = storeLatticeManager.getStoreLattice("default", "threadMessageQueue");
+      const queueStore = queueStoreLattice.store;
+      const threadsWithPending = await queueStore.getThreadsWithPendingMessages();
+      if (threadsWithPending.length === 0) {
+        console.log("[AgentInstanceManager] No threads with pending messages found");
+        return stats;
+      }
+      console.log(`[AgentInstanceManager] Found ${threadsWithPending.length} threads with pending messages, restoring...`);
+      for (const threadInfo of threadsWithPending) {
+        try {
+          await this.restoreThread(threadInfo, queueStore);
+          stats.restored++;
+        } catch (error) {
+          console.error(`[AgentInstanceManager] Failed to restore thread ${threadInfo.threadId}:`, error);
+          stats.errors++;
+        }
+      }
+      console.log(`[AgentInstanceManager] Restore complete: ${stats.restored} restored, ${stats.errors} errors`);
+      return stats;
+    } catch (error) {
+      console.error("[AgentInstanceManager] Restore failed:", error);
+      throw error;
+    }
+  }
+  /**
+   * Restore a single thread
+   * Delegates actual recovery logic to Agent.resumeTask()
+   */
+  async restoreThread(threadInfo, queueStore) {
+    const { tenantId, assistantId, threadId } = threadInfo;
+    const threadParams = {
+      tenant_id: tenantId,
+      assistant_id: assistantId,
+      thread_id: threadId,
+      workspace_id: "default",
+      // TODO: Get from thread store
+      project_id: "default"
+      // TODO: Get from thread store
+    };
+    const agent = this.getAgent(threadParams);
+    await agent.resumeTask();
+    console.log(`[AgentInstanceManager] Restored thread ${threadId}`);
+  }
 };
 var agentInstanceManager = AgentInstanceManager.getInstance();