@axiom-lattice/core 6.3.0 → 6.3.1

package/dist/index.mjs

@@ -18552,12 +18552,47 @@ var Agent = class {
           id: interruptData.id,
           data: { content: interruptData.value }
         };
+        await this.awaitDurableInterrupt(interruptData.id, signal);
       }
       if (data) {
         this.addChunk(data);
       }
     }
   }
+  /**
+   * Waits until the thread's durable checkpoint reports the given interrupt id.
+   *
+   * Reads {@link getCurrentState} (the checkpoint, i.e. the single source of
+   * truth), never an in-memory status, so a `true` result guarantees a resume
+   * against this thread will find the interrupt. Bounded so a broken
+   * checkpointer cannot strand the stream; on timeout the interrupt is emitted
+   * anyway and a warning is logged.
+   *
+   * @param interruptId - Interrupt id from the streamed `__interrupt__` update.
+   * @param signal - Run abort signal; polling stops when aborted.
+   * @param timeoutMs - Maximum time to wait for durable confirmation.
+   */
+  async awaitDurableInterrupt(interruptId, signal, timeoutMs = 5e3) {
+    if (!interruptId) return;
+    const deadline = Date.now() + timeoutMs;
+    while (!signal?.aborted) {
+      try {
+        const state = await this.getCurrentState();
+        const durable = (state?.tasks ?? []).some(
+          (task) => (task.interrupts ?? []).some((interrupt5) => interrupt5.id === interruptId)
+        );
+        if (durable) return;
+      } catch {
+      }
+      if (Date.now() >= deadline) {
+        console.warn(
+          `[Agent] interrupt ${interruptId} not durable within ${timeoutMs}ms on thread ${this.thread_id}; emitting without durable confirmation`
+        );
+        return;
+      }
+      await new Promise((resolve4) => setTimeout(resolve4, 20));
+    }
+  }
   /**
    * Resume LangGraph execution from the last checkpoint.
    *