@axiom-lattice/core 2.1.42 → 2.1.44

package/dist/index.mjs

@@ -6452,10 +6452,10 @@ var InMemoryThreadMessageQueueStore = class {
     return this.messages.get(threadId);
   }
   async addMessage(params) {
-    const { threadId, tenantId, assistantId, content, type = "human", priority = 0, command } = params;
+    const { threadId, tenantId, assistantId, content, type = "human", priority = 0, command, id } = params;
     const threadMessages = this.getMessagesForThread(threadId);
     const message = {
-      id: this.generateId(),
+      id: id || this.generateId(),
       content,
       type,
       sequence: threadMessages.length,
@@ -6469,38 +6469,38 @@ var InMemoryThreadMessageQueueStore = class {
     threadMessages.push(message);
     return message;
   }
-  async addMessageAtHead(threadId, content, type = "system") {
+  async addMessageAtHead(threadId, content, type = "system", id, command) {
     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(),
+      id: 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)
+      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);
@@ -6509,11 +6509,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 || "",
@@ -6563,6 +6563,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
@@ -9897,7 +9911,7 @@ import {
   ToolMessage as ToolMessage3,
   humanInTheLoopMiddleware
 } from "langchain";
-import { Command as Command2, getCurrentTaskInput as getCurrentTaskInput2 } from "@langchain/langgraph";
+import { Command as Command2, getCurrentTaskInput as getCurrentTaskInput2, GraphInterrupt as GraphInterrupt3 } from "@langchain/langgraph";
 import { HumanMessage } from "@langchain/core/messages";
 
 // src/agent_worker/agent_worker_graph.ts
@@ -10595,6 +10609,9 @@ function createTaskTool(options) {
         }
         return returnCommandWithStateUpdate(result, config.toolCall.id);
       } catch (error) {
+        if (error instanceof GraphInterrupt3) {
+          throw error;
+        }
         return new Command2({
           update: {
             messages: [
@@ -13948,7 +13965,7 @@ var AgentParamsBuilder = class {
    * @param options build options
    * @returns Agent build parameters
    */
-  buildParams(agentLattice, options) {
+  async buildParams(agentLattice, options) {
     const skills = isDeepAgentConfig2(agentLattice.config) ? agentLattice.config.skillCategories : void 0;
     const toolKeys = options?.overrideTools || getToolsFromConfig2(agentLattice.config);
     const tools = toolKeys.map((toolKey) => {
@@ -13968,8 +13985,8 @@ var AgentParamsBuilder = class {
       throw new Error(`Model "${modelKey}" does not exist`);
     }
     const subAgentKeys = getSubAgentsFromConfig2(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`);
       }
@@ -13978,7 +13995,7 @@ var AgentParamsBuilder = class {
         config: subAgentLattice.config,
         client: subAgentLattice.client
       };
-    });
+    }));
     let internalSubAgents = [];
     if (isDeepAgentConfig2(agentLattice.config)) {
       internalSubAgents = agentLattice.config.internalSubAgents?.map((i) => ({
@@ -14056,7 +14073,7 @@ var AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager
       }
       const config = assistantToConfig(assistant);
       const agentLattice = {
-        config,
+        config: { ...config, tenantId },
         client: void 0
       };
       return agentLattice;
@@ -14363,13 +14380,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
@@ -14390,7 +14407,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);
   }
   /**
@@ -16818,7 +16835,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;
@@ -16938,27 +16955,30 @@ var Agent = class {
           break;
         }
         const firstMessage = pendings[0];
-        const hasCommand = firstMessage.content?.command;
+        const hasCommand = firstMessage.command;
         if (hasCommand) {
           for (const p of pendings) {
             if (signal?.aborted) break;
-            if (!p.content?.command) break;
+            if (!p.command) break;
             await this.queueStore?.markProcessing(p.id);
             const startTime = Date.now();
             this.publish("message:started", {
               type: "message:started",
-              messageId: p.content.id,
-              messageContent: p.content.message,
+              messageId: this.getHumanPendingContent(p).id,
+              messageContent: this.getHumanPendingContent(p).message,
               timestamp: /* @__PURE__ */ new Date(),
               queueMode: this.queueMode.mode
             });
+            const humanContent = p.content;
             const input = {
-              messages: [new HumanMessage2({ id: p.content.id, content: p.content.message })]
+              messages: [new HumanMessage2({ id: humanContent.id, content: humanContent.message })]
             };
+            const queueMessageData = humanContent.queueMessage;
             try {
               await this.agentStreamExecutor({
                 input,
-                command: p.content.command
+                command: p.command,
+                custom_run_config: queueMessageData.custom_run_config
               }, signal);
               await this.queueStore?.markCompleted(p.id);
               const runStatus = await this.getRunStatus();
@@ -16966,7 +16986,7 @@ var Agent = class {
               if (runStatus === "interrupted" /* INTERRUPTED */) {
                 this.publish("message:interrupted", {
                   type: "message:interrupted",
-                  messageId: p.content.id,
+                  messageId: humanContent.id,
                   timestamp: /* @__PURE__ */ new Date(),
                   duration: Date.now() - startTime,
                   state
@@ -16975,13 +16995,13 @@ var Agent = class {
                 this.addChunk({
                   type: "message_completed",
                   data: {
-                    id: p.content.id,
+                    id: humanContent.id,
                     content: ""
                   }
                 });
                 this.publish("message:completed", {
                   type: "message:completed",
-                  messageId: p.content.id,
+                  messageId: humanContent.id,
                   timestamp: /* @__PURE__ */ new Date(),
                   duration: Date.now() - startTime,
                   state
@@ -16992,13 +17012,13 @@ var Agent = class {
               this.addChunk({
                 type: "message_failed",
                 data: {
-                  id: p.content.id,
+                  id: humanContent.id,
                   content: error instanceof Error ? error.message : String(error)
                 }
               });
               this.publish("message:failed", {
                 type: "message:failed",
-                messageId: p.content.id,
+                messageId: humanContent.id,
                 error: error instanceof Error ? error.message : String(error),
                 timestamp: /* @__PURE__ */ new Date()
               });
@@ -17013,17 +17033,22 @@ var Agent = class {
             const startTime = Date.now();
             remainingPendings.forEach((p) => {
               this.queueStore?.markProcessing(p.id);
-              userMessages.push(new HumanMessage2({ id: p.content.id, content: p.content.message }));
+              const humanContent = p.content;
+              userMessages.push(new HumanMessage2({ id: humanContent.id, content: humanContent.message }));
               this.publish("message:started", {
                 type: "message:started",
-                messageId: p.content.id,
-                messageContent: p.content.message,
+                messageId: humanContent.id,
+                messageContent: humanContent.message,
                 timestamp: /* @__PURE__ */ new Date(),
                 queueMode: "collect" /* COLLECT */
               });
             });
+            const firstQueueMessage = remainingPendings[0] ? this.getHumanPendingContent(remainingPendings[0]).queueMessage : void 0;
             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) {
@@ -17076,24 +17101,29 @@ var Agent = class {
             for (const p of remainingPendings) {
               if (signal?.aborted) break;
               await this.queueStore?.markProcessing(p.id);
-              const message = new HumanMessage2({ id: p.id, content: p.content.message });
+              const humanContent = p.content;
+              const message = new HumanMessage2({ id: humanContent.id, content: humanContent.message });
               const startTime = Date.now();
               this.publish("message:started", {
                 type: "message:started",
-                messageId: p.content.id,
-                messageContent: p.content.message,
+                messageId: humanContent.id,
+                messageContent: humanContent.message,
                 timestamp: /* @__PURE__ */ new Date(),
                 queueMode: "followup" /* FOLLOWUP */
               });
+              const queueMessageData = humanContent.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();
                 if (runStatus === "interrupted" /* INTERRUPTED */) {
                   this.publish("message:interrupted", {
                     type: "message:interrupted",
-                    messageId: p.content.id,
+                    messageId: humanContent.id,
                     timestamp: /* @__PURE__ */ new Date(),
                     duration: Date.now() - startTime,
                     state
@@ -17102,13 +17132,13 @@ var Agent = class {
                   this.addChunk({
                     type: "message_completed",
                     data: {
-                      id: p.content.id,
+                      id: humanContent.id,
                       content: ""
                     }
                   });
                   this.publish("message:completed", {
                     type: "message:completed",
-                    messageId: p.content.id,
+                    messageId: humanContent.id,
                     timestamp: /* @__PURE__ */ new Date(),
                     duration: Date.now() - startTime,
                     state
@@ -17119,13 +17149,13 @@ var Agent = class {
                 this.addChunk({
                   type: "message_failed",
                   data: {
-                    id: p.content.id,
+                    id: humanContent.id,
                     content: error instanceof Error ? error.message : String(error)
                   }
                 });
                 this.publish("message:failed", {
                   type: "message:failed",
-                  messageId: p.content.id,
+                  messageId: humanContent.id,
                   error: error instanceof Error ? error.message : String(error),
                   timestamp: /* @__PURE__ */ new Date()
                 });
@@ -17143,6 +17173,12 @@ var Agent = class {
     this.project_id = project_id;
     this.custom_run_config = custom_run_config;
   }
+  getHumanPendingContent(message) {
+    if (typeof message.content === "string" || !message.content || !("id" in message.content) || !("message" in message.content)) {
+      throw new Error(`Expected human pending message content for message ${message.id}`);
+    }
+    return message.content;
+  }
   /**
    * Initialize with message queue store
    */
@@ -17257,7 +17293,7 @@ var Agent = class {
    */
   async addMessage(queueMessage, mode) {
     const useMode = mode ?? this.queueMode.mode;
-    const messageId = v4();
+    const messageId = queueMessage.input.id || v4();
     const isHighPriority = useMode === "steer" /* STEER */ || !!queueMessage.command;
     const store = this.getQueueStore();
     const currentSize = await store.getQueueSize(this.thread_id);
@@ -17267,20 +17303,30 @@ 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");
+      await store.addMessageAtHead(this.thread_id, content, "human", messageId, queueMessage.command);
+      if (useMode === "steer" /* STEER */) {
+        this.stopQueueProcessor();
+        await store.resetProcessingToPending(this.thread_id);
+        console.log(`[Agent] STEER mode: stopped current processing, reset queue, message ${messageId} will execute next`);
+      }
     } else {
       await store.addMessage({
         threadId: this.thread_id,
         tenantId: this.tenant_id,
         assistantId: this.assistant_id,
         content,
-        type: "human"
+        type: "human",
+        command: queueMessage.command,
+        id: messageId
       });
     }
     this.startQueueProcessorIfNeeded().catch((err) => {
@@ -17299,7 +17345,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();
@@ -17313,7 +17359,7 @@ var Agent = class {
     this.publish("thread:busy", {
       type: "thread:busy",
       timestamp: /* @__PURE__ */ new Date(),
-      messageId: firstMessage?.content?.id
+      messageId: firstMessage ? this.getHumanPendingContent(firstMessage).id : void 0
     });
     this.waitingForQueueEnd(this.abortController.signal).catch((error) => {
       console.error(`Queue processing error for thread ${this.thread_id}:`, error);
@@ -17387,6 +17433,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
@@ -17496,6 +17566,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();