@axiom-lattice/core 2.1.40 → 2.1.42

package/dist/index.mjs

@@ -10788,13 +10788,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
       });
@@ -12103,17 +12103,11 @@ ${BASE_PROMPT}` : BASE_PROMPT;
     todoListMiddleware(),
     // Enables filesystem operations and optional long-term memory storage
     createFilesystemMiddleware({ backend: filesystemBackend }),
-    createClawMiddleware({
-      backend: filesystemBackend
-    }),
     // Enables delegation to specialized subagents for complex tasks
     createSubAgentMiddleware({
       defaultModel: model,
       defaultTools: tools,
       defaultMiddleware: [
-        createClawMiddleware({
-          backend: filesystemBackend
-        }),
         // Subagent middleware: Todo list management
         todoListMiddleware(),
         // Subagent middleware: Filesystem operations
@@ -14474,11 +14468,14 @@ var ChunkBuffer = class {
 };
 
 // src/chunk_buffer_lattice/InMemoryChunkBuffer.ts
+import { MessageChunkTypes } from "@axiom-lattice/protocols";
 import {
   ReplaySubject,
   observeOn,
   asyncScheduler
 } from "rxjs";
+import { eachValueFrom } from "rxjs-for-await";
+import { filter, takeWhile } from "rxjs/operators";
 var InMemoryChunkBuffer = class extends ChunkBuffer {
   constructor(config) {
     super();
@@ -14563,7 +14560,7 @@ var InMemoryChunkBuffer = class extends ChunkBuffer {
     let chunk;
     if (typeof arg2 === "string" && arg3 !== void 0) {
       chunk = {
-        type: "message_chunk",
+        type: MessageChunkTypes.AI,
         data: {
           id: arg2,
           content: arg3
@@ -14677,76 +14674,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(observeOn(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 = [
+      MessageChunkTypes.MESSAGE_COMPLETED,
+      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;
-            accumulatedContent += chunk.data?.content || "";
-          }
-          if (startYieldChunk) {
-            yield chunk;
-          }
-        }
-      }
-    } finally {
-      subscription.unsubscribe();
-    }
+    console.log("start from messageId", messageId);
+    const filtered$ = buffer2.chunks$.pipe(
+      observeOn(asyncScheduler),
+      // 1. 从指定 messageId 开始
+      filter((chunk) => {
+        if (chunk.data?.id === messageId) startYieldChunk = true;
+        return startYieldChunk;
+      }),
+      // 2. 包含指定的停止类型，但收到后停止
+      takeWhile((chunk) => !typesToStop.includes(chunk.type), true)
+    );
+    yield* eachValueFrom(filtered$);
   }
   getStats() {
     let activeCount = 0;
@@ -16824,6 +16772,7 @@ var Agent = class {
     this.chunkBuffer = getChunkBuffer("default");
     this.abortController = null;
     this.queueMode = this.getDefaultQueueConfig();
+    this.isWaitingForQueueEnd = false;
     this.agentExecutor = async ({ input, command, custom_run_config }, signal) => {
       const { runnable_agent, runConfig } = await this.getLatticeClientAndRuntimeConfig(custom_run_config);
       const { messages, ...rest } = input;
@@ -16951,9 +16900,7 @@ var Agent = class {
               };
             }
             if (data) {
-              if (data.type !== "interrupt") {
-                await lifecycleManager.addChunk(data);
-              }
+              lifecycleManager.addChunk(data);
             }
           }
         } catch (error) {
@@ -16970,8 +16917,8 @@ var Agent = class {
       while (!signal?.aborted) {
         const pendings = await this.getPendingMessages();
         if (pendings.length === 0) {
-          await this.chunkBuffer.completeThread(this.thread_id);
           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",
@@ -16979,6 +16926,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];
@@ -16997,22 +16953,49 @@ var Agent = class {
               queueMode: this.queueMode.mode
             });
             const input = {
-              messages: [new HumanMessage2({ id: p.content.id, content: p.content.message })],
-              command: p.content.command
+              messages: [new HumanMessage2({ id: p.content.id, content: p.content.message })]
             };
             try {
-              await this.agentStreamExecutor({ input }, signal);
+              await this.agentStreamExecutor({
+                input,
+                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,
@@ -17041,20 +17024,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,
@@ -17080,16 +17088,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,
@@ -17119,11 +17152,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* () {
@@ -17396,6 +17430,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);
   }
 };