@threadplane/langgraph 0.0.56 → 0.0.58

package/fesm2022/threadplane-langgraph.mjs

@@ -3,9 +3,9 @@ import { signal, Injectable, InjectionToken, computed, inject, DestroyRef, isSig
 import { toObservable, toSignal } from '@angular/core/rxjs-interop';
 import { takeUntil, Subject, BehaviorSubject, of, throttleTime, asyncScheduler } from 'rxjs';
 import { takeUntil as takeUntil$1 } from 'rxjs/operators';
+import { staticDelivery, completeDelivery, streamingDelivery, toAgentError, isAbortError, AgentError, AGENT_ERROR_MESSAGES, selectPendingClientToolCalls, mockAgent } from '@threadplane/chat';
 import { Client } from '@langchain/langgraph-sdk';
 import { getToolCallsWithResults } from '@langchain/langgraph-sdk/utils';
-import { toAgentError, isAbortError, AgentError, AGENT_ERROR_MESSAGES, mockAgent } from '@threadplane/chat';
 
 // SPDX-License-Identifier: MIT
 /**
@@ -226,6 +226,11 @@ function isRecord$2(value) {
 }
 
 const DEFAULT_SUBAGENT_TOOL_NAMES = ['task'];
+let subagentGenerationSequence = 0;
+function createSubagentGeneration() {
+    subagentGenerationSequence += 1;
+    return `subagent-${subagentGenerationSequence}-${Math.random().toString(36).slice(2, 10)}`;
+}
 /**
  * Lightweight Angular adapter for LangGraph subagent stream state.
  *
@@ -272,6 +277,7 @@ class SubagentTracker {
             const existing = this.subagents.get(id);
             this.subagents.set(id, {
                 id,
+                generation: existing?.generation ?? createSubagentGeneration(),
                 status: existing?.status ?? 'pending',
                 toolCall: {
                     id,
@@ -404,6 +410,22 @@ class SubagentTracker {
         });
         this.onSubagentChange?.();
     }
+    getMessageDelivery(toolCallId, message) {
+        const id = getMessageId(message) ?? toolCallId;
+        const raw = message;
+        const type = typeof message._getType === 'function' ? message._getType() : raw['type'];
+        if (type !== 'ai' && type !== 'assistant' && type !== 'AIMessage' && type !== 'AIMessageChunk') {
+            return staticDelivery(id);
+        }
+        const subagent = this.subagents.get(toolCallId);
+        if (!subagent)
+            return staticDelivery(id);
+        if (subagent.status === 'error')
+            return completeDelivery(subagent.generation, 'error');
+        if (subagent.status === 'complete')
+            return completeDelivery(subagent.generation, 'success');
+        return streamingDelivery(subagent.generation);
+    }
     retryPendingMatches() {
         for (const [namespaceId, description] of this.pendingMatches) {
             if (this.matchSubgraphToSubagent(namespaceId, description)) {
@@ -537,15 +559,19 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
     let abortController = null;
     let historyAbortController = null;
     let hasSeenThreadId = false;
-    /** True when the current abort was user-initiated (via stop()). Reset at the start of every new runStream(). */
-    let userAbortRequested = false;
+    const userAbortedControllers = new WeakSet();
     const toolProgressMap = new Map();
     // Message ids whose content is known-final (installed by a canonical
     // replacement). Late streamed deltas for these ids are stale stragglers and
     // are ignored — decided by identity, never by comparing text to text.
     const canonicalMessageIds = new Set();
     const queuedRuns = [];
-    let drainingQueue = false;
+    let queueDrainEpoch = 0;
+    let activeQueueDrainEpoch = null;
+    let attemptSequence = 0;
+    const messageDeliveries = new Map();
+    const deliveryRevision = signal(0, ...(ngDevMode ? [{ debugName: "deliveryRevision" }] : []));
+    let activeAttempt = null;
     const subagentManager = new SubagentTracker({
         subagentToolNames: options.subagentToolNames,
         onSubagentChange: publishSubagents,
@@ -565,6 +591,135 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
      * resetThreadState() and on bridge teardown.
      */
     const reasoningTimingMap = new Map();
+    function notifyDeliveryChange() {
+        deliveryRevision.update(revision => revision + 1);
+    }
+    function beginAttempt(allowBaselineTail = false) {
+        if (activeAttempt?.awaitingFinalSync) {
+            historyAbortController?.abort();
+        }
+        if (activeAttempt && !activeAttempt.terminalOutcome) {
+            finalizeAttempt(activeAttempt, 'interrupted');
+        }
+        const baselineMessageIds = new Set();
+        for (const message of subjects.messages$.value) {
+            const id = message['id'];
+            if (typeof id === 'string')
+                baselineMessageIds.add(id);
+        }
+        attemptSequence += 1;
+        const attempt = {
+            generation: `attempt-${attemptSequence}-${Math.random().toString(36).slice(2, 10)}`,
+            messageIds: new Set(),
+            finalizedMessageIds: new Set(),
+            baselineMessageIds,
+            eligibleBaselineAssistantId: allowBaselineTail
+                ? getTailAssistantMessageId(subjects.messages$.value)
+                : undefined,
+            sawAssistantChunk: false,
+            currentStepHasTerminalEvidence: false,
+            awaitingFinalSync: false,
+        };
+        activeAttempt = attempt;
+        return attempt;
+    }
+    function isCurrentExecution(controller, attempt) {
+        return abortController === controller && activeAttempt === attempt;
+    }
+    function setDelivery(id, delivery) {
+        const previous = messageDeliveries.get(id);
+        if (previous?.generation === delivery.generation
+            && previous.phase === delivery.phase
+            && (previous.phase !== 'complete' || delivery.phase !== 'complete' || previous.outcome === delivery.outcome)) {
+            return;
+        }
+        messageDeliveries.set(id, delivery);
+        notifyDeliveryChange();
+    }
+    function finalizeMessage(attempt, id, outcome) {
+        setDelivery(id, completeDelivery(attempt.generation, outcome));
+        attempt.finalizedMessageIds.add(id);
+    }
+    function finalizeAttempt(attempt, outcome) {
+        if (attempt.terminalOutcome)
+            return;
+        attempt.terminalOutcome = outcome;
+        for (const id of attempt.messageIds) {
+            if (attempt.finalizedMessageIds.has(id))
+                continue;
+            finalizeMessage(attempt, id, outcome);
+        }
+    }
+    function finishOutcome(attempt) {
+        return attempt.terminalOutcome
+            ?? (attempt.currentStepHasTerminalEvidence || !attempt.sawAssistantChunk ? 'success' : 'interrupted');
+    }
+    async function finalizeClosedAttempt(controller, attempt) {
+        if (attempt.terminalOutcome)
+            return attempt.terminalOutcome;
+        const outcome = finishOutcome(attempt);
+        attempt.awaitingFinalSync = true;
+        try {
+            await refreshHistory(true, () => isCurrentExecution(controller, attempt) && !attempt.terminalOutcome);
+        }
+        finally {
+            attempt.awaitingFinalSync = false;
+        }
+        if (!isCurrentExecution(controller, attempt))
+            return null;
+        if (!attempt.terminalOutcome)
+            finalizeAttempt(attempt, outcome);
+        return attempt.terminalOutcome ?? outcome;
+    }
+    function trackAssistantMessages(messages) {
+        const attempt = activeAttempt;
+        if (!attempt || attempt.terminalOutcome)
+            return;
+        const assistantMessages = messages.filter(message => {
+            const raw = message;
+            const type = normalizeMessageType(typeof message._getType === 'function' ? message._getType() : raw['type']);
+            const id = typeof raw['id'] === 'string' ? raw['id'] : undefined;
+            return type === 'ai' && id && !attempt.finalizedMessageIds.has(id);
+        });
+        const newAssistantMessages = assistantMessages.filter(message => {
+            const id = message['id'];
+            return typeof id === 'string' && !attempt.baselineMessageIds.has(id);
+        });
+        const currentStepMessages = newAssistantMessages.length > 0
+            ? newAssistantMessages
+            : assistantMessages.filter(message => message['id'] === attempt.eligibleBaselineAssistantId);
+        for (const message of currentStepMessages) {
+            const id = message['id'];
+            if (attempt.currentAssistantMessageId && attempt.currentAssistantMessageId !== id) {
+                finalizeMessage(attempt, attempt.currentAssistantMessageId, 'success');
+                attempt.currentStepHasTerminalEvidence = false;
+            }
+            attempt.currentAssistantMessageId = id;
+            attempt.messageIds.add(id);
+            attempt.sawAssistantChunk = true;
+            setDelivery(id, streamingDelivery(attempt.generation));
+        }
+    }
+    function invalidateQueueDrain() {
+        queueDrainEpoch += 1;
+        activeQueueDrainEpoch = null;
+    }
+    function markNormalTerminal(event) {
+        const attempt = activeAttempt;
+        if (!attempt
+            || attempt.terminalOutcome
+            || !attempt.sawAssistantChunk
+            || (getEventNamespace(event)?.length ?? 0) > 0)
+            return;
+        const baseType = getBaseEventType(event.type);
+        // These are the canonical state/snapshot signals available in the current
+        // transport contract. Iterator close alone is deliberately not terminal
+        // evidence: after assistant chunks, a close without one of these markers
+        // is classified as interrupted.
+        if (baseType === 'values' || baseType === 'messages/complete' || baseType === 'checkpoints') {
+            attempt.currentStepHasTerminalEvidence = true;
+        }
+    }
     function resetThreadState() {
         historyAbortController?.abort();
         subjects.values$.next({});
@@ -584,10 +739,19 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
         subagentManager.clear();
         reasoningTimingMap.clear();
         canonicalMessageIds.clear();
+        if (activeAttempt && !activeAttempt.terminalOutcome) {
+            finalizeAttempt(activeAttempt, 'interrupted');
+        }
+        messageDeliveries.clear();
+        activeAttempt = null;
+        notifyDeliveryChange();
     }
     function setThreadId(id, resetState) {
         if (resetState) {
+            invalidateQueueDrain();
             abortController?.abort();
+            lastPayload = null;
+            lastOptions = undefined;
         }
         currentThreadId = id;
         if (resetState) {
@@ -602,11 +766,18 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
         setThreadId(id, shouldReset);
     });
     destroy$.subscribe(() => {
+        invalidateQueueDrain();
         abortController?.abort();
         historyAbortController?.abort();
         reasoningTimingMap.clear();
+        if (activeAttempt && !activeAttempt.terminalOutcome) {
+            finalizeAttempt(activeAttempt, 'interrupted');
+        }
+        messageDeliveries.clear();
+        activeAttempt = null;
+        notifyDeliveryChange();
     });
-    async function refreshHistory(force = false) {
+    async function refreshHistory(force = false, isRelevant = () => true) {
         const getHistory = transport.getHistory?.bind(transport);
         if (!currentThreadId || !getHistory)
             return;
@@ -616,8 +787,8 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
         const threadId = currentThreadId;
         subjects.isThreadLoading$.next(true);
         try {
-            const history = await getHistory(threadId, controller.signal);
-            if (!controller.signal.aborted && currentThreadId === threadId) {
+            const history = await waitForHistory(getHistory(threadId, controller.signal), controller.signal);
+            if (!controller.signal.aborted && currentThreadId === threadId && isRelevant()) {
                 subjects.history$.next(history);
                 // Project the latest checkpoint into messages$ + values$:
                 //  - On first connect (`force=false`): only when messages$ is
@@ -636,7 +807,7 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
                     // canonical surface for them; keeping a duplicate in values$
                     // would confuse downstream consumers reading both subjects.
                     delete restoredValues.messages;
-                    subjects.messages$.next(restoredMessages);
+                    subjects.messages$.next(preserveIds(subjects.messages$.value, restoredMessages));
                     subjects.values$.next(restoredValues);
                     // Rebuild derived subjects from the new authoritative messages$.
                     // Tool-call results displayed by chat-tool-calls come from
@@ -653,7 +824,7 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
             }
         }
         catch (err) {
-            if (!controller.signal.aborted && err?.name !== 'AbortError') {
+            if (!controller.signal.aborted && isRelevant() && err?.name !== 'AbortError') {
                 subjects.error$.next(toAgentError(err));
             }
         }
@@ -664,6 +835,30 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
             }
         }
     }
+    function waitForHistory(history, signal) {
+        if (signal.aborted)
+            return Promise.reject(createHistoryAbortError());
+        return new Promise((resolve, reject) => {
+            const onAbort = () => {
+                cleanup();
+                reject(createHistoryAbortError());
+            };
+            const cleanup = () => signal.removeEventListener('abort', onAbort);
+            signal.addEventListener('abort', onAbort, { once: true });
+            history.then(value => {
+                cleanup();
+                resolve(value);
+            }, error => {
+                cleanup();
+                reject(error);
+            });
+        });
+    }
+    function createHistoryAbortError() {
+        const error = new Error('History refresh aborted.');
+        error.name = 'AbortError';
+        return error;
+    }
     function publishQueue() {
         subjects.queue$.next(createQueueSnapshot());
     }
@@ -719,24 +914,33 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
         await Promise.all(entries.map(entry => cancelRun(entry.threadId, entry.id, new AbortController().signal)));
     }
     async function drainQueue() {
-        if (drainingQueue || queuedRuns.length === 0)
+        if (activeQueueDrainEpoch !== null || queuedRuns.length === 0)
             return;
-        drainingQueue = true;
+        queueDrainEpoch += 1;
+        const drainEpoch = queueDrainEpoch;
+        activeQueueDrainEpoch = drainEpoch;
         try {
             while (queuedRuns.length > 0) {
+                if (activeQueueDrainEpoch !== drainEpoch)
+                    return;
                 const entry = queuedRuns.shift();
                 publishQueue();
                 if (!entry || !transport.joinStream)
                     continue;
-                await joinQueuedRun(entry);
+                await joinQueuedRun(entry, drainEpoch);
             }
         }
         finally {
-            drainingQueue = false;
+            if (activeQueueDrainEpoch === drainEpoch)
+                activeQueueDrainEpoch = null;
         }
     }
-    async function joinQueuedRun(entry) {
-        abortController = new AbortController();
+    async function joinQueuedRun(entry, drainEpoch) {
+        if (activeQueueDrainEpoch !== drainEpoch)
+            return;
+        const controller = new AbortController();
+        abortController = controller;
+        const attempt = beginAttempt(true);
         const startedAt = Date.now();
         captureRuntimeRequestTelemetry('join_queued');
         captureAgentRuntimeTelemetry(options.telemetry, 'tplane:stream_started', telemetryProperties);
@@ -746,19 +950,22 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
         subjects.status$.next(ResourceStatus.Loading);
         try {
             const iter = transport.joinStream
-                ? transport.joinStream(entry.threadId, entry.id, undefined, abortController.signal)
+                ? transport.joinStream(entry.threadId, entry.id, undefined, controller.signal)
                 : [];
             for await (const event of iter) {
-                if (abortController.signal.aborted)
+                if (controller.signal.aborted || !isCurrentExecution(controller, attempt))
                     break;
                 processEvent(event);
             }
-            if (!abortController.signal.aborted) {
-                subjects.status$.next(ResourceStatus.Resolved);
-                // force=true: rehydrate from server-authoritative state so any
-                // post-process node mutations (RemoveMessage, id-match content
-                // replacement) reflected on the server are picked up client-side.
-                await refreshHistory(true);
+            if (!isCurrentExecution(controller, attempt))
+                return;
+            const outcome = await finalizeClosedAttempt(controller, attempt);
+            if (outcome === null)
+                return;
+            if (!controller.signal.aborted) {
+                if (outcome !== 'error') {
+                    subjects.status$.next(ResourceStatus.Resolved);
+                }
                 captureAgentRuntimeTelemetry(options.telemetry, 'tplane:stream_ended', {
                     ...telemetryProperties,
                     durationMs: Date.now() - startedAt,
@@ -766,19 +973,37 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
             }
         }
         catch (err) {
-            subjects.error$.next(toAgentError(err));
-            subjects.status$.next(ResourceStatus.Error);
-            captureAgentRuntimeTelemetry(options.telemetry, 'tplane:stream_errored', {
-                ...telemetryProperties,
-                durationMs: Date.now() - startedAt,
-                errorClass: agentRuntimeTelemetryErrorClass(err),
-            });
+            if (!isCurrentExecution(controller, attempt))
+                return;
+            if (attempt.terminalOutcome)
+                return;
+            if (isAbortError(err) && userAbortedControllers.has(controller)) {
+                finalizeAttempt(attempt, 'aborted');
+                subjects.error$.next(undefined);
+                subjects.status$.next(ResourceStatus.Idle);
+            }
+            else {
+                finalizeAttempt(attempt, attempt.sawAssistantChunk ? 'interrupted' : 'error');
+                subjects.error$.next(toAgentError(err));
+                subjects.status$.next(ResourceStatus.Error);
+                captureAgentRuntimeTelemetry(options.telemetry, 'tplane:stream_errored', {
+                    ...telemetryProperties,
+                    durationMs: Date.now() - startedAt,
+                    errorClass: agentRuntimeTelemetryErrorClass(err),
+                });
+            }
+        }
+        finally {
+            if (abortController === controller)
+                abortController = null;
         }
     }
     async function runStream(payload, opts, requestType = 'submit') {
+        invalidateQueueDrain();
         abortController?.abort();
-        abortController = new AbortController();
-        userAbortRequested = false;
+        const controller = new AbortController();
+        abortController = controller;
+        const attempt = beginAttempt(requestType === 'resubmit' || (isRecord$1(opts?.command) && 'resume' in opts.command));
         const startedAt = Date.now();
         captureRuntimeRequestTelemetry(requestType);
         captureAgentRuntimeTelemetry(options.telemetry, 'tplane:stream_started', telemetryProperties);
@@ -788,7 +1013,7 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
         subjects.toolProgress$.next([]);
         toolProgressMap.clear();
         canonicalMessageIds.clear();
-        lastPayload = payload;
+        lastPayload = payload ?? null;
         lastOptions = opts;
         // Tracks whether at least one stream event has been processed this run.
         // Used to distinguish a mid-stream network interruption (kind:'interrupted')
@@ -813,31 +1038,43 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
             subjects.messages$.next([...existing, ...stamped]);
         }
         try {
-            const iter = transport.stream(options.assistantId, currentThreadId, payload, opts?.signal ?? abortController.signal, opts);
+            const iter = transport.stream(options.assistantId, currentThreadId, payload, opts?.signal ?? controller.signal, opts);
             for await (const event of iter) {
-                if (abortController.signal.aborted)
+                if (controller.signal.aborted || !isCurrentExecution(controller, attempt))
                     break;
                 streamingStarted = true;
                 processEvent(event);
             }
-            if (!abortController.signal.aborted) {
-                subjects.status$.next(ResourceStatus.Resolved);
-                // force=true: see refreshHistory comment — server state is
-                // authoritative after run completion.
-                await refreshHistory(true);
+            if (!isCurrentExecution(controller, attempt))
+                return finishOutcome(attempt);
+            const outcome = await finalizeClosedAttempt(controller, attempt);
+            if (outcome === null)
+                return finishOutcome(attempt);
+            if (!controller.signal.aborted) {
+                if (outcome !== 'error') {
+                    subjects.status$.next(ResourceStatus.Resolved);
+                }
                 await drainQueue();
                 captureAgentRuntimeTelemetry(options.telemetry, 'tplane:stream_ended', {
                     ...telemetryProperties,
                     durationMs: Date.now() - startedAt,
                 });
             }
+            return outcome;
         }
         catch (err) {
-            if (isAbortError(err) && userAbortRequested) {
+            if (!isCurrentExecution(controller, attempt))
+                return finishOutcome(attempt);
+            if (attempt.terminalOutcome)
+                return attempt.terminalOutcome;
+            if (isAbortError(err) && userAbortedControllers.has(controller)) {
+                finalizeAttempt(attempt, 'aborted');
                 // User explicitly called stop() — treat as graceful idle, not an error.
+                subjects.error$.next(undefined);
                 subjects.status$.next(ResourceStatus.Idle);
             }
             else if (isAbortError(err)) {
+                finalizeAttempt(attempt, attempt.sawAssistantChunk ? 'interrupted' : 'error');
                 // A non-user-requested abort: interrupted if a stream had started, else a
                 // connect-phase failure. Never "aborted" (that's reserved for user stop).
                 const e = streamingStarted
@@ -852,6 +1089,7 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
                 });
             }
             else {
+                finalizeAttempt(attempt, attempt.sawAssistantChunk ? 'interrupted' : 'error');
                 subjects.error$.next(toAgentError(err));
                 subjects.status$.next(ResourceStatus.Error);
                 captureAgentRuntimeTelemetry(options.telemetry, 'tplane:stream_errored', {
@@ -860,11 +1098,19 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
                     errorClass: agentRuntimeTelemetryErrorClass(err),
                 });
             }
+            return finishOutcome(attempt);
+        }
+        finally {
+            if (abortController === controller)
+                abortController = null;
         }
     }
     function processEvent(event) {
         const baseType = getBaseEventType(event.type);
         const namespace = getEventNamespace(event);
+        if (baseType === 'checkpoints' || baseType === 'messages/complete') {
+            markNormalTerminal(event);
+        }
         if (isMessagesEvent(event.type)) {
             const msgs = normalizeMessages(event);
             if (!msgs)
@@ -887,8 +1133,22 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
             // Partial and message-tuple events are incremental. Merge them by id
             // so optimistic human messages and earlier tool messages are preserved.
             if (event.type === 'messages/partial' || event.messageMetadata) {
+                if (!isTranscriptMessageEvent(event, options.transcriptNodeNames)) {
+                    storeMessageMetadata(normalized, event);
+                    syncSubagentsFromMessages(normalized);
+                    return;
+                }
                 const mode = event.messageMetadata ? 'delta' : 'snapshot';
-                subjects.messages$.next(mergeMessages(subjects.messages$.value, normalized, reasoningTimingMap, mode, canonicalMessageIds));
+                const affectedMessageIds = new Set();
+                const merged = mergeMessages(subjects.messages$.value, normalized, reasoningTimingMap, mode, canonicalMessageIds, affectedMessageIds, activeAttempt?.currentAssistantMessageId !== undefined
+                    && activeAttempt.currentStepHasTerminalEvidence !== true);
+                subjects.messages$.next(merged);
+                if (!isSubagentNamespace(namespace)) {
+                    trackAssistantMessages(merged.filter(message => {
+                        const id = message['id'];
+                        return typeof id === 'string' && affectedMessageIds.has(id);
+                    }));
+                }
                 if (isLgTraceEnabled()) {
                     const msgs = subjects.messages$.value;
                     const last = msgs[msgs.length - 1];
@@ -903,8 +1163,17 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
             else {
                 // Preserve existing ids by content so the final-id swap doesn't
                 // tear down the chat-message DOM (and its streaming-md renderer).
-                subjects.messages$.next(preserveIds(subjects.messages$.value, normalized));
+                const affectedMessageIds = new Set();
+                const preserved = preserveIds(subjects.messages$.value, normalized, affectedMessageIds);
+                subjects.messages$.next(preserved);
+                if (!isSubagentNamespace(namespace)) {
+                    trackAssistantMessages(preserved.filter(message => {
+                        const id = message['id'];
+                        return typeof id === 'string' && affectedMessageIds.has(id);
+                    }));
+                }
             }
+            markNormalTerminal(event);
             storeMessageMetadata(normalized, event);
             syncSubagentsFromMessages(normalized);
             syncToolCallsFromMessages();
@@ -920,6 +1189,15 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
                     updateSubagentValues(namespace, vals);
                     break;
                 }
+                if ((namespace?.length ?? 0) === 0) {
+                    if (hasInterrupts(vals)) {
+                        if (activeAttempt)
+                            finalizeAttempt(activeAttempt, 'paused');
+                    }
+                    else {
+                        markNormalTerminal(event);
+                    }
+                }
                 if (vals != null) {
                     extractInterrupts(vals, subjects);
                     subjects.values$.next(vals);
@@ -988,13 +1266,19 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
                 break;
             }
             case 'error':
+                if (activeAttempt)
+                    finalizeAttempt(activeAttempt, 'error');
                 subjects.error$.next(toAgentError(event['error']));
                 subjects.status$.next(ResourceStatus.Error);
                 break;
             case 'interrupt':
+                if (activeAttempt)
+                    finalizeAttempt(activeAttempt, 'paused');
                 subjects.interrupt$.next(event['interrupt']);
                 break;
             case 'interrupts':
+                if (activeAttempt)
+                    finalizeAttempt(activeAttempt, 'paused');
                 subjects.interrupts$.next(event['interrupts']);
                 break;
             case 'custom': {
@@ -1127,19 +1411,24 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
         submit: async (payload, opts) => {
             if (opts?.multitaskStrategy === 'enqueue' && subjects.status$.value === ResourceStatus.Loading) {
                 await enqueueRun(payload, opts);
-                return;
+                return 'success';
             }
-            await runStream(payload, opts);
+            return runStream(payload, opts);
         },
         stop: async () => {
-            userAbortRequested = true;
+            invalidateQueueDrain();
+            const shouldAbortAttempt = Boolean(abortController && activeAttempt && !activeAttempt.terminalOutcome);
+            if (shouldAbortAttempt && abortController)
+                userAbortedControllers.add(abortController);
+            if (shouldAbortAttempt && activeAttempt)
+                finalizeAttempt(activeAttempt, 'aborted');
             abortController?.abort();
+            if (activeAttempt?.awaitingFinalSync)
+                historyAbortController?.abort();
             await clearQueue();
-            // Note: status is set to Idle by the runStream() catch when it sees
-            // isAbortError && userAbortRequested. The explicit set here handles
-            // the case where stop() is called when no stream is active (so the
-            // catch never fires) or when clearQueue() raised an error.
-            if (subjects.status$.value !== ResourceStatus.Idle) {
+            // Set Idle synchronously for an active user cancellation. Attempts that
+            // already reached a terminal outcome retain their existing status.
+            if (shouldAbortAttempt && subjects.status$.value !== ResourceStatus.Idle) {
                 subjects.status$.next(ResourceStatus.Idle);
             }
         },
@@ -1149,8 +1438,12 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
         joinStream: async (runId, lastEventId) => {
             if (!currentThreadId)
                 return;
+            invalidateQueueDrain();
             abortController?.abort();
-            abortController = new AbortController();
+            const controller = new AbortController();
+            abortController = controller;
+            const attempt = beginAttempt(true);
+            const threadId = currentThreadId;
             const startedAt = Date.now();
             captureRuntimeRequestTelemetry('join');
             captureAgentRuntimeTelemetry(options.telemetry, 'tplane:stream_started', telemetryProperties);
@@ -1158,34 +1451,61 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
             subjects.toolProgress$.next([]);
             toolProgressMap.clear();
             subjects.status$.next(ResourceStatus.Loading);
+            subjects.error$.next(undefined);
             try {
                 const iter = transport.joinStream
-                    ? transport.joinStream(currentThreadId, runId, lastEventId, abortController.signal)
+                    ? transport.joinStream(threadId, runId, lastEventId, controller.signal)
                     : [];
                 for await (const event of iter) {
+                    if (controller.signal.aborted || !isCurrentExecution(controller, attempt))
+                        break;
                     processEvent(event);
                 }
-                subjects.status$.next(ResourceStatus.Resolved);
-                await refreshHistory();
-                captureAgentRuntimeTelemetry(options.telemetry, 'tplane:stream_ended', {
-                    ...telemetryProperties,
-                    durationMs: Date.now() - startedAt,
-                });
+                if (!isCurrentExecution(controller, attempt))
+                    return;
+                const outcome = await finalizeClosedAttempt(controller, attempt);
+                if (outcome === null)
+                    return;
+                if (!controller.signal.aborted) {
+                    if (outcome !== 'error') {
+                        subjects.status$.next(ResourceStatus.Resolved);
+                    }
+                    captureAgentRuntimeTelemetry(options.telemetry, 'tplane:stream_ended', {
+                        ...telemetryProperties,
+                        durationMs: Date.now() - startedAt,
+                    });
+                }
             }
             catch (err) {
-                subjects.error$.next(toAgentError(err));
-                subjects.status$.next(ResourceStatus.Error);
-                captureAgentRuntimeTelemetry(options.telemetry, 'tplane:stream_errored', {
-                    ...telemetryProperties,
-                    durationMs: Date.now() - startedAt,
-                    errorClass: agentRuntimeTelemetryErrorClass(err),
-                });
+                if (!isCurrentExecution(controller, attempt))
+                    return;
+                if (attempt.terminalOutcome)
+                    return;
+                if (isAbortError(err) && userAbortedControllers.has(controller)) {
+                    finalizeAttempt(attempt, 'aborted');
+                    subjects.error$.next(undefined);
+                    subjects.status$.next(ResourceStatus.Idle);
+                }
+                else {
+                    finalizeAttempt(attempt, attempt.sawAssistantChunk ? 'interrupted' : 'error');
+                    subjects.error$.next(toAgentError(err));
+                    subjects.status$.next(ResourceStatus.Error);
+                    captureAgentRuntimeTelemetry(options.telemetry, 'tplane:stream_errored', {
+                        ...telemetryProperties,
+                        durationMs: Date.now() - startedAt,
+                        errorClass: agentRuntimeTelemetryErrorClass(err),
+                    });
+                }
+            }
+            finally {
+                if (abortController === controller)
+                    abortController = null;
             }
         },
         resubmitLast: async () => {
-            if (lastPayload !== null) {
-                await runStream(lastPayload, lastOptions, 'resubmit');
-            }
+            if (lastPayload === null)
+                return 'not-started';
+            return runStream(lastPayload, lastOptions, 'resubmit');
         },
         getReasoningDurationMs: (id) => {
             const entry = reasoningTimingMap.get(id);
@@ -1195,6 +1515,9 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
                 return undefined;
             return entry.endedAt - entry.startedAt;
         },
+        getMessageDelivery: (id) => messageDeliveries.get(id) ?? staticDelivery(id),
+        getSubagentMessageDelivery: (toolCallId, message) => subagentManager.getMessageDelivery(toolCallId, message),
+        deliveryRevision,
         updateState: async (values, opts) => {
             // No-op when there is no thread yet or the transport doesn't support
             // updateState (e.g. MockAgentTransport in unit tests without a threadId).
@@ -1208,6 +1531,14 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
         },
     };
 }
+function isTranscriptMessageEvent(event, transcriptNodeNames) {
+    if (!transcriptNodeNames || transcriptNodeNames.length === 0)
+        return true;
+    const node = event.messageMetadata?.['langgraph_node'];
+    if (typeof node !== 'string')
+        return true;
+    return transcriptNodeNames.includes(node);
+}
 /**
  * Extracts the payload data from a normalized SDK event.
  *
@@ -1242,6 +1573,12 @@ function extractInterrupts(payload, subjects) {
         subjects.interrupts$.next([]);
     }
 }
+function hasInterrupts(payload) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload))
+        return false;
+    const raw = payload['__interrupt__'];
+    return Array.isArray(raw) && raw.length > 0;
+}
 /**
  * Projects pending interrupts from the latest history checkpoint onto the
  * interrupt$ / interrupts$ subjects. ThreadState exposes interrupts under
@@ -1337,7 +1674,7 @@ function normalizeMessages(event) {
  * carry the full text we collapse them, keeping the older slot's id so
  * track-by-id stays stable in the chat list.
  */
-function collapseAdjacentAi(messages) {
+function collapseAdjacentAi(messages, affectedMessageIds, allowCrossIdAiMerge = true) {
     if (messages.length < 2)
         return messages;
     const out = [];
@@ -1352,13 +1689,21 @@ function collapseAdjacentAi(messages) {
         if (lastType === 'ai' && msgType === 'ai') {
             const lastText = extractText(last.content);
             const msgText = extractText(msg.content);
-            if (lastText.length === 0
+            const lastRaw = last;
+            const msgRaw = msg;
+            const differentIds = lastRaw['id'] !== msgRaw['id'];
+            if (!(differentIds && !allowCrossIdAiMerge) && (lastText.length === 0
                 || msgText.length === 0
                 || lastText === msgText
                 || lastText.startsWith(msgText)
-                || msgText.startsWith(lastText)) {
+                || msgText.startsWith(lastText))) {
                 // Keep the longer content; preserve last (older) id and metadata.
                 const longerText = msgText.length >= lastText.length ? msgText : lastText;
+                const lastId = last['id'];
+                const msgId = msg['id'];
+                if (typeof msgId === 'string' && affectedMessageIds?.delete(msgId) && typeof lastId === 'string') {
+                    affectedMessageIds.add(lastId);
+                }
                 out[out.length - 1] = { ...last, content: longerText };
                 continue;
             }
@@ -1367,7 +1712,7 @@ function collapseAdjacentAi(messages) {
     }
     return out;
 }
-function mergeMessages(existing, incoming, reasoningTimingMap, mode = 'snapshot', canonicalMessageIds) {
+function mergeMessages(existing, incoming, reasoningTimingMap, mode = 'snapshot', canonicalMessageIds, affectedMessageIds, allowCrossIdAiMerge = true) {
     const merged = [...existing];
     for (const msg of incoming) {
         const rawIn = msg;
@@ -1381,6 +1726,9 @@ function mergeMessages(existing, incoming, reasoningTimingMap, mode = 'snapshot'
         // prevents DOM teardown + animation restarts mid-stream.
         if (idx < 0) {
             idx = findContentMatch(merged, msg);
+            if (idx >= 0 && !canMergeCrossIdAi(merged[idx], msg, allowCrossIdAiMerge)) {
+                idx = -1;
+            }
         }
         // When an AIMessageChunk arrives without an id-match or content-prefix
         // match, treat the trailing AI message as its accumulator. The
@@ -1395,6 +1743,8 @@ function mergeMessages(existing, incoming, reasoningTimingMap, mode = 'snapshot'
                         ? merged[i]._getType()
                         : merged[i]['type']);
                     if (t === 'ai') {
+                        if (!canMergeCrossIdAi(merged[i], msg, allowCrossIdAiMerge))
+                            break;
                         idx = i;
                         break;
                     }
@@ -1450,7 +1800,10 @@ function mergeMessages(existing, incoming, reasoningTimingMap, mode = 'snapshot'
             if (existingId) {
                 next['id'] = existingId;
             }
+            const changed = mode === 'delta' || messageChangedForDelivery(existing, next);
             merged[idx] = next;
+            if (targetId && changed)
+                affectedMessageIds?.add(targetId);
         }
         else {
             const incomingRaw = msg;
@@ -1467,9 +1820,19 @@ function mergeMessages(existing, incoming, reasoningTimingMap, mode = 'snapshot'
             const next = { ...msg };
             next['reasoning'] = initialReasoning;
             merged.push(next);
+            const nextId = next['id'];
+            if (typeof nextId === 'string')
+                affectedMessageIds?.add(nextId);
         }
     }
-    return collapseAdjacentAi(merged);
+    return collapseAdjacentAi(merged, affectedMessageIds, allowCrossIdAiMerge);
+}
+function canMergeCrossIdAi(candidate, incoming, allowCrossIdAiMerge) {
+    const candidateRaw = candidate;
+    const incomingRaw = incoming;
+    if (candidateRaw['id'] === incomingRaw['id'])
+        return true;
+    return allowCrossIdAiMerge;
 }
 /**
  * Merge an incoming chunk's content into prior accumulated content for the
@@ -1627,9 +1990,15 @@ function accumulateReasoning(existing, incoming) {
  * (role, content) matches positionally and the existing id differs. Keeps
  * track-by-id stable across server echoes and final-id swaps.
  */
-function preserveIds(existing, incoming) {
-    if (existing.length === 0)
-        return collapseAdjacentAi(incoming);
+function preserveIds(existing, incoming, affectedMessageIds) {
+    if (existing.length === 0) {
+        for (const message of incoming) {
+            const id = message['id'];
+            if (typeof id === 'string')
+                affectedMessageIds?.add(id);
+        }
+        return collapseAdjacentAi(incoming, affectedMessageIds);
+    }
     const usedExisting = new Set();
     const remapped = incoming.map((msg, i) => {
         const inRaw = msg;
@@ -1643,15 +2012,40 @@ function preserveIds(existing, incoming) {
             // Fallback: any unused existing message with matching role+content.
             matchIdx = existing.findIndex((m, j) => !usedExisting.has(j) && sameRoleAndContent(m, msg));
         }
-        if (matchIdx < 0)
+        if (matchIdx < 0) {
+            if (typeof inId === 'string')
+                affectedMessageIds?.add(inId);
             return msg;
+        }
         usedExisting.add(matchIdx);
         const existingId = existing[matchIdx]['id'];
-        if (!existingId || existingId === inId)
-            return msg;
-        return { ...msg, id: existingId };
+        const remappedMessage = !existingId || existingId === inId
+            ? msg
+            : { ...msg, id: existingId };
+        if (typeof existingId === 'string' && messageChangedForDelivery(existing[matchIdx], remappedMessage)) {
+            affectedMessageIds?.add(existingId);
+        }
+        return remappedMessage;
     });
-    return collapseAdjacentAi(remapped);
+    return collapseAdjacentAi(remapped, affectedMessageIds);
+}
+function messageChangedForDelivery(existing, incoming) {
+    const existingRaw = existing;
+    const incomingRaw = incoming;
+    const existingType = normalizeMessageType(typeof existing._getType === 'function' ? existing._getType() : existingRaw['type']);
+    const incomingType = normalizeMessageType(typeof incoming._getType === 'function' ? incoming._getType() : incomingRaw['type']);
+    if (existingType !== incomingType || extractText(existing.content) !== extractText(incoming.content)) {
+        return true;
+    }
+    const existingReasoning = typeof existingRaw['reasoning'] === 'string'
+        ? existingRaw['reasoning']
+        : extractReasoning(existingRaw['reasoning']);
+    const incomingReasoning = typeof incomingRaw['reasoning'] === 'string'
+        ? incomingRaw['reasoning']
+        : extractReasoning(incomingRaw['reasoning']);
+    if (existingReasoning !== incomingReasoning)
+        return true;
+    return JSON.stringify(existingRaw['tool_calls'] ?? null) !== JSON.stringify(incomingRaw['tool_calls'] ?? null);
 }
 function sameRoleAndContent(a, b) {
     const aType = normalizeMessageType(typeof a._getType === 'function' ? a._getType() : a['type']);
@@ -1723,6 +2117,14 @@ function normalizeMessageType(t) {
         return 'system';
     return t;
 }
+function getTailAssistantMessageId(messages) {
+    const tail = messages[messages.length - 1];
+    if (!tail)
+        return undefined;
+    const raw = tail;
+    const type = normalizeMessageType(typeof tail._getType === 'function' ? tail._getType() : raw['type']);
+    return type === 'ai' && typeof raw['id'] === 'string' ? raw['id'] : undefined;
+}
 function toSubagentRefs(subagents) {
     const refs = new Map();
     subagents.forEach((subagent, key) => {
@@ -1921,12 +2323,19 @@ function normalizeCitation(entry, fallbackIndex) {
         }
         return undefined;
     };
+    const publishedAt = e['publishedAt'];
+    const normalizedPublishedAt = typeof publishedAt === 'string' || typeof publishedAt === 'number' || publishedAt instanceof Date
+        ? publishedAt
+        : undefined;
     return {
         id: str('id') ?? str('refId') ?? `c${fallbackIndex}`,
         index: typeof e['index'] === 'number' ? e['index'] : fallbackIndex,
         title: firstStr('title', 'name'),
         url: firstStr('url', 'href', 'source'),
         snippet: firstStr('snippet', 'content', 'excerpt'),
+        sourceType: str('sourceType'),
+        iconUrl: str('iconUrl'),
+        publishedAt: normalizedPublishedAt,
         extra: typeof e['extra'] === 'object' && e['extra'] !== null
             ? e['extra']
             : undefined,
@@ -1959,6 +2368,41 @@ function mergeClientTools(payload, catalog) {
         return payload;
     return { ...payload, client_tools: catalog };
 }
+/**
+ * Merge A2UI client capabilities into a run payload under the
+ * `a2ui_client_capabilities` state key. Same payload semantics as
+ * {@link mergeClientTools}: null/undefined payloads (command resumes,
+ * regenerates) and non-record payloads pass through untouched, and the
+ * original object is never mutated. Because LangGraph thread state
+ * persists across runs, the capabilities stamped by any run remain
+ * readable by later runs on the same thread.
+ */
+function mergeA2uiClientCapabilities(payload, capabilities) {
+    if (!capabilities)
+        return payload;
+    if (payload === null || payload === undefined)
+        return payload;
+    if (typeof payload !== 'object' || Array.isArray(payload))
+        return payload;
+    return { ...payload, a2ui_client_capabilities: capabilities };
+}
+/**
+ * Prepend staged tool messages to a run payload's message list.
+ *
+ * Mirrors mergeClientTools: a null payload signals a no-input resume and must
+ * stay null, so staged messages cannot ride along and are left buffered.
+ */
+function mergeStagedToolMessages(payload, staged) {
+    if (staged.length === 0)
+        return payload;
+    if (payload === null || payload === undefined)
+        return payload;
+    if (typeof payload !== 'object' || Array.isArray(payload))
+        return payload;
+    const record = payload;
+    const existing = Array.isArray(record['messages']) ? record['messages'] : [];
+    return { ...record, messages: [...staged, ...existing] };
+}
 /**
  * Creates a ClientToolsCapability backed by a LangGraph submit function and
  * a store of tool-call signals. Extracted into a factory so it can be
@@ -1973,14 +2417,26 @@ function mergeClientTools(payload, catalog) {
  *    yet — but ONLY when the run is not in progress (isLoading===false).
  *    The backend ends the run without emitting a ToolMessage result for
  *    client tools, so `result` stays undefined on those entries.
- *  - resolve(id, result): marks the call as resolved, then issues a NEW
- *    run on the SAME thread by calling submitFn with:
+ *  - settle(id, result): marks the call as resolved, writes the local result,
+ *    and stages a ToolMessage with a deterministic ID without issuing a run.
+ *  - flush(): snapshots the whole staged group into ONE persistFn call without
+ *    starting a run — the settlement path for tool groups that never continue.
+ *    Successful persistence acknowledges the captured entries; failed writes
+ *    retain them. When persistFn is absent, a non-empty flush rejects without
+ *    changing the staged results. Flushes are chained so entries settled after
+ *    one snapshot receive their own write. Concurrent persistence,
+ *    continuation, and ordinary submits may safely carry the same stable IDs.
+ *  - clearStagedToolMessages(): discards staged results on a thread switch and
+ *    advances the generation so late acknowledgments cannot affect new state.
+ *  - resolve(id, result): settles the result, then issues a NEW run on the SAME
+ *    thread by calling submitFn with a non-destructive ToolMessage snapshot:
  *      input: {
  *        messages: [{ type: 'tool', role: 'tool', tool_call_id: id, content }],
  *        client_tools: catalog(),
  *      }
- *    The `add_messages` reducer on the Python side appends the ToolMessage
- *    to thread state. Including `client_tools` ensures the model sees the
+ *    The snapshot remains staged unless that continuation reports success.
+ *    LangGraph's `add_messages` reducer reuses each stable message ID on safe
+ *    overlap or replay. Including `client_tools` ensures the model sees the
  *    full tool catalog on the continuation run.
  *
  * Catalog shipping: the catalog is NOT injected by this factory's
@@ -1990,62 +2446,199 @@ function mergeClientTools(payload, catalog) {
  * before forwarding to manager.submit. This keeps injection concerns
  * co-located with the run-issuing call sites.
  */
-function createClientToolsCapability(submitFn, store) {
+function createClientToolsCapability(submitFn, store, persistFn, currentThreadIdFn) {
     const catalog = signal([], ...(ngDevMode ? [{ debugName: "catalog" }] : []));
     const resolvedIds = signal(new Set(), ...(ngDevMode ? [{ debugName: "resolvedIds" }] : []));
+    const toolMessageBuffer = [];
+    let flushInFlight;
+    // Bumped whenever a thread reset discards staged state. Every snapshot keeps
+    // its generation, making acknowledgments from the prior thread no-ops.
+    let bufferGeneration = 0;
+    // Tool calls belonging to threads we have left. A handler still running when
+    // the user switches threads settles AFTER the switch, by which point both the
+    // store and the current thread id already describe the NEW thread — the id is
+    // the only durable way left to recognise the result as stale.
+    const retiredToolCallIds = new Set();
     const pending = computed(() => {
         // Client tools are only actionable after the run ends (the backend
         // signals this by ending the run WITHOUT emitting a ToolMessage result
         // for client tools).
-        if (store.isLoading())
-            return [];
-        const names = new Set(catalog().map((s) => s.name));
-        const done = resolvedIds();
-        return store.toolCalls().filter((tc) => names.has(tc.name) && tc.result === undefined && !done.has(tc.id));
+        return selectPendingClientToolCalls({
+            isLoading: store.isLoading(),
+            toolCalls: store.toolCalls(),
+            catalogNames: new Set(catalog().map((s) => s.name)),
+            resolvedIds: resolvedIds(),
+        });
     }, ...(ngDevMode ? [{ debugName: "pending" }] : []));
+    function settleResult(id, result) {
+        // Mark as resolved first so pending() drops it immediately.
+        resolvedIds.update((s) => new Set(s).add(id));
+        // Cast rather than rely on discriminant narrowing: consumer apps that
+        // compile this source with `strictNullChecks: false` don't narrow the
+        // ClientToolResult union in a ternary.
+        const ok = result.ok;
+        const value = result.value;
+        const error = result.error;
+        // Write the outcome onto the LOCAL ToolCall (via the adapter's override
+        // layer). The client tool DID produce a result client-side, so this is
+        // semantically correct — and it freezes the transcript card: the mounted
+        // ask component re-renders with its own emitted value as props and can
+        // branch to a resolved/frozen state. Without this, the LOCAL tool call
+        // never gets a result (only the backend ToolMessage does) so the card
+        // stays interactive forever.
+        store.applyClientResult(id, {
+            result: ok ? value : { error },
+            ...(ok ? {} : { error, status: 'error' }),
+        });
+        const content = ok
+            ? safeStringify(value)
+            : `Error: ${error}`;
+        // The tool call belongs to a thread the user has already left, so there is
+        // nowhere valid to send this result: the current thread has no matching
+        // tool call, and the old thread is no longer the write target.
+        if (retiredToolCallIds.has(id)) {
+            console.warn(`Discarding client tool result for ${id}: its thread is no longer active.`);
+            return;
+        }
+        // Message shape: both `type` and `role` are set for compatibility —
+        // the LangGraph server's add_messages coercion reads `role` (Python
+        // side), while the bridge's local optimistic-message path reads `type`
+        // (via toMessage's normalizeMessageType). This mirrors the human-message
+        // shape used in buildSubmitUpdate (agent.fn.ts line 732).
+        toolMessageBuffer.push({
+            threadId: currentThreadIdFn?.() ?? null,
+            message: {
+                id: `client-tool-result-${id}`,
+                type: 'tool',
+                role: 'tool',
+                tool_call_id: id,
+                content,
+            },
+        });
+    }
+    /**
+     * Returns a non-destructive snapshot of entries still valid for the thread a
+     * write would land on right now. Captured entries remain staged, so
+     * overlapping operations may carry the same deterministic message IDs.
+     * Acknowledgment removes only the exact captured entries while the snapshot
+     * generation is current. An entry stamped for another thread is dropped
+     * rather than misdelivered.
+     *
+     * A null on either side means "thread not tracked yet" (no threadId option
+     * and no run has reported one); those are kept, since there is no evidence of
+     * a switch and dropping them would lose results on untracked transports.
+     */
+    function snapshotToolMessages() {
+        const current = currentThreadIdFn?.() ?? null;
+        for (let index = toolMessageBuffer.length - 1; index >= 0; index -= 1) {
+            const entry = toolMessageBuffer[index];
+            const stale = entry.threadId !== null && current !== null && entry.threadId !== current;
+            if (stale) {
+                console.warn(`Discarding a client tool result staged for thread ${entry.threadId}; ` +
+                    `the active thread is now ${current}.`);
+                toolMessageBuffer.splice(index, 1);
+            }
+        }
+        const generation = bufferGeneration;
+        const entries = [...toolMessageBuffer];
+        const messages = entries.map(({ message }) => ({ ...message }));
+        let acknowledged = false;
+        return {
+            generation,
+            messages,
+            acknowledge() {
+                if (acknowledged || generation !== bufferGeneration)
+                    return;
+                acknowledged = true;
+                for (const entry of entries) {
+                    const index = toolMessageBuffer.indexOf(entry);
+                    if (index !== -1)
+                        toolMessageBuffer.splice(index, 1);
+                }
+            },
+        };
+    }
+    /**
+     * Persist one snapshot. Only that snapshot is acknowledged after persistence
+     * succeeds; failure leaves its exact entries staged for retry or submit.
+     */
+    function runFlush() {
+        const batch = snapshotToolMessages();
+        if (batch.messages.length === 0)
+            return Promise.resolve();
+        if (!persistFn) {
+            return Promise.reject(new Error('Cannot flush staged client tool results. ' +
+                'Custom LangGraph transports using terminal client tools must implement updateState().'));
+        }
+        return persistFn(batch.messages)
+            .then(() => {
+            batch.acknowledge();
+        })
+            .catch((err) => {
+            console.warn(`Client tool flush failed; ${batch.messages.length} result(s) remain staged for the next run.`, err);
+        });
+    }
     const capability = {
         catalog,
         setCatalog(specs) {
             catalog.set([...specs]);
         },
         pending,
+        settle(id, result) {
+            settleResult(id, result);
+        },
+        snapshotToolMessages() {
+            return snapshotToolMessages();
+        },
+        /**
+         * Discard everything staged. Called when the active thread changes: a
+         * ToolMessage only makes sense against the thread whose AIMessage produced
+         * its tool_call_id, so carrying it over would poison the new thread.
+         */
+        clearStagedToolMessages() {
+            // Retire the outgoing thread's tool calls so a handler that settles after
+            // the switch is recognised as stale. Read the store BEFORE it resets —
+            // agent.fn.ts calls this ahead of manager.switchThread for that reason.
+            for (const toolCall of store.toolCalls())
+                retiredToolCallIds.add(toolCall.id);
+            toolMessageBuffer.length = 0;
+            // Invalidate every outstanding snapshot acknowledgment from the old thread.
+            bufferGeneration += 1;
+        },
+        flush() {
+            // Only this method owns the queue tail. Results settled after an active
+            // snapshot need their own write, and every caller must remain behind all
+            // callers already queued. The chain terminates when a fresh snapshot is
+            // empty.
+            const queued = flushInFlight
+                ? flushInFlight.then(() => runFlush(), () => runFlush())
+                : runFlush();
+            flushInFlight = queued;
+            const clearTail = () => {
+                if (flushInFlight === queued)
+                    flushInFlight = undefined;
+            };
+            // Both handlers return normally, so this bookkeeping branch cannot
+            // create an unhandled rejection when the caller observes `queued`.
+            void queued.then(clearTail, clearTail);
+            return queued;
+        },
         resolve(id, result) {
-            // Mark as resolved first so pending() drops it immediately.
-            resolvedIds.update((s) => new Set(s).add(id));
-            // Cast rather than rely on discriminant narrowing: consumer apps that
-            // compile this source with `strictNullChecks: false` don't narrow the
-            // ClientToolResult union in a ternary.
-            const ok = result.ok;
-            const value = result.value;
-            const error = result.error;
-            // Write the outcome onto the LOCAL ToolCall (via the adapter's override
-            // layer). The client tool DID produce a result client-side, so this is
-            // semantically correct — and it freezes the transcript card: the mounted
-            // ask component re-renders with its own emitted value as props and can
-            // branch to a resolved/frozen state. Without this, the LOCAL tool call
-            // never gets a result (only the backend ToolMessage does) so the card
-            // stays interactive forever.
-            store.applyClientResult(id, {
-                result: ok ? value : { error },
-                ...(ok ? {} : { error, status: 'error' }),
-            });
-            const content = ok
-                ? safeStringify(value)
-                : `Error: ${error}`;
-            // Issue a new run on the same thread. LangGraph's add_messages reducer
-            // appends the ToolMessage to the thread state. `client_tools` is
-            // included so the model sees the full tool catalog on the continuation.
-            //
-            // Message shape: both `type` and `role` are set for compatibility —
-            // the LangGraph server's add_messages coercion reads `role` (Python
-            // side), while the bridge's local optimistic-message path reads `type`
-            // (via toMessage's normalizeMessageType). This mirrors the human-message
-            // shape used in buildSubmitUpdate (agent.fn.ts line 732).
+            settleResult(id, result);
+            // Issue a new run with a non-destructive snapshot. The exact batch is
+            // acknowledged only when that continuation succeeds; failures retain it
+            // for retry. Stable IDs make overlap with flush or submit safe under
+            // LangGraph's add_messages reducer. `client_tools` keeps the full catalog
+            // visible to the continuation.
+            const batch = snapshotToolMessages();
             const toolPayload = {
-                messages: [{ type: 'tool', role: 'tool', tool_call_id: id, content }],
+                messages: batch.messages,
                 client_tools: catalog(),
             };
-            void submitFn(toolPayload);
+            void submitFn(toolPayload, undefined, batch).then((outcome) => {
+                if (outcome === 'success')
+                    batch.acknowledge();
+            });
         },
     };
     return capability;
@@ -2156,10 +2749,22 @@ function agent(options) {
     });
     const custom$ = new BehaviorSubject([]);
     const hasValue$ = new BehaviorSubject(false);
+    // Forward reference. The client-tools capability is built much further down
+    // (it needs `manager`, which needs these subjects), but the thread-change
+    // seam lives here. A holder keeps the binding itself a `const` while its
+    // member is filled in later.
+    const clientToolStaging = {};
+    let retryableToolMessageBatch;
     function resetDerivedThreadState() {
         status$.next(ResourceStatus.Idle);
         error$.next(undefined);
         hasValue$.next(false);
+        // Staged client-tool results belong to the thread whose AIMessage produced
+        // their tool_call_ids. Carrying them into a different thread would prepend
+        // a ToolMessage that matches no tool call there — a 400 on that turn.
+        // Runs BEFORE manager.switchThread resets the store, so the capability can
+        // still read the outgoing thread's tool calls.
+        clientToolStaging.clear?.();
     }
     // Track hasValue — becomes true once values or messages arrive
     values$.pipe(takeUntil$1(destroy$)).subscribe(v => {
@@ -2314,7 +2919,10 @@ function agent(options) {
     // `@let content = messageContent(message)` short-circuits — DOM never
     // updates per token. DOM stability is provided by `track message.id`
     // in chat-message-list, not by Message identity.
-    const messagesNeutral = computed(() => rawMessages().map((m) => toMessage(m, manager.getReasoningDurationMs)), ...(ngDevMode ? [{ debugName: "messagesNeutral" }] : []));
+    const messagesNeutral = computed(() => {
+        manager.deliveryRevision();
+        return rawMessages().map((m) => toMessage(m, manager.getReasoningDurationMs, manager.getMessageDelivery));
+    }, ...(ngDevMode ? [{ debugName: "messagesNeutral" }] : []));
     // Client-tool resolutions written client-side. The raw `toolCalls$` stream
     // (and thus `rawToolCalls`) only ever carries backend results — a resolved
     // client tool (`ask`/`view`) never receives a backend ToolMessage on its
@@ -2341,7 +2949,7 @@ function agent(options) {
     }, ...(ngDevMode ? [{ debugName: "interruptNeutral" }] : []));
     const subagentsNeutral = computed(() => {
         const out = new Map();
-        subagentsSig().forEach((sa, key) => out.set(key, toSubagent(sa)));
+        subagentsSig().forEach((sa, key) => out.set(key, toSubagent(sa, manager)));
         return out;
     }, ...(ngDevMode ? [{ debugName: "subagentsNeutral" }] : []));
     const historyNeutral = computed(() => historySig().map(toCheckpoint), ...(ngDevMode ? [{ debugName: "historyNeutral" }] : []));
@@ -2353,11 +2961,47 @@ function agent(options) {
     // follow-up runs (resolve) without going through the full submit() wrapper.
     // The catalog is injected into every outbound payload via mergeClientTools()
     // in the submit wrapper below and in the resolve path inside the capability.
-    const clientToolsCap = createClientToolsCapability((payload, opts) => manager.submit(payload, opts), {
+    //
+    // flush() needs a durable write that does NOT start a run. The bridge's
+    // updateState() silently no-ops when the transport has no updateState, so
+    // only supply a persist function when the effective transport supports it —
+    // an omitted transport means the bridge builds a FetchStreamTransport, which
+    // does. When persistFn is undefined, a non-empty flush() rejects while the
+    // results stay staged; an ordinary non-null submit remains their in-memory
+    // fallback path.
+    const canPersistToolMessages = !transport || typeof transport.updateState === 'function';
+    const clientToolsCap = createClientToolsCapability((payload, opts, batch) => {
+        retryableToolMessageBatch = batch;
+        return manager.submit(payload, opts);
+    }, {
         toolCalls: toolCallsNeutral,
         isLoading,
         applyClientResult: (id, patch) => clientResultOverrides.update((m) => new Map(m).set(id, patch)),
-    });
+    }, canPersistToolMessages
+        ? async (messages) => {
+            // Throw rather than let the bridge no-op: without a thread there is
+            // nothing to write to, and flush() must keep the buffer staged.
+            if (!manager.currentThreadId) {
+                throw new Error('no threadId for client tool flush');
+            }
+            // No asNode: add_messages appends the ToolMessages and the graph's
+            // resume point is left untouched, so no run is started.
+            await manager.updateState({ messages: [...messages] });
+        }
+        : undefined, 
+    // Stamps each staged result with the thread it was settled on, so a write
+    // can never land on a thread the user has since moved to.
+    () => manager.currentThreadId);
+    clientToolStaging.clear = () => {
+        retryableToolMessageBatch = undefined;
+        clientToolsCap.clearStagedToolMessages();
+    };
+    async function resubmitWithToolRecovery() {
+        const batch = retryableToolMessageBatch;
+        const outcome = await manager.resubmitLast();
+        if (outcome === 'success')
+            batch?.acknowledge();
+    }
     return {
         // ── Runtime-neutral surface (AgentWithHistory) ────────────────────────
         messages: messagesNeutral,
@@ -2371,7 +3015,7 @@ function agent(options) {
         events$,
         history: historyNeutral,
         messageCheckpoints: messageCheckpointsSig,
-        submit: (input, opts) => {
+        submit: async (input, opts) => {
             // Lifecycle: first submit with no existing threadId → thread create.
             if (lcThreadCreatedAt() === null && lastThreadId == null) {
                 lcThreadCreatedAt.set(Date.now());
@@ -2384,15 +3028,34 @@ function agent(options) {
             // Thread the client-tools catalog into every outbound payload so the
             // backend middleware can merge them into the model's tool list. Null
             // payloads (regenerate re-runs, command resumes) are left unchanged.
-            const payload = mergeClientTools(request.payload, clientToolsCap.catalog());
-            return manager.submit(payload, request.options);
+            //
+            // Snapshot results settled but not yet durable (flush unavailable or a
+            // prior flush failed) so they ride along without being forgotten. The
+            // exact snapshot is acknowledged only when this operation succeeds;
+            // overlaps may safely carry the same deterministic message IDs. A null
+            // payload cannot carry results, so it leaves staging unchanged.
+            const batch = request.payload === null || request.payload === undefined
+                ? undefined
+                : clientToolsCap.snapshotToolMessages();
+            const staged = batch?.messages ?? [];
+            const withStaged = staged.length > 0
+                ? mergeStagedToolMessages(request.payload, staged)
+                : request.payload;
+            const payload = mergeA2uiClientCapabilities(mergeClientTools(withStaged, clientToolsCap.catalog()), options.a2uiClientCapabilities);
+            const createsQueuedRun = request.options?.multitaskStrategy === 'enqueue' && isLoading();
+            if (!createsQueuedRun) {
+                retryableToolMessageBatch = batch;
+            }
+            const outcome = await manager.submit(payload, request.options);
+            if (outcome === 'success')
+                batch?.acknowledge();
         },
         stop: () => manager.stop(),
         retry: async () => {
             if (isLoading())
                 return; // no-op while a run is in flight
             error$.next(undefined); // clear the error before re-running
-            await manager.resubmitLast();
+            await resubmitWithToolRecovery();
         },
         clientTools: clientToolsCap,
         regenerate: async (assistantMessageIndex) => {
@@ -2449,6 +3112,7 @@ function agent(options) {
             // at `__start__`, this resumes at the entry node and produces a fresh
             // assistant message — the trailing user message becomes the active
             // prompt without being re-appended.
+            retryableToolMessageBatch = undefined;
             await manager.submit(null, undefined);
         },
         // ── Raw LangGraph signals ─────────────────────────────────────────────
@@ -2460,7 +3124,9 @@ function agent(options) {
         // ── Other LangGraph-specific fields ──────────────────────────────────
         value: value,
         hasValue: hasValueSig,
-        reload: () => manager.resubmitLast(),
+        reload: () => {
+            void resubmitWithToolRecovery();
+        },
         toolProgress: toolProgSig,
         queue: queueSig,
         activeSubagents,
@@ -2537,7 +3203,7 @@ function mapStatus(s) {
             return 'idle';
     }
 }
-function toMessage(m, getReasoningDurationMs) {
+function toMessage(m, getReasoningDurationMs, getDelivery) {
     const raw = m;
     const typeVal = typeof m._getType === 'function'
         ? m._getType()
@@ -2556,6 +3222,7 @@ function toMessage(m, getReasoningDurationMs) {
     const result = {
         id,
         role,
+        delivery: getDelivery?.(id) ?? staticDelivery(id),
         content: extractTextContent(m.content),
         toolCallId: raw['tool_call_id'],
         name: raw['name'],
@@ -2632,12 +3299,15 @@ function toInterrupt(ix) {
         resumable: true,
     };
 }
-function toSubagent(sa) {
+function toSubagent(sa, manager) {
     return {
         toolCallId: sa.toolCallId,
         name: sa.name,
         status: sa.status,
-        messages: computed(() => sa.messages().map((m) => toMessage(m))),
+        messages: computed(() => {
+            manager.deliveryRevision();
+            return sa.messages().map((m) => toMessage(m, undefined, () => manager.getSubagentMessageDelivery(sa.toolCallId, m)));
+        }),
         state: sa.values,
     };
 }
@@ -2756,6 +3426,7 @@ function agentFactory() {
         ...(config.telemetry !== undefined ? { telemetry: config.telemetry } : {}),
         ...(config.filterSubagentMessages !== undefined ? { filterSubagentMessages: config.filterSubagentMessages } : {}),
         ...(config.subagentToolNames !== undefined ? { subagentToolNames: config.subagentToolNames } : {}),
+        ...(config.transcriptNodeNames !== undefined ? { transcriptNodeNames: config.transcriptNodeNames } : {}),
     });
 }
 function isAgentRef(x) {