@agent-native/core 0.227.0-nightly-20261110182415 → 0.227.0

package/dist/client/chat/agentkit-protocol.js

@@ -5,7 +5,17 @@ import { isPersistableAttachmentUrl } from "../../shared/attachments.js";
 import { parseBase64DataUrl } from "../../shared/data-url.js";
 import { emitChatFirstOpenApp, emitChatFirstOpenBrowser, } from "../chat-first-state.js";
 import { toolDisplayName } from "../tool-display.js";
-import { decideAfterStreamClosed, runOutcomeForCode, } from "./run-outcome.js";
+import { decideAfterStreamClosed, runOutcomeForCode, transition, } from "./run-outcome.js";
+function isRunTerminal(run) {
+    return run.phase.type === "terminal" || run.phase.type === "disposed";
+}
+function isRunCancelling(run) {
+    return run.phase.type === "cancelling";
+}
+// The phase can change during awaits and event handling, despite local narrowing.
+function isRunPhase(run, phase) {
+    return run.phase.type === phase;
+}
 function isTerminalRunStatus(status) {
     return (status === "completed" || status === "failed" || status === "cancelled");
 }
@@ -1087,7 +1097,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
     }
     function findRunByTurnId(threadId, turnId) {
         const owners = [...runs.values()].filter((run) => run.threadId === threadId && run.turn.id === turnId);
-        const activeOwners = owners.filter((run) => !run.terminal);
+        const activeOwners = owners.filter((run) => !isRunTerminal(run));
         if (activeOwners.length > 1) {
             throw new Error(`Turn ${turnId} is owned by multiple active AgentKit runs in thread ${threadId}.`);
         }
@@ -1114,7 +1124,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
             if (previousRun &&
                 previousRun !== run &&
                 runs.get(previousRun.runId) === previousRun &&
-                !previousRun.terminal) {
+                !isRunTerminal(previousRun)) {
                 throw new Error(`Runtime run id ${runtimeRunId} is already owned by active AgentKit run ${previousRun.runId}.`);
             }
             runtimeRunAliases.set(aliasKey, run);
@@ -1125,7 +1135,9 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
     async function resolveRuntimeRunOwner(threadId, runtimeRunId, sessionId, authorityRead) {
         if (!runAuthority)
             return {};
-        const candidates = [...runs.values()].filter((run) => run.threadId === threadId && !run.terminal && Boolean(run.turn.id));
+        const candidates = [...runs.values()].filter((run) => run.threadId === threadId &&
+            !isRunTerminal(run) &&
+            Boolean(run.turn.id));
         const candidate = candidates[0];
         const resolvedSessionId = sessionId ?? candidate?.session.id;
         if (!resolvedSessionId)
@@ -1163,7 +1175,9 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                 // coercion-ok: startRun surfaces this rejection; restore from the separate authoritative read.
             }
         }
-        const currentCandidates = [...runs.values()].filter((run) => run.threadId === threadId && !run.terminal && Boolean(run.turn.id));
+        const currentCandidates = [...runs.values()].filter((run) => run.threadId === threadId &&
+            !isRunTerminal(run) &&
+            Boolean(run.turn.id));
         const owners = currentCandidates.filter((run) => run.turn.id === state.turnId);
         if (owners.length !== 1)
             return { read };
@@ -1196,7 +1210,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
         if (disposed)
             return;
         const nextExpiry = [...runs.values()]
-            .filter((run) => run.terminal &&
+            .filter((run) => isRunTerminal(run) &&
             run.activeReaders === 0 &&
             run.terminalAtMs !== undefined)
             .reduce((earliest, run) => {
@@ -1213,7 +1227,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
         timer.unref?.();
     }
     function pruneRetainedRuns(referenceTimeMs = timeMs()) {
-        const evictable = [...runs.values()].filter((run) => run.terminal && run.activeReaders === 0);
+        const evictable = [...runs.values()].filter((run) => isRunTerminal(run) && run.activeReaders === 0);
         for (const run of evictable) {
             if (run.terminalAtMs !== undefined &&
                 referenceTimeMs - run.terminalAtMs >= retainedRunTtlMs) {
@@ -1221,9 +1235,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
             }
         }
         const retainedCompleted = [...runs.values()]
-            .filter((run) => run.terminal &&
-            !run.waitingForContinuation &&
-            run.activeReaders === 0)
+            .filter((run) => isRunTerminal(run) && run.activeReaders === 0)
             .sort((left, right) => left.lastAccessedAtMs - right.lastAccessedAtMs);
         while (retainedCompleted.length > maxRetainedRuns) {
             const run = retainedCompleted.shift();
@@ -1485,10 +1497,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
             terminalAppendDepth: 0,
             pumpPromise: null,
             continuationPromise: null,
-            streamClosed: false,
-            terminal: false,
-            waitingForContinuation: false,
-            ...(runAuthority ? { restoredWithoutStream: true } : {}),
+            phase: { type: runAuthority ? "followingSuccessor" : "streaming" },
             ...(restoreOptions.includePendingConnectionRequest
                 ? { requiresRestoredConnectionRequestReplay: true }
                 : {}),
@@ -1559,9 +1568,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
             terminalAppendDepth: 0,
             pumpPromise: null,
             continuationPromise: null,
-            streamClosed: false,
-            terminal: false,
-            waitingForContinuation: false,
+            phase: { type: "streaming" },
             listeners: new Set(),
         };
         if (disposed) {
@@ -1579,7 +1586,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
             }
             const isRuntimeAlias = existingRun.runId !== runId;
             const isSameRuntimeTurn = existingRun.turn.id !== undefined && existingRun.turn.id === turn.id;
-            if (isRuntimeAlias && !isSameRuntimeTurn && !existingRun.terminal) {
+            if (isRuntimeAlias && !isSameRuntimeTurn && !isRunTerminal(existingRun)) {
                 await closeDiscardedTurnEvents(turn);
                 throw new Error(`Duplicate AgentKit run id: ${runId}`);
             }
@@ -1672,7 +1679,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                     (event.type === "run.status" && event.status === "cancelled")
                     ? "cancelled"
                     : undefined;
-        const terminalFollowup = run.terminal &&
+        const terminalFollowup = isRunTerminal(run) &&
             lastType === "run.status" &&
             ((run.status === "completed" && event.type === "run.completed") ||
                 (run.status === "failed" && event.type === "run.failed") ||
@@ -1682,7 +1689,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
             lastType === "run.cancelled") {
             return;
         }
-        if (run.terminal &&
+        if (isRunTerminal(run) &&
             run.terminalAppendDepth === 0 &&
             !terminalFollowup &&
             !(terminalStatus && !isTerminalRunStatus(run.status))) {
@@ -1750,7 +1757,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                 run.completedAt = protocolEvent.occurredAt;
                 run.terminalAtMs = timeMs(protocolEvent.occurredAt);
                 run.actions.clear();
-                run.terminal = true;
+                run.phase = transition(run.phase, { type: "terminal" });
                 becameTerminal = true;
             }
         }
@@ -1765,7 +1772,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                 run.usage = protocolEvent.usage;
             }
             run.actions.clear();
-            run.terminal = true;
+            run.phase = transition(run.phase, { type: "terminal" });
             becameTerminal = true;
         }
         else if (protocolEvent.type === "run.cancelled") {
@@ -1773,7 +1780,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
             run.completedAt = protocolEvent.occurredAt;
             run.terminalAtMs = timeMs(protocolEvent.occurredAt);
             run.actions.clear();
-            run.terminal = true;
+            run.phase = transition(run.phase, { type: "terminal" });
             becameTerminal = true;
         }
         else if (protocolEvent.type === "run.failed") {
@@ -1782,7 +1789,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
             run.terminalAtMs = timeMs(protocolEvent.occurredAt);
             run.error = protocolEvent.error;
             run.actions.clear();
-            run.terminal = true;
+            run.phase = transition(run.phase, { type: "terminal" });
             becameTerminal = true;
         }
         if (protocolEvent.type === "run.completed" ||
@@ -2219,12 +2226,14 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                     run.pendingApprovalId !== event.approvalId) {
                     throw new Error(`AgentKit run ${run.runId} received approval ${event.approvalId} while approval ${run.pendingApprovalId} is still pending.`);
                 }
-                run.waitingForContinuation = true;
+                run.phase = transition(run.phase, {
+                    type: "awaitContinuation",
+                    streamClosed: true,
+                });
                 run.pendingApprovalId = event.approvalId;
                 // AG-UI models an approval interrupt as RUN_FINISHED. Close the wire
                 // stream while retaining ownership of the paused Core turn so it can
                 // still be resumed, cancelled, or disposed.
-                run.streamClosed = true;
                 return [
                     {
                         type: "run.status",
@@ -2272,9 +2281,11 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                     run.pendingConnectionRequestId !== event.requestId) {
                     throw new Error(`AgentKit run ${run.runId} received connection request ${event.requestId} while ${run.pendingConnectionRequestId} is still pending.`);
                 }
-                run.waitingForContinuation = true;
+                run.phase = transition(run.phase, {
+                    type: "awaitContinuation",
+                    streamClosed: true,
+                });
                 run.pendingConnectionRequestId = event.requestId;
-                run.streamClosed = true;
                 return [
                     { type: "run.status", ...base, status: "awaiting_input" },
                     {
@@ -2609,10 +2620,10 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                 if (runAuthority &&
                     capabilities.resumableRuns === true &&
                     runOutcomeForCode(error.code) === "interrupted") {
-                    run.heldInterruption = error;
+                    run.phase = transition(run.phase, { type: "interrupted", error });
                     return [];
                 }
-                run.terminal = true;
+                run.phase = transition(run.phase, { type: "terminal" });
                 return [
                     { type: "run.status", ...base, status: "failed" },
                     { type: "run.failed", ...base, error },
@@ -2620,7 +2631,10 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
             }
             case "done":
                 if (!isTerminalReason(event.reason)) {
-                    run.waitingForContinuation = true;
+                    run.phase = transition(run.phase, {
+                        type: "awaitContinuation",
+                        streamClosed: false,
+                    });
                     return [
                         {
                             type: "run.status",
@@ -2631,7 +2645,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                         },
                     ];
                 }
-                run.terminal = true;
+                run.phase = transition(run.phase, { type: "terminal" });
                 if (event.reason === "cancelled" || event.reason === "interrupted") {
                     return [
                         { type: "run.status", ...base, status: "cancelled" },
@@ -2728,13 +2742,13 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
             run.events.some((event) => event.type === "connection.requested" &&
                 event.request.id === requestId);
         const deadline = Date.now() + RESTORED_CONNECTION_REQUEST_REPLAY_TIMEOUT_MS;
-        while (!isPending() && !run.terminal && !readers.signal.aborted) {
+        while (!isPending() && !isRunTerminal(run) && !readers.signal.aborted) {
             const remaining = deadline - Date.now();
             if (remaining <= 0)
                 break;
             await notifyWhenChanged(run, readers.signal, remaining);
         }
-        if (!isPending() && !run.terminal) {
+        if (!isPending() && !isRunTerminal(run)) {
             throw restoredConnectionRequestUnverifiedError();
         }
     }
@@ -2756,7 +2770,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
         };
         let lastError;
         while ((run.resumeAttempts ?? 0) < MAX_DURABLE_RESUME_ATTEMPTS) {
-            if (run.terminal || run.streamClosed)
+            if (run.phase.type !== "followingSuccessor")
                 return null;
             run.resumeAttempts = (run.resumeAttempts ?? 0) + 1;
             try {
@@ -2793,18 +2807,15 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
         let failure = stream;
         try {
             const resumed = await resumeRuntimeTurn(run, stream.failed ? stream.error : undefined);
-            if (resumed || run.terminal || run.streamClosed)
+            if (resumed || run.phase.type !== "followingSuccessor")
                 return resumed;
-            if (run.waitingForContinuation)
-                return null;
         }
         catch (resumeError) {
             failure = { failed: true, error: resumeError };
         }
-        if (run.terminal || run.streamClosed)
+        if (run.phase.type !== "followingSuccessor")
             return null;
-        run.streamClosed = true;
-        run.terminal = true;
+        run.phase = transition(run.phase, { type: "terminal" });
         run.terminalSource = "pipe";
         append(run, {
             type: "run.failed",
@@ -2825,7 +2836,9 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
      * next, or null once the run is terminal or this adapter stopped reading.
      */
     async function followRunAuthority(run, authority, stream) {
-        const stopped = () => run.terminal || run.streamClosed || readers.signal.aborted;
+        const stopped = () => (run.phase.type !== "followingSuccessor" &&
+            run.phase.type !== "holdingInterruption") ||
+            readers.signal.aborted;
         if (run.readingTerminalDrain && run.terminalDrain) {
             run.readingTerminalDrain = false;
             if (!stream.failed) {
@@ -2845,7 +2858,8 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                 return null;
             // An unreachable server says nothing about a successor; keep holding
             // through the usual backoff until it answers.
-            if (run.heldInterruption && read.kind !== "unreachable") {
+            if (run.phase.type === "holdingInterruption" &&
+                read.kind !== "unreachable") {
                 const successor = read.kind === "read" &&
                     read.state.status !== "missing" &&
                     read.state.runId !== runtimeRunId;
@@ -2853,7 +2867,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                     appendHeldInterruption(run);
                     return null;
                 }
-                run.heldInterruption = undefined;
+                run.phase = transition(run.phase, { type: "followSuccessor" });
             }
             const decision = decideAfterStreamClosed(read, {
                 runId: runtimeRunId,
@@ -2974,7 +2988,9 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
             if (refusal)
                 asked.set(decision.runId, refusal);
         }
-        if (activity && !run.terminal) {
+        while (isRunCancelling(run))
+            await notifyWhenChanged(run, readers.signal);
+        if (activity && !isRunTerminal(run)) {
             append(run, {
                 type: "activity.completed",
                 activity: {
@@ -2986,11 +3002,15 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
         }
         // A Stop that landed while the request was in flight stopped the whole
         // turn server-side, including the run this request started.
-        return run.terminal || run.streamClosed ? null : next;
+        if (isRunTerminal(run)) {
+            if (next)
+                await closeDiscardedTurnEvents(next);
+            return null;
+        }
+        return next;
     }
     function appendAuthorityTerminal(run, decision) {
-        run.streamClosed = true;
-        run.terminal = true;
+        run.phase = transition(run.phase, { type: "terminal" });
         run.terminalSource = "authority";
         if ("error" in decision) {
             append(run, { type: "run.status", status: "failed" });
@@ -3007,9 +3027,10 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
     }
     /** The runtime run's own interruption, once no newer run carries the turn. */
     function appendHeldInterruption(run) {
-        const error = run.heldInterruption;
-        run.heldInterruption = undefined;
-        run.terminal = true;
+        if (run.phase.type !== "holdingInterruption")
+            return;
+        const error = run.phase.error;
+        run.phase = transition(run.phase, { type: "terminal" });
         append(run, { type: "run.status", status: "failed" });
         append(run, { type: "run.failed", error });
     }
@@ -3031,63 +3052,77 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
     }
     function ensurePump(run) {
         if (run.pumpPromise ||
-            run.streamClosed ||
-            run.terminal ||
-            !run.turn ||
+            (run.phase.type !== "streaming" &&
+                run.phase.type !== "followingSuccessor") ||
             readers.signal.aborted)
             return;
         run.pumpPromise = (async () => {
             try {
-                while (!run.terminal && !run.waitingForContinuation) {
-                    const stream = {
-                        failed: false,
-                    };
-                    try {
-                        for await (const event of run.turn.events) {
-                            const sequence = event.metadata?.seq;
-                            if (typeof sequence === "number" &&
-                                (run.runtimeSequence === undefined ||
-                                    sequence > run.runtimeSequence)) {
-                                run.runtimeSequence = sequence;
-                                run.resumeAttempts = 0;
-                                run.quietAuthorityReads = 0;
-                            }
-                            for (const protocolEvent of runtimeEventToProtocolEvents(run, event)) {
-                                append(run, protocolEvent);
-                            }
-                            if (run.waitingForContinuation ||
-                                run.terminal ||
-                                run.heldInterruption) {
-                                break;
+                let stream = { failed: false };
+                for (;;) {
+                    while (isRunCancelling(run))
+                        await notifyWhenChanged(run, readers.signal);
+                    if (run.phase.type === "streaming") {
+                        stream = { failed: false };
+                        try {
+                            for await (const event of run.turn.events) {
+                                while (isRunCancelling(run))
+                                    await notifyWhenChanged(run, readers.signal);
+                                if (!isRunPhase(run, "streaming"))
+                                    break;
+                                const sequence = event.metadata?.seq;
+                                if (typeof sequence === "number" &&
+                                    (run.runtimeSequence === undefined ||
+                                        sequence > run.runtimeSequence)) {
+                                    run.runtimeSequence = sequence;
+                                    run.resumeAttempts = 0;
+                                    run.quietAuthorityReads = 0;
+                                }
+                                for (const protocolEvent of runtimeEventToProtocolEvents(run, event)) {
+                                    append(run, protocolEvent);
+                                }
+                                if (!isRunPhase(run, "streaming"))
+                                    break;
                             }
                         }
+                        catch (error) {
+                            stream = { failed: true, error };
+                        }
+                        while (isRunCancelling(run))
+                            await notifyWhenChanged(run, readers.signal);
+                        if (isRunPhase(run, "streaming")) {
+                            run.pipeClosedBeforeTerminal = true;
+                            run.phase = transition(run.phase, {
+                                type: stream.failed ? "streamFailed" : "streamEnded",
+                            });
+                        }
                     }
-                    catch (error) {
-                        stream.failed = true;
-                        stream.error = error;
-                    }
-                    if (run.terminal || run.streamClosed || run.waitingForContinuation) {
+                    if (run.phase.type !== "followingSuccessor" &&
+                        run.phase.type !== "holdingInterruption")
                         break;
-                    }
-                    if (run.restoredWithoutStream)
-                        run.restoredWithoutStream = false;
-                    else if (!run.heldInterruption)
-                        run.pipeClosedBeforeTerminal = true;
                     const resumed = runAuthority && capabilities.resumableRuns === true
                         ? await followRunAuthority(run, runAuthority, stream)
                         : await resumeWithoutAuthority(run, stream);
-                    if (!resumed || run.terminal || run.waitingForContinuation)
+                    while (isRunCancelling(run))
+                        await notifyWhenChanged(run, readers.signal);
+                    if (!resumed) {
+                        if (isRunPhase(run, "followingSuccessor") ||
+                            isRunPhase(run, "holdingInterruption"))
+                            continue;
+                        break;
+                    }
+                    if (run.phase.type !== "followingSuccessor") {
+                        await closeDiscardedTurnEvents(resumed);
                         break;
+                    }
                     setResumedRuntimeTurn(run, resumed);
+                    run.phase = transition(run.phase, { type: "streamOpened" });
                 }
             }
             finally {
                 run.pumpPromise = null;
                 for (const listener of run.listeners)
                     listener();
-                if (!run.streamClosed && !run.terminal && !run.waitingForContinuation) {
-                    ensurePump(run);
-                }
             }
         })();
     }
@@ -3108,7 +3143,11 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                     }
                     yield event;
                 }
-                if ((run.streamClosed || run.terminal) && !run.cancelling)
+                if (run.phase.type === "disposed" ||
+                    run.phase.type === "terminal" ||
+                    (run.phase.type === "awaitingContinuation" &&
+                        run.phase.streamClosed &&
+                        !run.pendingConnectionResponses))
                     return;
                 await notifyWhenChanged(run, signal);
             }
@@ -3303,44 +3342,35 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                 run = await restoreRunFromRuntime(input);
             }
             touchRun(run);
-            if (run.terminal)
+            if (isRunTerminal(run) || run.phase.type === "cancelling")
                 return;
-            const streamWasClosed = run.streamClosed;
             // "user" is the server's turn-wide stop: it also stops any successor
             // run the turn would otherwise hand off to.
             const cancellation = cancelCoreTurn(run, "user");
-            run.streamClosed = true;
-            run.terminal = true;
-            // Stopping the turn can end its event stream before the cancel settles,
-            // and the pump wakes readers when it does. Without this hold they would
-            // see a closed run and leave before the cancelled events below exist.
-            run.cancelling = true;
+            // Keep readers attached until the cancellation has produced its events.
+            run.phase = transition(run.phase, { type: "cancelStarted" });
             try {
                 let result;
                 try {
                     result = await cancellation;
                 }
                 catch (error) {
-                    run.streamClosed = streamWasClosed;
-                    run.terminal = false;
-                    ensurePump(run);
+                    run.phase = transition(run.phase, { type: "cancelFailed" });
                     throw error;
                 }
                 if (result.status === "unsupported") {
-                    run.streamClosed = streamWasClosed;
-                    run.terminal = false;
-                    ensurePump(run);
+                    run.phase = transition(run.phase, { type: "cancelFailed" });
                     throw new Error("The Core runtime does not support run cancellation.");
                 }
-                run.waitingForContinuation = false;
+                if (run.phase.type === "disposed")
+                    return;
                 delete run.pendingApprovalId;
                 run.terminalSource = "local";
-                run.cancelling = false;
+                run.phase = transition(run.phase, { type: "cancelSucceeded" });
                 append(run, { type: "run.status", status: "cancelled" });
                 append(run, { type: "run.cancelled" });
             }
             finally {
-                run.cancelling = false;
                 for (const listener of run.listeners)
                     listener();
             }
@@ -3354,10 +3384,7 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
             // Readers end without a terminal event: this adapter stopped watching,
             // and the server still owns how each run ends.
             for (const run of runs.values()) {
-                run.streamClosed = true;
-                run.terminal = true;
-                run.cancelling = false;
-                run.waitingForContinuation = false;
+                run.phase = transition(run.phase, { type: "dispose" });
                 run.pendingApprovalId = undefined;
                 for (const listener of run.listeners)
                     listener();
@@ -3501,10 +3528,12 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                 const activePump = run.pumpPromise;
                 if (activePump)
                     await activePump;
-                if (run.terminal && !run.waitingForContinuation) {
+                while (isRunCancelling(run))
+                    await notifyWhenChanged(run, readers.signal);
+                if (isRunTerminal(run)) {
                     throw new Error("The AgentKit run is already terminal.");
                 }
-                if (!run.waitingForContinuation) {
+                if (run.phase.type !== "awaitingContinuation") {
                     throw new Error("The AgentKit run is not awaiting approval.");
                 }
                 if (run.pendingApprovalId !== entry.interruptId) {
@@ -3527,6 +3556,12 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                     },
                     abortSignal: readers.signal,
                 });
+                while (isRunCancelling(run))
+                    await notifyWhenChanged(run, readers.signal);
+                if (!isRunPhase(run, "awaitingContinuation")) {
+                    await closeDiscardedTurnEvents(nextTurn);
+                    throw new Error("The AgentKit run is already terminal.");
+                }
                 const replacementMetadata = mergeTrustedProtocolMetadata(run.metadata, nextTurn.metadata, {
                     [AGENT_NATIVE_PROTOCOL_METADATA_KEY]: {
                         observability: {
@@ -3579,14 +3614,11 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                     terminalAppendDepth: 0,
                     pumpPromise: null,
                     continuationPromise: null,
-                    streamClosed: false,
-                    terminal: false,
-                    waitingForContinuation: false,
+                    phase: { type: "streaming" },
                     listeners: new Set(),
                 };
-                run.waitingForContinuation = false;
                 run.pendingApprovalId = undefined;
-                run.terminal = true;
+                run.phase = transition(run.phase, { type: "terminal" });
                 run.terminalAtMs = timeMs();
                 indexRun(replacementRun, nextTurn.runId);
                 append(replacementRun, {
@@ -3703,94 +3735,121 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
                 await run.pumpPromise;
             }
             touchRun(run);
-            if (input.response.status === "declined" && run.terminal)
-                return;
-            if (run.pendingConnectionRequestId !== input.requestId) {
-                const staleDecline = input.response.status === "declined" &&
-                    run.initialAuthorityRead?.kind === "read" &&
-                    run.initialAuthorityRead.state.status !== "running";
-                if (staleDecline)
-                    return;
-                throw new Error(`Connection response ${input.requestId} does not match pending request ${run.pendingConnectionRequestId ?? "<none>"}.`);
-            }
-            const pendingEvent = [...run.events]
-                .reverse()
-                .find((event) => event.type === "connection.requested" &&
-                event.request.id === input.requestId);
-            if (!pendingEvent || pendingEvent.type !== "connection.requested") {
-                throw new Error(`Unknown connection request: ${input.requestId}`);
-            }
-            const update = (status) => append(run, {
-                type: "connection.updated",
-                request: {
-                    ...pendingEvent.request,
-                    status,
-                    updatedAt: now(),
-                },
-            });
-            if (input.response.status === "failed") {
-                update("failed");
-                run.waitingForContinuation = false;
-                run.pendingConnectionRequestId = undefined;
-                run.streamClosed = true;
-                run.terminalSource = "local";
-                append(run, { type: "run.status", status: "failed" });
-                append(run, {
-                    type: "run.failed",
-                    error: {
-                        code: "connection_failed",
-                        message: input.response.message?.trim() ||
-                            `Failed to connect ${pendingEvent.request.provider}.`,
-                    },
-                });
-                pruneRetainedRuns(run.terminalAtMs);
-                return;
-            }
-            if (!run.session.continueTurn) {
-                throw new Error("The Core runtime does not support connection continuation.");
-            }
-            if (run.continuationPromise) {
-                throw new Error("A connection continuation is already in progress.");
-            }
-            update("connecting");
-            const continuation = (async () => {
-                const activePump = run.pumpPromise;
-                if (activePump)
-                    await activePump;
-                if (run.terminal) {
+            run.pendingConnectionResponses =
+                (run.pendingConnectionResponses ?? 0) + 1;
+            try {
+                while (isRunCancelling(run))
+                    await notifyWhenChanged(run, readers.signal);
+                if (isRunTerminal(run)) {
+                    if (input.response.status === "declined")
+                        return;
                     throw new Error("The AgentKit run is already terminal.");
                 }
-                const nextTurn = await run.session.continueTurn({
-                    turnId: run.turn.id,
-                    connection: {
-                        id: pendingEvent.request.provider,
-                        status: input.response.status === "connected" ? "connected" : "declined",
-                        connectionId: input.response.connectionId,
-                        message: input.response.message,
+                if (run.pendingConnectionRequestId !== input.requestId) {
+                    const staleDecline = input.response.status === "declined" &&
+                        run.initialAuthorityRead?.kind === "read" &&
+                        run.initialAuthorityRead.state.status !== "running";
+                    if (staleDecline)
+                        return;
+                    throw new Error(`Connection response ${input.requestId} does not match pending request ${run.pendingConnectionRequestId ?? "<none>"}.`);
+                }
+                const pendingEvent = [...run.events]
+                    .reverse()
+                    .find((event) => event.type === "connection.requested" &&
+                    event.request.id === input.requestId);
+                if (!pendingEvent || pendingEvent.type !== "connection.requested") {
+                    throw new Error(`Unknown connection request: ${input.requestId}`);
+                }
+                const update = (status) => append(run, {
+                    type: "connection.updated",
+                    request: {
+                        ...pendingEvent.request,
+                        status,
+                        updatedAt: now(),
                     },
-                    abortSignal: readers.signal,
                 });
-                run.waitingForContinuation = false;
-                run.pendingConnectionRequestId = undefined;
-                run.turn = nextTurn;
-                indexRun(run, nextTurn.runId);
-                run.streamClosed = false;
-                update(input.response.status);
-                append(run, { type: "run.status", status: "running" });
-                ensurePump(run);
-            })();
-            run.continuationPromise = continuation;
-            try {
-                await continuation;
-            }
-            catch (error) {
-                update("failed");
-                throw error;
+                if (input.response.status === "failed") {
+                    update("failed");
+                    delete run.pendingConnectionRequestId;
+                    run.phase = transition(run.phase, { type: "terminal" });
+                    run.terminalSource = "local";
+                    append(run, { type: "run.status", status: "failed" });
+                    append(run, {
+                        type: "run.failed",
+                        error: {
+                            code: "connection_failed",
+                            message: input.response.message?.trim() ||
+                                `Failed to connect ${pendingEvent.request.provider}.`,
+                        },
+                    });
+                    pruneRetainedRuns(run.terminalAtMs);
+                    return;
+                }
+                const continueTurn = run.session.continueTurn?.bind(run.session);
+                if (!continueTurn) {
+                    throw new Error("The Core runtime does not support connection continuation.");
+                }
+                if (run.continuationPromise) {
+                    throw new Error("A connection continuation is already in progress.");
+                }
+                update("connecting");
+                const continuation = (async () => {
+                    const activePump = run.pumpPromise;
+                    if (activePump)
+                        await activePump;
+                    while (isRunCancelling(run))
+                        await notifyWhenChanged(run, readers.signal);
+                    if (isRunTerminal(run)) {
+                        throw new Error("The AgentKit run is already terminal.");
+                    }
+                    const nextTurn = await continueTurn({
+                        ...(run.turn.id === undefined ? {} : { turnId: run.turn.id }),
+                        connection: {
+                            id: pendingEvent.request.provider,
+                            status: input.response.status === "connected"
+                                ? "connected"
+                                : "declined",
+                            ...(input.response.connectionId === undefined
+                                ? {}
+                                : { connectionId: input.response.connectionId }),
+                            ...(input.response.message === undefined
+                                ? {}
+                                : { message: input.response.message }),
+                        },
+                        abortSignal: readers.signal,
+                    });
+                    while (isRunCancelling(run))
+                        await notifyWhenChanged(run, readers.signal);
+                    if (run.phase.type !== "awaitingContinuation") {
+                        await closeDiscardedTurnEvents(nextTurn);
+                        throw new Error("The AgentKit run is already terminal.");
+                    }
+                    delete run.pendingConnectionRequestId;
+                    run.turn = nextTurn;
+                    indexRun(run, nextTurn.runId);
+                    run.phase = transition(run.phase, { type: "continuationResumed" });
+                    update(input.response.status);
+                    append(run, { type: "run.status", status: "running" });
+                    ensurePump(run);
+                })();
+                run.continuationPromise = continuation;
+                try {
+                    await continuation;
+                }
+                catch (error) {
+                    update("failed");
+                    throw error;
+                }
+                finally {
+                    if (run.continuationPromise === continuation) {
+                        run.continuationPromise = null;
+                    }
+                }
             }
             finally {
-                if (run.continuationPromise === continuation) {
-                    run.continuationPromise = null;
-                }
+                run.pendingConnectionResponses -= 1;
+                for (const listener of run.listeners)
+                    listener();
             }
         };
     }