@copilotkit/channels-core 0.9.0 → 0.9.1

package/dist/thread.js

@@ -2,7 +2,17 @@ import { runAgentLoop } from "./run-loop.js";
 import { errorClass, normalizePlatform } from "./telemetry/sanitize-error.js";
 import { toAgentToolDescriptors } from "./tools.js";
 import { validateSchema } from "./standard-schema.js";
+import { channelActorIdentity } from "./identity.js";
 import { hasMemoryAccess, resolveMemoryGrant } from "./memory.js";
+/**
+ * Default retention for a captured interrupt value (7 days) — deliberately the
+ * same default the action store uses, so the retained value and the button that
+ * consumes it expire together. If a channel configures a LONGER
+ * `actionRetentionMs`, the value can lapse before the button does; a resume then
+ * simply omits `command.interruptEvent`, which is exactly the pre-existing
+ * behaviour rather than a new failure.
+ */
+const DEFAULT_INTERRUPT_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
 /** A Channel run requested Memory without an attached Intelligence backend. */
 export class ChannelMemoryUnavailableError extends Error {
     code = "channel_memory_unavailable";
@@ -254,6 +264,33 @@ export class Thread {
     state() {
         return this.trackOperation(() => this.store.kv.get(`threadstate:${this.deps.conversationKey}`));
     }
+    interruptEventKey() {
+        return `interruptevent:${this.deps.conversationKey}`;
+    }
+    /**
+     * Retain the raw value of a captured interrupt so a later {@link resume} can
+     * echo it back to the agent as `command.interruptEvent`.
+     *
+     * PERSISTED, not in-memory, because the resume arrives in a DIFFERENT run —
+     * possibly in a different process after a restart, which is the whole reason
+     * this HITL path exists. Stored per conversation, matching the fact that a
+     * renderer tracks a single pending interrupt: a second interrupt in the same
+     * conversation legitimately supersedes the first.
+     *
+     * Best-effort: an agent that needs no correlation data (LangGraph) resumes
+     * fine without this, so a store failure must not take the interrupt down.
+     */
+    async rememberInterruptEvent(value) {
+        if (value === undefined)
+            return;
+        try {
+            await this.store.kv.set(this.interruptEventKey(), value, this.deps.interruptRetentionMs ?? DEFAULT_INTERRUPT_RETENTION_MS);
+        }
+        catch (err) {
+            console.warn("[channel] could not retain the interrupt value; a resume will omit " +
+                "command.interruptEvent (fine for LangGraph, breaks Mastra):", err);
+        }
+    }
     /** Read the conversation's messages (returns `[]` when the adapter can't read history). */
     getMessages() {
         return this.trackOperation(async () => (await this.deps.adapter.getMessages?.(this.deps.replyTarget)) ?? []);
@@ -348,8 +385,28 @@ export class Thread {
                 initiator: claimed.initiator,
             };
             this.activeContinuation = continuation;
+            // Echo the originating interrupt back to the agent. Some AG-UI bridges
+            // (e.g. @ag-ui/mastra) key their resume off it — it carries the correlation
+            // ids identifying WHICH suspended call to continue — and silently ignore a
+            // resume without it. LangGraph needs no correlation data and ignores the
+            // extra field, so this is additive for existing agents.
+            //
+            // `consume` is atomic take-and-delete, matching the one-use continuation
+            // claimed just above: a replayed click must not resurrect a spent resume.
+            // Omitted entirely when absent, so the wire shape is byte-identical to
+            // before for any flow that never captured an interrupt value.
+            let interruptEvent;
+            try {
+                interruptEvent = await this.store.kv.consume(this.interruptEventKey());
+            }
+            catch (err) {
+                console.warn("[channel] could not read the retained interrupt value; resuming " +
+                    "without command.interruptEvent:", err);
+            }
             try {
-                return await this.run({ resume: value }, { memory });
+                return await this.run(interruptEvent === undefined
+                    ? { resume: value }
+                    : { resume: value, interruptEvent }, { memory });
             }
             finally {
                 if (this.activeContinuation === continuation) {
@@ -480,6 +537,7 @@ export class Thread {
             // reported as agent_run_failed (with the right stage) instead of being
             // hidden behind an already-sent success event.
             let stage = "agent";
+            const identity = channelActorIdentity(this.deps.actor, this.platform);
             try {
                 const loopArgs = {
                     agent: session.agent,
@@ -487,6 +545,9 @@ export class Thread {
                     tools,
                     toolDescriptors,
                     context,
+                    // The platform's word for who spoke, taken from this Thread's ingress
+                    // rather than from the run's caller. See `channelActorIdentity`.
+                    ...(identity ? { identity } : {}),
                     makeToolCtx: () => ({
                         thread: this,
                         message: this.deps.message,
@@ -496,6 +557,10 @@ export class Thread {
                         platform: this.platform,
                     }),
                     handleInterrupt: async (interrupt) => {
+                        // Retain BEFORE dispatching: the handler posts the picker, and the
+                        // click that resumes it can arrive at any later moment, so the value
+                        // has to already be durable by the time the button exists.
+                        await this.rememberInterruptEvent(interrupt.value);
                         const h = this.deps.interruptHandlers.get(interrupt.eventName);
                         if (h)
                             await h({
@@ -515,6 +580,7 @@ export class Thread {
                         tools: toolDescriptors,
                         context,
                         isResume: initialResume !== undefined,
+                        user: this.deps.user,
                         memory: extra?.memory,
                         execute: (subscriber, canonicalRun) => runAgentLoop({
                             ...loopArgs,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@copilotkit/channels-core",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "Platform-agnostic JSX channel engine for CopilotKit (createChannel, Thread, PlatformAdapter, ActionStore).",
   "license": "MIT",
   "repository": {
@@ -48,12 +48,12 @@
     "dist"
   ],
   "dependencies": {
-    "@ag-ui/client": "0.0.57",
-    "@ag-ui/core": "0.0.57",
+    "@ag-ui/client": "0.0.59",
+    "@ag-ui/core": "0.0.59",
     "zod-to-json-schema": "^3.24.1",
-    "@copilotkit/channels-ui": "~0.9.0",
-    "@copilotkit/shared": "^1.68.0",
-    "@copilotkit/core": "^1.68.0"
+    "@copilotkit/channels-ui": "~0.9.1",
+    "@copilotkit/core": "^1.70.0",
+    "@copilotkit/shared": "^1.70.0"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",