@tea-agent/loop-agent 0.39.0-beta.1 → 0.39.0-beta.11

package/dist/worker/console/static-src/operator-chat/chat-sse-events.js

@@ -3,6 +3,7 @@ import { humanGateCardFromEventPayload, mergeHumanGateCardState, } from "../../c
 import { mergeOperationCardState, operationFromEventPayload, } from "../../chat/operation-card.js";
 import { requestId } from "./format.js";
 import { parseAssistantContent } from "../../chat/assistant-content.js";
+import { upsertCompactionMessage } from "./compaction-message.js";
 /** Shared handler for a single parsed Chat SSE event (M1 reconnect).
  *
  * Used by BOTH the inline prompt POST SSE and the background reconnect
@@ -10,7 +11,9 @@ import { parseAssistantContent } from "../../chat/assistant-content.js";
  * original request would have. `assistantId` is the in-flight assistant
  * message id to patch for streaming text; reconnect creates one if none. */
 export function createChatSseEventApplier(deps) {
-    const { refs, onReconcile, setError, setInterview, setHumanGateCards, setArtifactCards, setStreaming, setTurnPhase = () => undefined, setDeferredTurn = () => undefined, setStreamingAssistantId, setUnread, setOperationCards, setUsage, setMessages, setToolCalls, } = deps;
+    const { refs, onReconcile, setError, setInterview, setHumanGateCards, setArtifactCards, setStreaming, setTurnPhase = () => undefined, setDeferredTurn = () => undefined, setDeferredTurns = () => undefined, setStreamingAssistantId, setUnread, setOperationCards, setUsage, onTelemetryRefresh, setMessages, setToolCalls, setPendingQuestion = () => undefined, setTodos = () => undefined, } = deps;
+    let queueOwner;
+    let queueRevision = -1;
     return (eventName, data, assistantId, options) => {
         if (options?.generation !== undefined &&
             refs.sessionGenerationRef.current !== options.generation)
@@ -42,6 +45,26 @@ export function createChatSseEventApplier(deps) {
         const payload = data.data && typeof data.data === "object"
             ? data.data
             : data;
+        if (eventName === "todo_updated" || eventName === "todo_cleared") {
+            const todos = Array.isArray(payload.todos) ? payload.todos : [];
+            setTodos(todos.filter((item) => Boolean(item) && typeof item === "object" && typeof item.content === "string" && (item.status === "pending" || item.status === "in_progress" || item.status === "completed")));
+            return;
+        }
+        if ((eventName === "question_requested" ||
+            eventName === "question_resolved" ||
+            eventName === "question_cancelled") &&
+            payload.question &&
+            typeof payload.question === "object") {
+            const question = payload.question;
+            if (typeof question.requestId === "string" &&
+                typeof question.sessionId === "string" &&
+                question.sessionId === refs.sessionRef.current?.sessionId) {
+                setPendingQuestion(eventName === "question_requested" && question.status === "pending"
+                    ? question
+                    : null);
+            }
+            return;
+        }
         const turnId = typeof data.turnId === "string" ? data.turnId : undefined;
         const eventSeq = typeof data.seq === "number" && Number.isFinite(data.seq)
             ? data.seq
@@ -51,13 +74,20 @@ export function createChatSseEventApplier(deps) {
             : Date.now();
         if (eventName === "queue_update") {
             const revision = typeof payload.revision === "number" ? payload.revision : -1;
-            setDeferredTurn((current) => {
-                if (current && revision < current.revision)
-                    return current;
-                return payload.deferredTurn && typeof payload.deferredTurn === "object"
-                    ? payload.deferredTurn
-                    : null;
-            });
+            const owner = refs.sessionRef.current?.sessionId;
+            if (owner !== queueOwner) {
+                queueOwner = owner;
+                queueRevision = -1;
+            }
+            if (revision < queueRevision)
+                return;
+            queueRevision = revision;
+            setDeferredTurn(payload.deferredTurn && typeof payload.deferredTurn === "object"
+                ? payload.deferredTurn
+                : null);
+            if (Array.isArray(payload.deferredTurns)) {
+                setDeferredTurns(payload.deferredTurns);
+            }
             return;
         }
         if (eventName === "user_message") {
@@ -84,6 +114,17 @@ export function createChatSseEventApplier(deps) {
             }
             return;
         }
+        if (eventName === "compact" ||
+            eventName === "compaction_start" ||
+            eventName === "compaction_end") {
+            setMessages((messages) => upsertCompactionMessage(messages, {
+                eventId: typeof data.eventId === "string" ? data.eventId : undefined,
+                kind: eventName,
+                at: new Date(eventAt).toISOString(),
+                data: payload,
+            }));
+            return;
+        }
         if (turnId &&
             (eventName === "agent_start" || eventName === "message_update") &&
             refs.settledTurnIdsRef.current.has(turnId)) {
@@ -186,6 +227,16 @@ export function createChatSseEventApplier(deps) {
                 refs.settledTurnIdsRef.current.delete(turnId);
                 refs.activeTurnIdRef.current = turnId;
             }
+            if (refs.stopRequestedRef.current &&
+                (!turnId ||
+                    turnId === refs.stoppingTurnIdRef.current ||
+                    turnId === refs.activeTurnIdRef.current)) {
+                refs.streamingRef.current = false;
+                setStreaming(false);
+                setTurnPhase("idle");
+                setStreamingAssistantId(null);
+                return;
+            }
             refs.streamingRef.current = true;
             setStreaming(true);
             setTurnPhase("running");
@@ -200,9 +251,22 @@ export function createChatSseEventApplier(deps) {
             // (M4.4). It must not prematurely close the visible turn.
             if (eventName === "agent_end")
                 return;
+            const pending = refs.pendingSubmissionRef.current;
+            if (pending && turnId && pending.acceptedTurnId === turnId) {
+                refs.releasedClientRequestIdsRef.current.add(pending.clientRequestId);
+                refs.pendingSubmissionRef.current = null;
+                refs.submitInFlightRef.current = false;
+            }
+            if (!turnId ||
+                turnId === refs.stoppingTurnIdRef.current ||
+                turnId === refs.activeTurnIdRef.current) {
+                refs.stoppingTurnIdRef.current = null;
+                refs.stopRequestedRef.current = false;
+            }
             if (turnId === refs.activeTurnIdRef.current)
                 refs.activeTurnIdRef.current = null;
             refs.streamingRef.current = false;
+            refs.assistantIdRef.current = null;
             setStreaming(false);
             setTurnPhase("idle");
             setStreamingAssistantId(null);
@@ -236,10 +300,21 @@ export function createChatSseEventApplier(deps) {
                     return true;
                 return assistantOwnsTools;
             }));
+            if (!replay)
+                onTelemetryRefresh?.();
             return;
         }
         if (eventName === "operation-ref" || eventName === "operation-status") {
             const operation = operationFromEventPayload(payload);
+            // R9: tombstones are session-scoped. The same operation may be linked
+            // to another session, but delayed frames cannot resurrect it here.
+            const currentSessionId = refs.sessionRef.current?.sessionId;
+            if (operation &&
+                currentSessionId &&
+                refs.unlinkedOperationIdsRef.current
+                    .get(currentSessionId)
+                    ?.has(operation.operationId))
+                return;
             if (operation) {
                 const toolCallId = typeof payload.toolCallId === "string"
                     ? payload.toolCallId
@@ -256,6 +331,23 @@ export function createChatSseEventApplier(deps) {
             }
             return;
         }
+        if (eventName === "operation-unlinked") {
+            // R8 AC-001/AC-R8-001: durable tombstone — the server persisted an
+            // operation-unlinked event that OVERSHADOWS any earlier operation-ref.
+            // Drop the card from the projection; replay/recovery can never
+            // resurrect it because the tombstone is appended after the ref in
+            // the same ring.
+            const operationId = typeof payload.operationId === "string" ? payload.operationId : "";
+            const currentSessionId = refs.sessionRef.current?.sessionId;
+            if (operationId && currentSessionId) {
+                const sessionTombstones = refs.unlinkedOperationIdsRef.current.get(currentSessionId) ??
+                    new Set();
+                sessionTombstones.add(operationId);
+                refs.unlinkedOperationIdsRef.current.set(currentSessionId, sessionTombstones);
+                setOperationCards((current) => current.filter((card) => card.operationId !== operationId));
+            }
+            return;
+        }
         if (eventName === "usage") {
             if (replay)
                 return;
@@ -451,6 +543,47 @@ export function createChatSseEventApplier(deps) {
             });
         }
         else if (eventName === "error") {
+            const candidate = payload.providerError && typeof payload.providerError === "object"
+                ? payload.providerError
+                : undefined;
+            if (candidate &&
+                typeof candidate.message === "string" &&
+                typeof candidate.raw === "string" &&
+                (candidate.category === "authentication" ||
+                    candidate.category === "context-overflow" ||
+                    candidate.category === "rate-limit" ||
+                    candidate.category === "provider")) {
+                // Session hydration already restores the durable card; retained replay
+                // must not add a second synthetic row on top of it.
+                if (replay)
+                    return;
+                const providerError = candidate;
+                const errorContent = parseAssistantContent(payload.content);
+                const id = turnId && eventSeq !== undefined
+                    ? `provider-error-${turnId}-${eventSeq}`
+                    : requestId("provider-error");
+                setMessages((messages) => {
+                    if (messages.some((message) => message.id === id))
+                        return messages;
+                    const activeAlreadyOwnsContent = messages.some((message) => message.id === resolvedAssistantId &&
+                        Boolean(message.content?.length));
+                    return [
+                        ...messages,
+                        {
+                            id,
+                            role: "assistant",
+                            kind: "provider-error",
+                            text: providerError.message,
+                            createdAt: eventAt,
+                            providerError,
+                            ...(!activeAlreadyOwnsContent && errorContent
+                                ? { content: errorContent }
+                                : {}),
+                        },
+                    ];
+                });
+                return;
+            }
             setError(typeof payload.message === "string" ? payload.message : "chat error");
         }
     };

package/dist/worker/console/static-src/operator-chat/compaction-message.js

@@ -0,0 +1,79 @@
+function finiteToken(value) {
+    return typeof value === "number" && Number.isFinite(value)
+        ? Math.max(0, Math.floor(value))
+        : undefined;
+}
+/** Project legacy final snapshots and lifecycle events to one stable row. */
+export function compactionMessageFromEvent(item) {
+    const data = item.data && typeof item.data === "object"
+        ? item.data
+        : {};
+    const eventId = typeof item.eventId === "string" ? item.eventId : undefined;
+    const compactionId = typeof data.compactionId === "string" && data.compactionId
+        ? data.compactionId
+        : eventId;
+    if (!compactionId)
+        return undefined;
+    const status = data.status === "running" ||
+        data.status === "completed" ||
+        data.status === "failed" ||
+        data.status === "aborted"
+        ? data.status
+        : "completed";
+    const reason = data.reason === "manual" ||
+        data.reason === "threshold" ||
+        data.reason === "overflow"
+        ? data.reason
+        : "manual";
+    const summary = typeof data.summary === "string" ? data.summary : "";
+    const errorMessage = typeof data.errorMessage === "string" ? data.errorMessage : undefined;
+    return {
+        id: `compaction-${compactionId}`,
+        role: "assistant",
+        kind: "compaction",
+        text: summary ||
+            errorMessage ||
+            (status === "completed"
+                ? "历史上下文已精简，关键决策与当前任务已保留。"
+                : ""),
+        createdAt: Date.parse(item.at ?? "") || Date.now(),
+        compaction: {
+            compactionId,
+            status,
+            reason,
+            willRetry: data.willRetry === true,
+            ...(finiteToken(data.tokensBefore) === undefined
+                ? {}
+                : { tokensBefore: finiteToken(data.tokensBefore) }),
+            ...(finiteToken(data.estimatedTokensAfter) === undefined
+                ? {}
+                : { estimatedTokensAfter: finiteToken(data.estimatedTokensAfter) }),
+            ...(typeof data.firstKeptEntryId === "string" && data.firstKeptEntryId
+                ? { firstKeptEntryId: data.firstKeptEntryId }
+                : {}),
+            ...(errorMessage ? { errorMessage } : {}),
+            ...(eventId ? { eventId } : {}),
+        },
+    };
+}
+export function upsertCompactionMessage(messages, item) {
+    const next = compactionMessageFromEvent(item);
+    if (!next)
+        return messages;
+    const existing = messages.find((message) => message.id === next.id);
+    const result = existing
+        ? messages.map((message) => message.id === next.id
+            ? {
+                ...message,
+                ...next,
+                createdAt: Math.min(message.createdAt, next.createdAt),
+                text: next.text || message.text,
+                compaction: {
+                    ...message.compaction,
+                    ...next.compaction,
+                },
+            }
+            : message)
+        : [...messages, next];
+    return result.sort((a, b) => a.createdAt - b.createdAt);
+}

package/dist/worker/console/static-src/operator-chat/details-dag-actions.js

@@ -0,0 +1,122 @@
+function resolveDagId(id) {
+    const value = typeof id === "function" ? id() : id;
+    return value?.trim() || null;
+}
+export function createDetailsDagActions(params) {
+    const fetchImpl = params.fetchFn ?? fetch;
+    let pending = false;
+    let error = null;
+    const completionListeners = new Set();
+    const emitState = () => params.onStateChange?.({ pending, error });
+    const emitCompletion = (outcome, identity, message) => {
+        for (const listener of [...completionListeners]) {
+            try {
+                listener(outcome, identity, message);
+            }
+            catch {
+                // a listener throwing must never break the request path
+            }
+        }
+    };
+    const run = (action, issue) => {
+        const sessionId = resolveDagId(params.sessionId);
+        const operationId = resolveDagId(params.operationId);
+        if (!sessionId || !operationId || pending)
+            return false;
+        const identity = {
+            action,
+            workspaceId: resolveDagId(params.workspaceId ?? null),
+            sessionId,
+            operationId,
+        };
+        pending = true;
+        error = null;
+        emitState();
+        void (async () => {
+            try {
+                const result = await issue(identity);
+                if (!result.ok) {
+                    error = result.message ?? `DAG 关联操作失败`;
+                    params.onFailure?.(identity, error);
+                    emitCompletion("failure", identity, error);
+                    return;
+                }
+                params.onSuccess?.(identity);
+                emitCompletion("success", identity);
+            }
+            catch (err) {
+                error = err instanceof Error ? err.message : String(err);
+                params.onFailure?.(identity, error);
+                emitCompletion("failure", identity, error);
+            }
+            finally {
+                pending = false;
+                emitState();
+            }
+        })();
+        return true;
+    };
+    return {
+        get pending() {
+            return pending;
+        },
+        get error() {
+            return error;
+        },
+        subscribe(listener) {
+            completionListeners.add(listener);
+            return () => completionListeners.delete(listener);
+        },
+        onAddDag() {
+            return run("add", async (identity) => {
+                // AC-002: session-scoped mutations carry the session's durable
+                // owning workspace so a global active-workspace switch can never
+                // retarget the link to another workspace's store.
+                const ownerQuery = identity.workspaceId
+                    ? `?workspaceId=${encodeURIComponent(identity.workspaceId)}`
+                    : "";
+                const res = await fetchImpl(`/api/operator/v1/chat/sessions/${encodeURIComponent(identity.sessionId)}/operation-links${ownerQuery}`, {
+                    method: "POST",
+                    credentials: "same-origin",
+                    headers: {
+                        "Content-Type": "application/json",
+                        "x-loop-console-confirmation": params.confirmationToken(),
+                    },
+                    body: JSON.stringify({ operationId: identity.operationId }),
+                });
+                if (!res.ok) {
+                    const body = (await res.json().catch(() => ({})));
+                    return {
+                        ok: false,
+                        message: body.error?.message ??
+                            `添加 DAG 关联失败（HTTP ${res.status}）`,
+                    };
+                }
+                return { ok: true };
+            });
+        },
+        onRemoveDag() {
+            return run("remove", async (identity) => {
+                const ownerQuery = identity.workspaceId
+                    ? `?workspaceId=${encodeURIComponent(identity.workspaceId)}`
+                    : "";
+                const res = await fetchImpl(`/api/operator/v1/chat/sessions/${encodeURIComponent(identity.sessionId)}/operation-links/${encodeURIComponent(identity.operationId)}${ownerQuery}`, {
+                    method: "DELETE",
+                    credentials: "same-origin",
+                    headers: {
+                        "x-loop-console-confirmation": params.confirmationToken(),
+                    },
+                });
+                if (!res.ok && res.status !== 404) {
+                    const body = (await res.json().catch(() => ({})));
+                    return {
+                        ok: false,
+                        message: body.error?.message ??
+                            `移除 DAG 关联失败（HTTP ${res.status}）`,
+                    };
+                }
+                return { ok: true };
+            });
+        },
+    };
+}

package/dist/worker/console/static-src/operator-chat/input-history.js

@@ -0,0 +1,76 @@
+/**
+ * Pure composer input-history state machine for Operator Chat.
+ *
+ * Extracted so ArrowUp/ArrowUp recall, unsent-draft retention and history
+ * recording can be unit-tested without mounting the React composer.
+ */
+export const INPUT_HISTORY_LIMIT = 100;
+export function createInputHistoryState() {
+    return { entries: [], index: -1, draft: "" };
+}
+/** Record one sent text and reset browsing back to the present draft. */
+export function recordInputHistoryEntry(state, text) {
+    if (!text.trim())
+        return state;
+    if (state.entries[state.entries.length - 1] === text) {
+        return state.index === -1 ? state : { ...state, index: -1, draft: "" };
+    }
+    const entries = [...state.entries, text].slice(-INPUT_HISTORY_LIMIT);
+    return { entries, index: -1, draft: "" };
+}
+/** Leave browse mode (manual typing edits the recalled text in place). */
+export function resetInputHistoryBrowsing(state) {
+    return state.index === -1 ? state : { ...state, index: -1 };
+}
+/**
+ * Recall an earlier input with the arrow keys (terminal-style).
+ *
+ * Up only engages while the caret sits on the first line and Down while it
+ * sits on the last line, so plain caret movement inside multi-line drafts is
+ * never swallowed. The unsent draft is stashed when browsing leaves the
+ * present position and restored when Down walks past the newest entry.
+ */
+export function navigateInputHistory(state, direction, context) {
+    const { text, caretStart, caretEnd } = context;
+    if (state.entries.length === 0)
+        return { handled: false };
+    if (direction === "up") {
+        if (text.slice(0, caretStart).includes("\n"))
+            return { handled: false };
+        if (state.index === -1) {
+            const index = state.entries.length - 1;
+            return {
+                handled: true,
+                state: { ...state, index, draft: text },
+                text: state.entries[index],
+            };
+        }
+        if (state.index === 0) {
+            // Already at the oldest entry: stay there (terminal behaviour).
+            return { handled: true, state, text: state.entries[0] };
+        }
+        const index = state.index - 1;
+        return {
+            handled: true,
+            state: { ...state, index },
+            text: state.entries[index],
+        };
+    }
+    if (state.index === -1)
+        return { handled: false };
+    if (text.slice(caretEnd).includes("\n"))
+        return { handled: false };
+    if (state.index >= state.entries.length - 1) {
+        return {
+            handled: true,
+            state: { ...state, index: -1 },
+            text: state.draft,
+        };
+    }
+    const index = state.index + 1;
+    return {
+        handled: true,
+        state: { ...state, index },
+        text: state.entries[index],
+    };
+}

package/dist/worker/console/static-src/operator-chat/mutation-gate.js

@@ -30,7 +30,7 @@ export function isStaleTokenFailure(code) {
 /** Chinese, actionable copy for mutation-gate rejections. */
 export function describeMutationGateFailure(code) {
     if (isStaleTokenFailure(code)) {
-        return "页面已过期（控制台已重启），请刷新页面（F5）后重试。";
+        return "页面凭证已失效（控制台可能已重启），请刷新页面（F5）后重试。";
     }
     if (code === "host-not-loopback") {
         return "请求主机校验失败：非回环绑定时要求 Host 头，请刷新页面或检查访问地址。";

package/dist/worker/console/static-src/operator-chat/refs.js

@@ -24,6 +24,7 @@ export function useChatRefs() {
     const abortPostedTurnIdsRef = useRef(new Set());
     const releasedClientRequestIdsRef = useRef(new Set());
     const usageResponseKeysRef = useRef(new Set());
+    const unlinkedOperationIdsRef = useRef(new Map());
     const isComposingRef = useRef(false);
     const compositionEndedAtRef = useRef(0);
     // Keep the bag identity stable: individual refs never change, so domain
@@ -53,6 +54,7 @@ export function useChatRefs() {
         abortPostedTurnIdsRef,
         releasedClientRequestIdsRef,
         usageResponseKeysRef,
+        unlinkedOperationIdsRef,
         isComposingRef,
         compositionEndedAtRef,
     }), [
@@ -80,6 +82,7 @@ export function useChatRefs() {
         abortPostedTurnIdsRef,
         releasedClientRequestIdsRef,
         usageResponseKeysRef,
+        unlinkedOperationIdsRef,
         isComposingRef,
         compositionEndedAtRef,
     ]);

package/dist/worker/console/static-src/operator-chat/runtime-selection-labels.js

@@ -0,0 +1,27 @@
+import { formatModelRef } from "../../chat/runtime-selection.js";
+const THINKING_SHORT_LABELS = {
+    auto: "Auto",
+    off: "Off",
+    minimal: "Minimal",
+    low: "Low",
+    medium: "Medium",
+    high: "High",
+    xhigh: "XHigh",
+    max: "Max",
+};
+export function formatThinkingSelectionLabel(selection, effective) {
+    const normalized = selection || "auto";
+    const label = THINKING_SHORT_LABELS[normalized] ?? normalized;
+    if (normalized !== "auto" || !effective)
+        return label;
+    return `${label} · ${THINKING_SHORT_LABELS[effective] ?? effective}`;
+}
+export function resolveModelDisplayName(models, activeModelRef) {
+    if (!activeModelRef)
+        return "选择模型";
+    const current = models.find((model) => formatModelRef(model.provider, model.id) === activeModelRef);
+    if (current)
+        return current.name?.trim() || current.id;
+    const slash = activeModelRef.indexOf("/");
+    return slash === -1 ? activeModelRef : activeModelRef.slice(slash + 1);
+}

package/dist/worker/console/static-src/operator-chat/spatial-overlay.js

@@ -1,6 +1,6 @@
 /**
  * Mutual-exclusion state for large spatial overlays in Operator Chat.
- * At most one of: sidebar drawer, process, runtime context, tools, activity.
+ * At most one of: sidebar drawer, process, runtime context, tools.
  * Small composer menus (model/thinking) are out of scope.
  */
 export function createSpatialOverlayState(active = "none") {
@@ -33,6 +33,5 @@ export function spatialOverlayFlags(state) {
         processOpen: state.active === "process",
         runtimeContextOpen: state.active === "runtime-context",
         toolsOpen: state.active === "tools",
-        activityOpen: state.active === "activity",
     };
 }

package/dist/worker/console/static-src/operator-chat/turn-stream-controller.js

@@ -38,6 +38,15 @@ export function turnPhaseFromOwnership(bag) {
         return "running";
     return "idle";
 }
+/**
+ * DSH-style visual projection: Stop immediately releases the composer while
+ * the ownership projection remains `stopping` for deferred-send routing and
+ * duplicate-Turn prevention.
+ */
+export function visualTurnPhaseFromOwnership(bag) {
+    const phase = turnPhaseFromOwnership(bag);
+    return phase === "stopping" ? "idle" : phase;
+}
 export function createTurnOwnershipBag(seed) {
     return {
         submitInFlight: false,
@@ -394,6 +403,9 @@ export function classifyAbortResponse(input) {
         isTerminalTurnState(terminalState)) {
         return { action: "terminal-idle", turnId: input.turnId };
     }
+    if (input.httpOk && input.body.accepted === true) {
+        return { action: "abort-accepted-background" };
+    }
     if (input.body.error?.code === "TURN_ABORT_PENDING") {
         return { action: "abort-pending-notice" };
     }
@@ -416,6 +428,10 @@ export function applyAbortDecision(bag, decision, notice, opts) {
         if (!current)
             return;
         bag.settledTurnIds.add(decision.turnId);
+        if (bag.pendingSubmission) {
+            releaseSubmitOwnership(bag, bag.pendingSubmission.clientRequestId);
+        }
+        clearStopRequested(bag);
         bag.streaming = false;
         bag.activeTurnId = null;
         bag.assistantId = null;
@@ -423,6 +439,11 @@ export function applyAbortDecision(bag, decision, notice, opts) {
         opts?.markIdle?.();
         return;
     }
+    if (decision.action === "abort-accepted-background") {
+        // Visual idle is projected by the caller. Hidden ownership deliberately
+        // remains stopping until terminal SSE or /state evidence releases it.
+        return;
+    }
     if (decision.action === "abort-pending-notice") {
         // Non-fatal; keep busy.
         notice.showNotice(ABORT_PENDING_NOTICE);
@@ -436,6 +457,10 @@ export function applyAbortDecision(bag, decision, notice, opts) {
                 bag.settledTurnIds.add(bag.stoppingTurnId);
             }
             bag.streaming = false;
+            if (bag.pendingSubmission) {
+                releaseSubmitOwnership(bag, bag.pendingSubmission.clientRequestId);
+            }
+            clearStopRequested(bag);
             bag.activeTurnId = null;
             bag.assistantId = null;
             bag.stoppingTurnId = null;