veryfront 0.1.1208 → 0.1.1209

package/esm/src/agent/runtime/chat-stream-handler.js

@@ -297,14 +297,80 @@ export function processStreamInternal(resultOrSource, state, controller, encoder
             ? new Set(callbacks.availableToolNames)
             : null;
         const suppressedToolCallIds = new Set();
+        // Provider-executed calls whose input completed but whose result has not
+        // arrived yet. While any is outstanding the local-tool commit grace must not
+        // truncate the stream: the provider result can arrive after a separate HTTP
+        // continuation.
+        const pendingProviderExecutedToolCallIds = new Set();
         const isUnavailableTool = (toolName) => availableToolNames !== null && !availableToolNames.has(toolName);
         const suppressToolCall = (toolCallId, toolName) => {
             if (!toolCallId || suppressedToolCallIds.has(toolCallId)) {
                 return;
             }
             suppressedToolCallIds.add(toolCallId);
+            pendingProviderExecutedToolCallIds.delete(toolCallId);
             state.suppressedToolCalls.push({ id: toolCallId, name: toolName });
         };
+        /**
+         * Record a provider-executed call as outstanding.
+         *
+         * Only call this where the tool call reaches `inputAvailable: true`. That
+         * keeps the invariant `id ∈ pending ⟹ toolCalls.get(id).inputAvailable`, so
+         * `finalizeUnresolvedProviderToolCalls` always drains the set. Tracking a
+         * call whose input never completed (or one already suppressed, which no
+         * later part will resolve) would leave an id nothing removes, disabling the
+         * local-tool commit grace for the rest of the step.
+         */
+        const trackProviderExecutedToolCall = (toolCallId, providerExecuted) => {
+            if (!toolCallId || providerExecuted !== true || suppressedToolCallIds.has(toolCallId)) {
+                return;
+            }
+            pendingProviderExecutedToolCallIds.add(toolCallId);
+        };
+        /**
+         * Close out provider-executed calls the provider never resolved.
+         *
+         * Without a terminal event the call stays `input-available` forever: the UI
+         * card spins and persistence judges the part incomplete and drops it.
+         * Emitting an error is honest: there genuinely is no content.
+         *
+         * The synthesized event is stream-only on purpose. Recording it in
+         * `state.toolResults` would make the runtime believe the provider answered:
+         * `shouldContinueAfterStreamStep()` would flip to true and bill another
+         * model call per unresolved call, and the fabricated result would be
+         * persisted into model history. The runtime keeps its unchanged view (no
+         * result arrived) while the client still gets a terminal part.
+         */
+        const finalizeUnresolvedProviderToolCalls = () => {
+            if (pendingProviderExecutedToolCallIds.size === 0) {
+                return;
+            }
+            // A preliminary result is recorded like any other, so it must not count as
+            // proof the provider answered. Reading it as terminal here would skip the
+            // synthesized event and strand the call, which is the failure this whole
+            // finalizer exists to close.
+            const terminalToolCallIds = new Set(state.toolResults
+                .filter((result) => result.preliminary !== true)
+                .map((result) => result.toolCallId));
+            for (const toolCall of state.toolCalls.values()) {
+                if (!pendingProviderExecutedToolCallIds.has(toolCall.id))
+                    continue;
+                if (toolCall.providerExecuted !== true || toolCall.inputAvailable !== true)
+                    continue;
+                if (terminalToolCallIds.has(toolCall.id))
+                    continue;
+                if (suppressedToolCallIds.has(toolCall.id))
+                    continue;
+                sendSSE(controller, encoder, {
+                    type: "tool-output-error",
+                    toolCallId: toolCall.id,
+                    errorText: `Provider-executed tool "${toolCall.name}" returned no result before the model turn ended.`,
+                    providerExecuted: true,
+                    ...(toolCall.dynamic ? { dynamic: true } : {}),
+                });
+            }
+            pendingProviderExecutedToolCallIds.clear();
+        };
         const resolveProviderExecuted = (toolName, providerExecuted) => providerExecuted ?? (providerExecutedToolNames.has(toolName) ? true : undefined);
         const normalizeReasoningId = (part) => typeof part.id === "string" && part.id.length > 0 ? part.id : "reasoning";
         const openTextSegment = () => {
@@ -476,479 +542,531 @@ export function processStreamInternal(resultOrSource, state, controller, encoder
             });
         };
         throwIfAborted(abortSignal);
+        // Terminal events for unresolved provider-executed calls must reach the
+        // client even when the stream aborts or throws, so the finalizer runs in a
+        // `finally`. It runs after the shadow compare so a synthesized event can
+        // never perturb the legacy-vs-reducer snapshot the rollout gate reads.
         const streamIterator = result.fullStream[Symbol.asyncIterator]();
-        while (true) {
-            const shouldStopForIdleOutput = !hasActiveLocalToolInput &&
-                !shouldStopForCommittedLocalToolCall && hasStreamOutput(state);
-            const shouldStopForIdleStart = !hasActiveLocalToolInput &&
-                !shouldStopForCommittedLocalToolCall && !hasStreamOutput(state);
-            const next = hasActiveLocalToolInput
-                ? await readNextStreamPartWithTimeout(streamIterator, state, callbacks?.localToolInputIdleTimeoutMs ?? LOCAL_TOOL_INPUT_IDLE_MS)
-                : shouldStopForCommittedLocalToolCall
-                    ? await readNextStreamPartWithTimeout(streamIterator, state, LOCAL_TOOL_COMMIT_GRACE_MS)
-                    : shouldStopForIdleOutput
-                        ? await readNextStreamPartWithTimeout(streamIterator, state, callbacks?.streamIdleTimeoutMs ?? STREAM_OUTPUT_IDLE_MS)
-                        : shouldStopForIdleStart
-                            ? await readNextStreamPartWithTimeout(streamIterator, state, callbacks?.streamIdleTimeoutMs ?? STREAM_START_IDLE_MS)
-                            : await readNextStreamPart(streamIterator, state);
-            if (next === "timeout") {
-                state.finishReason ??= shouldStopForIdleOutput || shouldStopForIdleStart
-                    ? "stop"
-                    : "tool-calls";
-                requestStreamIteratorReturn(streamIterator);
-                break;
-            }
-            if (next.done) {
-                break;
-            }
-            const part = next.value;
-            throwIfAborted(abortSignal);
-            try {
-                shadowLifecycle?.observePart(part);
-            }
-            catch {
-                shadowLifecycleFailed = true;
-                shadowLifecycle = null;
-            }
-            eventCount++;
-            if (!isRecord(part) || typeof part.type !== "string") {
-                continue;
-            }
-            const typedPart = part;
-            if (typedPart.type.startsWith("data-")) {
-                sendSSE(controller, encoder, {
-                    type: typedPart.type,
-                    data: "data" in typedPart ? typedPart.data : undefined,
-                });
-                continue;
+        let streamIteratorReturned = false;
+        /** Release the upstream iterator exactly once, whichever exit is taken. */
+        const returnStreamIteratorOnce = () => {
+            if (streamIteratorReturned) {
+                return;
             }
-            switch (typedPart.type) {
-                case "text-delta": {
-                    closeReasoningSegment();
-                    openTextSegment();
-                    state.accumulatedText += typedPart.text;
-                    sendSSE(controller, encoder, {
-                        type: "text-delta",
-                        id: textPartId,
-                        delta: typedPart.text,
-                    });
-                    callbacks?.onChunk?.(typedPart.text);
+            streamIteratorReturned = true;
+            requestStreamIteratorReturn(streamIterator);
+        };
+        try {
+            while (true) {
+                // A pending provider-executed call outranks the local commit grace: its
+                // result can arrive on a later provider continuation request. This picks
+                // a longer timeout only. It must not change what a timeout *means*, so
+                // the finish-reason classification below stays on the ungated flag.
+                const shouldStopForCommittedLocalToolCallNow = shouldStopForCommittedLocalToolCall &&
+                    pendingProviderExecutedToolCallIds.size === 0;
+                const shouldStopForIdleOutput = !hasActiveLocalToolInput &&
+                    !shouldStopForCommittedLocalToolCallNow && hasStreamOutput(state);
+                const shouldStopForIdleStart = !hasActiveLocalToolInput &&
+                    !shouldStopForCommittedLocalToolCallNow && !hasStreamOutput(state);
+                // A timeout means "the turn is over" only when nothing local is in flight
+                // and nothing local was committed. Classifying a committed local tool call
+                // as "stop" makes shouldContinueAfterStreamStep() bail, so the tool never
+                // executes and its card is stranded at input-available.
+                const wouldTimeOutIdle = !hasActiveLocalToolInput && !shouldStopForCommittedLocalToolCall;
+                const next = hasActiveLocalToolInput
+                    ? await readNextStreamPartWithTimeout(streamIterator, state, callbacks?.localToolInputIdleTimeoutMs ?? LOCAL_TOOL_INPUT_IDLE_MS)
+                    : shouldStopForCommittedLocalToolCallNow
+                        ? await readNextStreamPartWithTimeout(streamIterator, state, callbacks?.localToolCommitGraceMs ?? LOCAL_TOOL_COMMIT_GRACE_MS)
+                        : shouldStopForIdleOutput
+                            ? await readNextStreamPartWithTimeout(streamIterator, state, callbacks?.streamIdleTimeoutMs ?? STREAM_OUTPUT_IDLE_MS)
+                            : shouldStopForIdleStart
+                                ? await readNextStreamPartWithTimeout(streamIterator, state, callbacks?.streamIdleTimeoutMs ?? STREAM_START_IDLE_MS)
+                                : await readNextStreamPart(streamIterator, state);
+                if (next === "timeout") {
+                    state.finishReason ??= wouldTimeOutIdle ? "stop" : "tool-calls";
+                    returnStreamIteratorOnce();
                     break;
                 }
-                case "reasoning-start": {
-                    closeTextSegment();
-                    openReasoningSegment(normalizeReasoningId(typedPart));
+                if (next.done) {
                     break;
                 }
-                case "reasoning-delta": {
-                    closeTextSegment();
-                    const reasoningId = normalizeReasoningId(typedPart);
-                    openReasoningSegment(reasoningId);
-                    const reasoningPart = reasoningParts.get(reasoningId);
-                    if (reasoningPart) {
-                        reasoningPart.text += typeof typedPart.delta === "string" ? typedPart.delta : "";
-                    }
-                    sendSSE(controller, encoder, {
-                        type: "reasoning-delta",
-                        id: reasoningId,
-                        delta: typeof typedPart.delta === "string" ? typedPart.delta : "",
-                    });
-                    break;
+                const part = next.value;
+                throwIfAborted(abortSignal);
+                try {
+                    shadowLifecycle?.observePart(part);
                 }
-                case "reasoning-end": {
-                    closeTextSegment();
-                    if (activeReasoningId === null) {
-                        activeReasoningId = normalizeReasoningId(typedPart);
-                    }
-                    const reasoningPart = reasoningParts.get(activeReasoningId);
-                    if (reasoningPart) {
-                        if (typeof typedPart.signature === "string") {
-                            reasoningPart.signature = typedPart.signature;
-                        }
-                        if (typeof typedPart.redactedData === "string") {
-                            reasoningPart.redactedData = typedPart.redactedData;
-                        }
-                    }
-                    closeReasoningSegment();
-                    break;
+                catch {
+                    shadowLifecycleFailed = true;
+                    shadowLifecycle = null;
                 }
-                case "tool-input-start": {
-                    closeTextSegment();
-                    closeReasoningSegment();
-                    shouldStopForCommittedLocalToolCall = false;
-                    const toolId = typedPart.id;
-                    if (isUnavailableTool(typedPart.toolName)) {
-                        suppressToolCall(toolId, typedPart.toolName);
-                        hasActiveLocalToolInput = false;
-                        break;
-                    }
-                    const providerExecuted = resolveProviderExecuted(typedPart.toolName, typedPart.providerExecuted);
-                    hasActiveLocalToolInput = providerExecuted !== true;
-                    state.toolCalls.set(toolId, {
-                        id: toolId,
-                        name: typedPart.toolName,
-                        arguments: "",
-                        inputAvailable: false,
-                        providerExecuted,
-                        dynamic: typedPart.dynamic,
-                        inputDeltas: [],
-                        inputAnnounced: false,
+                eventCount++;
+                if (!isRecord(part) || typeof part.type !== "string") {
+                    continue;
+                }
+                const typedPart = part;
+                if (typedPart.type.startsWith("data-")) {
+                    sendSSE(controller, encoder, {
+                        type: typedPart.type,
+                        data: "data" in typedPart ? typedPart.data : undefined,
                     });
-                    break;
+                    continue;
                 }
-                case "tool-input-delta": {
-                    closeReasoningSegment();
-                    const toolId = typedPart.id;
-                    if (suppressedToolCallIds.has(toolId))
-                        break;
-                    const tc = state.toolCalls.get(toolId);
-                    if (!tc)
+                switch (typedPart.type) {
+                    case "text-delta": {
+                        closeReasoningSegment();
+                        openTextSegment();
+                        state.accumulatedText += typedPart.text;
+                        sendSSE(controller, encoder, {
+                            type: "text-delta",
+                            id: textPartId,
+                            delta: typedPart.text,
+                        });
+                        callbacks?.onChunk?.(typedPart.text);
                         break;
-                    tc.arguments = mergeToolInputDelta(tc.arguments, typedPart.delta);
-                    tc.inputDeltas ??= [];
-                    tc.inputDeltas.push(typedPart.delta);
-                    break;
-                }
-                case "tool-input-end": {
-                    closeTextSegment();
-                    closeReasoningSegment();
-                    const toolId = typedPart.id;
-                    if (suppressedToolCallIds.has(toolId)) {
-                        hasActiveLocalToolInput = false;
+                    }
+                    case "reasoning-start": {
+                        closeTextSegment();
+                        openReasoningSegment(normalizeReasoningId(typedPart));
                         break;
                     }
-                    const tc = state.toolCalls.get(toolId);
-                    if (!tc)
+                    case "reasoning-delta": {
+                        closeTextSegment();
+                        const reasoningId = normalizeReasoningId(typedPart);
+                        openReasoningSegment(reasoningId);
+                        const reasoningPart = reasoningParts.get(reasoningId);
+                        if (reasoningPart) {
+                            reasoningPart.text += typeof typedPart.delta === "string" ? typedPart.delta : "";
+                        }
+                        sendSSE(controller, encoder, {
+                            type: "reasoning-delta",
+                            id: reasoningId,
+                            delta: typeof typedPart.delta === "string" ? typedPart.delta : "",
+                        });
                         break;
-                    tc.inputAvailable = true;
-                    hasActiveLocalToolInput = false;
-                    const dynamic = tc.dynamic ?? isDynamicTool(tc.name);
-                    if (dynamic) {
-                        tc.dynamic = true;
                     }
-                    announceToolInputStart(tc);
-                    sendSSE(controller, encoder, {
-                        type: "tool-input-available",
-                        toolCallId: toolId,
-                        toolName: tc.name,
-                        input: parseToolInputObject(tc.arguments),
-                        ...(tc.providerExecuted !== undefined ? { providerExecuted: tc.providerExecuted } : {}),
-                        ...(dynamic ? { dynamic: true } : {}),
-                    });
-                    if (tc.providerExecuted !== true) {
-                        shouldStopForCommittedLocalToolCall = true;
+                    case "reasoning-end": {
+                        closeTextSegment();
+                        if (activeReasoningId === null) {
+                            activeReasoningId = normalizeReasoningId(typedPart);
+                        }
+                        const reasoningPart = reasoningParts.get(activeReasoningId);
+                        if (reasoningPart) {
+                            if (typeof typedPart.signature === "string") {
+                                reasoningPart.signature = typedPart.signature;
+                            }
+                            if (typeof typedPart.redactedData === "string") {
+                                reasoningPart.redactedData = typedPart.redactedData;
+                            }
+                        }
+                        closeReasoningSegment();
+                        break;
                     }
-                    break;
-                }
-                case "tool-input-available": {
-                    closeTextSegment();
-                    closeReasoningSegment();
-                    const toolId = typedPart.toolCallId ?? typedPart.id;
-                    if (!toolId) {
+                    case "tool-input-start": {
+                        closeTextSegment();
+                        closeReasoningSegment();
+                        shouldStopForCommittedLocalToolCall = false;
+                        const toolId = typedPart.id;
+                        // A restart drops the call back to `inputAvailable: false`, so an
+                        // earlier tracking of the same id no longer holds. Leaving it pending
+                        // would disable the local commit grace for the rest of the step.
+                        pendingProviderExecutedToolCallIds.delete(toolId);
+                        if (isUnavailableTool(typedPart.toolName)) {
+                            suppressToolCall(toolId, typedPart.toolName);
+                            hasActiveLocalToolInput = false;
+                            break;
+                        }
+                        const providerExecuted = resolveProviderExecuted(typedPart.toolName, typedPart.providerExecuted);
+                        hasActiveLocalToolInput = providerExecuted !== true;
+                        state.toolCalls.set(toolId, {
+                            id: toolId,
+                            name: typedPart.toolName,
+                            arguments: "",
+                            inputAvailable: false,
+                            providerExecuted,
+                            dynamic: typedPart.dynamic,
+                            inputDeltas: [],
+                            inputAnnounced: false,
+                        });
                         break;
                     }
-                    if (isUnavailableTool(typedPart.toolName)) {
-                        suppressToolCall(toolId, typedPart.toolName);
-                        hasActiveLocalToolInput = false;
+                    case "tool-input-delta": {
+                        closeReasoningSegment();
+                        const toolId = typedPart.id;
+                        if (suppressedToolCallIds.has(toolId))
+                            break;
+                        const tc = state.toolCalls.get(toolId);
+                        if (!tc)
+                            break;
+                        tc.arguments = mergeToolInputDelta(tc.arguments, typedPart.delta);
+                        tc.inputDeltas ??= [];
+                        tc.inputDeltas.push(typedPart.delta);
                         break;
                     }
-                    const providerExecuted = resolveProviderExecuted(typedPart.toolName, typedPart.providerExecuted);
-                    hasActiveLocalToolInput = false;
-                    const inputStr = normalizeToolInputString(typedPart.input);
-                    const previous = state.toolCalls.get(toolId);
-                    const previousArguments = previous?.arguments ?? "";
-                    const resolvedArguments = mergeToolCallInput(previousArguments, inputStr);
-                    const wasInputAvailable = previous?.inputAvailable === true;
-                    const dynamic = typedPart.dynamic ?? isDynamicTool(typedPart.toolName);
-                    state.toolCalls.set(toolId, {
-                        id: toolId,
-                        name: typedPart.toolName,
-                        arguments: resolvedArguments,
-                        inputAvailable: true,
-                        providerExecuted,
-                        dynamic,
-                    });
-                    if (!wasInputAvailable) {
+                    case "tool-input-end": {
+                        closeTextSegment();
+                        closeReasoningSegment();
+                        const toolId = typedPart.id;
+                        if (suppressedToolCallIds.has(toolId)) {
+                            hasActiveLocalToolInput = false;
+                            break;
+                        }
+                        const tc = state.toolCalls.get(toolId);
+                        if (!tc)
+                            break;
+                        tc.inputAvailable = true;
+                        trackProviderExecutedToolCall(toolId, tc.providerExecuted);
+                        hasActiveLocalToolInput = false;
+                        const dynamic = tc.dynamic ?? isDynamicTool(tc.name);
+                        if (dynamic) {
+                            tc.dynamic = true;
+                        }
+                        announceToolInputStart(tc);
                         sendSSE(controller, encoder, {
                             type: "tool-input-available",
                             toolCallId: toolId,
-                            toolName: typedPart.toolName,
-                            input: parseToolInputObject(resolvedArguments),
-                            ...(providerExecuted !== undefined ? { providerExecuted } : {}),
+                            toolName: tc.name,
+                            input: parseToolInputObject(tc.arguments),
+                            ...(tc.providerExecuted !== undefined
+                                ? { providerExecuted: tc.providerExecuted }
+                                : {}),
                             ...(dynamic ? { dynamic: true } : {}),
                         });
+                        if (tc.providerExecuted !== true) {
+                            shouldStopForCommittedLocalToolCall = true;
+                        }
+                        break;
                     }
-                    if (providerExecuted !== true) {
-                        shouldStopForCommittedLocalToolCall = true;
+                    case "tool-input-available": {
+                        closeTextSegment();
+                        closeReasoningSegment();
+                        const toolId = typedPart.toolCallId ?? typedPart.id;
+                        if (!toolId) {
+                            break;
+                        }
+                        if (isUnavailableTool(typedPart.toolName)) {
+                            suppressToolCall(toolId, typedPart.toolName);
+                            hasActiveLocalToolInput = false;
+                            break;
+                        }
+                        const providerExecuted = resolveProviderExecuted(typedPart.toolName, typedPart.providerExecuted);
+                        hasActiveLocalToolInput = false;
+                        trackProviderExecutedToolCall(toolId, providerExecuted);
+                        const inputStr = normalizeToolInputString(typedPart.input);
+                        const previous = state.toolCalls.get(toolId);
+                        const previousArguments = previous?.arguments ?? "";
+                        const resolvedArguments = mergeToolCallInput(previousArguments, inputStr);
+                        const wasInputAvailable = previous?.inputAvailable === true;
+                        const dynamic = typedPart.dynamic ?? isDynamicTool(typedPart.toolName);
+                        state.toolCalls.set(toolId, {
+                            id: toolId,
+                            name: typedPart.toolName,
+                            arguments: resolvedArguments,
+                            inputAvailable: true,
+                            providerExecuted,
+                            dynamic,
+                        });
+                        if (!wasInputAvailable) {
+                            sendSSE(controller, encoder, {
+                                type: "tool-input-available",
+                                toolCallId: toolId,
+                                toolName: typedPart.toolName,
+                                input: parseToolInputObject(resolvedArguments),
+                                ...(providerExecuted !== undefined ? { providerExecuted } : {}),
+                                ...(dynamic ? { dynamic: true } : {}),
+                            });
+                        }
+                        if (providerExecuted !== true) {
+                            shouldStopForCommittedLocalToolCall = true;
+                        }
+                        break;
                     }
-                    break;
-                }
-                case "tool-call": {
-                    closeTextSegment();
-                    closeReasoningSegment();
-                    // tool-call fires when the full tool call is available
-                    const toolId = typedPart.toolCallId;
-                    if (isUnavailableTool(typedPart.toolName)) {
-                        suppressToolCall(toolId, typedPart.toolName);
+                    case "tool-call": {
+                        closeTextSegment();
+                        closeReasoningSegment();
+                        // tool-call fires when the full tool call is available
+                        const toolId = typedPart.toolCallId;
+                        if (isUnavailableTool(typedPart.toolName)) {
+                            suppressToolCall(toolId, typedPart.toolName);
+                            hasActiveLocalToolInput = false;
+                            break;
+                        }
+                        const providerExecuted = resolveProviderExecuted(typedPart.toolName, typedPart.providerExecuted);
                         hasActiveLocalToolInput = false;
+                        trackProviderExecutedToolCall(toolId, providerExecuted);
+                        const inputStr = normalizeToolInputString(typedPart.input);
+                        const previous = state.toolCalls.get(toolId);
+                        const previousArguments = previous?.arguments ?? "";
+                        const resolvedArguments = mergeToolCallInput(previousArguments, inputStr);
+                        const wasInputAvailable = previous?.inputAvailable === true;
+                        const toolCall = {
+                            id: toolId,
+                            name: typedPart.toolName,
+                            arguments: resolvedArguments,
+                            inputDeltas: previous?.inputDeltas ?? [],
+                            inputAnnounced: previous?.inputAnnounced ?? false,
+                            inputAvailable: true,
+                            providerExecuted,
+                            dynamic: typedPart.dynamic,
+                        };
+                        state.toolCalls.set(toolId, toolCall);
+                        const dynamic = isDynamicTool(typedPart.toolName);
+                        const inputObj = parseToolInputObject(typedPart.input);
+                        announceToolInputStart(toolCall);
+                        if (!wasInputAvailable) {
+                            sendSSE(controller, encoder, {
+                                type: "tool-input-available",
+                                toolCallId: toolId,
+                                toolName: typedPart.toolName,
+                                input: inputObj,
+                                ...(providerExecuted !== undefined ? { providerExecuted } : {}),
+                                ...(dynamic ? { dynamic: true } : {}),
+                            });
+                        }
+                        if (providerExecuted !== true) {
+                            shouldStopForCommittedLocalToolCall = true;
+                        }
                         break;
                     }
-                    const providerExecuted = resolveProviderExecuted(typedPart.toolName, typedPart.providerExecuted);
-                    hasActiveLocalToolInput = false;
-                    const inputStr = normalizeToolInputString(typedPart.input);
-                    const previous = state.toolCalls.get(toolId);
-                    const previousArguments = previous?.arguments ?? "";
-                    const resolvedArguments = mergeToolCallInput(previousArguments, inputStr);
-                    const wasInputAvailable = previous?.inputAvailable === true;
-                    const toolCall = {
-                        id: toolId,
-                        name: typedPart.toolName,
-                        arguments: resolvedArguments,
-                        inputDeltas: previous?.inputDeltas ?? [],
-                        inputAnnounced: previous?.inputAnnounced ?? false,
-                        inputAvailable: true,
-                        providerExecuted,
-                        dynamic: typedPart.dynamic,
-                    };
-                    state.toolCalls.set(toolId, toolCall);
-                    const dynamic = isDynamicTool(typedPart.toolName);
-                    const inputObj = parseToolInputObject(typedPart.input);
-                    announceToolInputStart(toolCall);
-                    if (!wasInputAvailable) {
-                        sendSSE(controller, encoder, {
-                            type: "tool-input-available",
-                            toolCallId: toolId,
+                    case "tool-result": {
+                        closeTextSegment();
+                        closeReasoningSegment();
+                        if (suppressedToolCallIds.has(typedPart.toolCallId) ||
+                            isUnavailableTool(typedPart.toolName)) {
+                            suppressToolCall(typedPart.toolCallId, typedPart.toolName);
+                            break;
+                        }
+                        const providerExecuted = resolveProviderExecuted(typedPart.toolName, typedPart.providerExecuted);
+                        // A preliminary result is not terminal: the provider is still
+                        // working. Releasing the call here would re-arm the local commit
+                        // grace and truncate the stream before the final result arrives,
+                        // which is the failure this tracking exists to prevent.
+                        if (typedPart.preliminary !== true) {
+                            pendingProviderExecutedToolCallIds.delete(typedPart.toolCallId);
+                        }
+                        ensureToolLifecycle({
+                            toolCallId: typedPart.toolCallId,
+                            toolName: typedPart.toolName,
+                            input: typedPart.input,
+                            providerExecuted,
+                            dynamic: typedPart.dynamic,
+                        });
+                        const toolResultOutput = resolveToolResultOutput(typedPart);
+                        const inferredToolError = getToolResultError(toolResultOutput);
+                        const isExplicitError = typedPart.isError === true &&
+                            !isIntegrationAuthenticationActionResult(toolResultOutput);
+                        const isError = isExplicitError || inferredToolError !== undefined;
+                        const toolResultError = isExplicitError
+                            ? toolResultOutput
+                            : inferredToolError ?? toolResultOutput;
+                        logProviderToolPart("tool-result", {
+                            toolCallId: typedPart.toolCallId,
+                            toolName: typedPart.toolName,
+                            providerExecuted,
+                            dynamic: typedPart.dynamic,
+                            output: toolResultOutput,
+                            input: typedPart.input,
+                            preliminary: typedPart.preliminary,
+                            isError,
+                        });
+                        if (isError) {
+                            state.toolResults.push({
+                                toolCallId: typedPart.toolCallId,
+                                toolName: typedPart.toolName,
+                                error: toolResultError,
+                                ...(providerExecuted !== undefined ? { providerExecuted } : {}),
+                                ...(typedPart.dynamic ? { dynamic: true } : {}),
+                            });
+                            sendSSE(controller, encoder, {
+                                type: "tool-output-error",
+                                toolCallId: typedPart.toolCallId,
+                                errorText: stringifyToolError(toolResultError),
+                                ...(providerExecuted !== undefined ? { providerExecuted } : {}),
+                                ...(typedPart.dynamic ? { dynamic: true } : {}),
+                            });
+                            break;
+                        }
+                        state.toolResults.push({
+                            toolCallId: typedPart.toolCallId,
                             toolName: typedPart.toolName,
-                            input: inputObj,
+                            output: toolResultOutput,
                             ...(providerExecuted !== undefined ? { providerExecuted } : {}),
-                            ...(dynamic ? { dynamic: true } : {}),
+                            ...(typedPart.dynamic ? { dynamic: true } : {}),
+                            ...(typedPart.preliminary !== undefined
+                                ? { preliminary: typedPart.preliminary }
+                                : {}),
+                        });
+                        sendSSE(controller, encoder, {
+                            type: "tool-output-available",
+                            toolCallId: typedPart.toolCallId,
+                            output: toolResultOutput,
+                            ...(providerExecuted !== undefined ? { providerExecuted } : {}),
+                            ...(typedPart.dynamic ? { dynamic: true } : {}),
+                            ...(typedPart.preliminary !== undefined
+                                ? { preliminary: typedPart.preliminary }
+                                : {}),
                         });
-                    }
-                    if (providerExecuted !== true) {
-                        shouldStopForCommittedLocalToolCall = true;
-                    }
-                    break;
-                }
-                case "tool-result": {
-                    closeTextSegment();
-                    closeReasoningSegment();
-                    if (suppressedToolCallIds.has(typedPart.toolCallId) ||
-                        isUnavailableTool(typedPart.toolName)) {
-                        suppressToolCall(typedPart.toolCallId, typedPart.toolName);
                         break;
                     }
-                    const providerExecuted = resolveProviderExecuted(typedPart.toolName, typedPart.providerExecuted);
-                    ensureToolLifecycle({
-                        toolCallId: typedPart.toolCallId,
-                        toolName: typedPart.toolName,
-                        input: typedPart.input,
-                        providerExecuted,
-                        dynamic: typedPart.dynamic,
-                    });
-                    const toolResultOutput = resolveToolResultOutput(typedPart);
-                    const inferredToolError = getToolResultError(toolResultOutput);
-                    const isExplicitError = typedPart.isError === true &&
-                        !isIntegrationAuthenticationActionResult(toolResultOutput);
-                    const isError = isExplicitError || inferredToolError !== undefined;
-                    const toolResultError = isExplicitError
-                        ? toolResultOutput
-                        : inferredToolError ?? toolResultOutput;
-                    logProviderToolPart("tool-result", {
-                        toolCallId: typedPart.toolCallId,
-                        toolName: typedPart.toolName,
-                        providerExecuted,
-                        dynamic: typedPart.dynamic,
-                        output: toolResultOutput,
-                        input: typedPart.input,
-                        preliminary: typedPart.preliminary,
-                        isError,
-                    });
-                    if (isError) {
+                    case "tool-error": {
+                        closeTextSegment();
+                        closeReasoningSegment();
+                        const providerExecuted = resolveProviderExecuted(typedPart.toolName, typedPart.providerExecuted);
+                        pendingProviderExecutedToolCallIds.delete(typedPart.toolCallId);
+                        ensureToolLifecycle({
+                            toolCallId: typedPart.toolCallId,
+                            toolName: typedPart.toolName,
+                            input: typedPart.input,
+                            providerExecuted,
+                            dynamic: typedPart.dynamic,
+                        });
+                        logProviderToolPart("tool-error", {
+                            toolCallId: typedPart.toolCallId,
+                            toolName: typedPart.toolName,
+                            providerExecuted,
+                            dynamic: typedPart.dynamic,
+                            error: typedPart.error,
+                            input: typedPart.input,
+                        });
                         state.toolResults.push({
                             toolCallId: typedPart.toolCallId,
                             toolName: typedPart.toolName,
-                            error: toolResultError,
+                            error: typedPart.error,
                             ...(providerExecuted !== undefined ? { providerExecuted } : {}),
                             ...(typedPart.dynamic ? { dynamic: true } : {}),
                         });
                         sendSSE(controller, encoder, {
                             type: "tool-output-error",
                             toolCallId: typedPart.toolCallId,
-                            errorText: stringifyToolError(toolResultError),
+                            errorText: stringifyToolError(typedPart.error),
                             ...(providerExecuted !== undefined ? { providerExecuted } : {}),
                             ...(typedPart.dynamic ? { dynamic: true } : {}),
                         });
                         break;
                     }
-                    state.toolResults.push({
-                        toolCallId: typedPart.toolCallId,
-                        toolName: typedPart.toolName,
-                        output: toolResultOutput,
-                        ...(providerExecuted !== undefined ? { providerExecuted } : {}),
-                        ...(typedPart.dynamic ? { dynamic: true } : {}),
-                        ...(typedPart.preliminary !== undefined ? { preliminary: typedPart.preliminary } : {}),
-                    });
-                    sendSSE(controller, encoder, {
-                        type: "tool-output-available",
-                        toolCallId: typedPart.toolCallId,
-                        output: toolResultOutput,
-                        ...(providerExecuted !== undefined ? { providerExecuted } : {}),
-                        ...(typedPart.dynamic ? { dynamic: true } : {}),
-                        ...(typedPart.preliminary !== undefined ? { preliminary: typedPart.preliminary } : {}),
-                    });
-                    break;
-                }
-                case "tool-error": {
-                    closeTextSegment();
-                    closeReasoningSegment();
-                    const providerExecuted = resolveProviderExecuted(typedPart.toolName, typedPart.providerExecuted);
-                    ensureToolLifecycle({
-                        toolCallId: typedPart.toolCallId,
-                        toolName: typedPart.toolName,
-                        input: typedPart.input,
-                        providerExecuted,
-                        dynamic: typedPart.dynamic,
-                    });
-                    logProviderToolPart("tool-error", {
-                        toolCallId: typedPart.toolCallId,
-                        toolName: typedPart.toolName,
-                        providerExecuted,
-                        dynamic: typedPart.dynamic,
-                        error: typedPart.error,
-                        input: typedPart.input,
-                    });
-                    state.toolResults.push({
-                        toolCallId: typedPart.toolCallId,
-                        toolName: typedPart.toolName,
-                        error: typedPart.error,
-                        ...(providerExecuted !== undefined ? { providerExecuted } : {}),
-                        ...(typedPart.dynamic ? { dynamic: true } : {}),
-                    });
-                    sendSSE(controller, encoder, {
-                        type: "tool-output-error",
-                        toolCallId: typedPart.toolCallId,
-                        errorText: stringifyToolError(typedPart.error),
-                        ...(providerExecuted !== undefined ? { providerExecuted } : {}),
-                        ...(typedPart.dynamic ? { dynamic: true } : {}),
-                    });
-                    break;
-                }
-                case "finish": {
-                    closeTextSegment();
-                    closeReasoningSegment();
-                    state.finishReason = typedPart.finishReason ?? null;
-                    if (state.finishReason) {
-                        setActiveSpanAttributes({
-                            "gen_ai.response.finish_reasons": [state.finishReason],
-                        });
-                    }
-                    if (state.finishReason === "tool-calls") {
-                        commitParseablePendingToolInputs();
+                    case "finish": {
+                        closeTextSegment();
+                        closeReasoningSegment();
+                        state.finishReason = typedPart.finishReason ?? null;
+                        if (state.finishReason) {
+                            setActiveSpanAttributes({
+                                "gen_ai.response.finish_reasons": [state.finishReason],
+                            });
+                        }
+                        if (state.finishReason === "tool-calls") {
+                            commitParseablePendingToolInputs();
+                        }
+                        if (typedPart.totalUsage) {
+                            const input = typedPart.totalUsage.inputTokens ?? 0;
+                            const output = typedPart.totalUsage.outputTokens ?? 0;
+                            const cacheReadInputTokens = typedPart.totalUsage.cacheReadInputTokens;
+                            const cacheCreationInputTokens = typedPart.totalUsage.cacheCreationInputTokens;
+                            const cachedInputTokens = typedPart.totalUsage.cachedInputTokens ??
+                                cacheReadInputTokens;
+                            state.usage = {
+                                promptTokens: input,
+                                completionTokens: output,
+                                totalTokens: typedPart.totalUsage.totalTokens ?? input + output,
+                                ...(cachedInputTokens !== undefined ? { cachedInputTokens } : {}),
+                                ...(cacheCreationInputTokens !== undefined ? { cacheCreationInputTokens } : {}),
+                                ...(cacheReadInputTokens !== undefined ? { cacheReadInputTokens } : {}),
+                                ...(typedPart.totalUsage.reasoningTokens !== undefined
+                                    ? { reasoningTokens: typedPart.totalUsage.reasoningTokens }
+                                    : {}),
+                                ...(typedPart.totalUsage.billableInputTokens !== undefined
+                                    ? { billableInputTokens: typedPart.totalUsage.billableInputTokens }
+                                    : {}),
+                                ...(typedPart.totalUsage.billableOutputTokens !== undefined
+                                    ? { billableOutputTokens: typedPart.totalUsage.billableOutputTokens }
+                                    : {}),
+                                ...(typedPart.totalUsage.costUsd !== undefined
+                                    ? { costUsd: typedPart.totalUsage.costUsd }
+                                    : {}),
+                                ...(typedPart.totalUsage.providerInputCostUsd !== undefined
+                                    ? { providerInputCostUsd: typedPart.totalUsage.providerInputCostUsd }
+                                    : {}),
+                                ...(typedPart.totalUsage.providerOutputCostUsd !== undefined
+                                    ? { providerOutputCostUsd: typedPart.totalUsage.providerOutputCostUsd }
+                                    : {}),
+                                ...(typedPart.totalUsage.providerCostUsd !== undefined
+                                    ? { providerCostUsd: typedPart.totalUsage.providerCostUsd }
+                                    : {}),
+                                ...(typedPart.totalUsage.veryfrontInputChargeUsd !== undefined
+                                    ? { veryfrontInputChargeUsd: typedPart.totalUsage.veryfrontInputChargeUsd }
+                                    : {}),
+                                ...(typedPart.totalUsage.veryfrontOutputChargeUsd !== undefined
+                                    ? { veryfrontOutputChargeUsd: typedPart.totalUsage.veryfrontOutputChargeUsd }
+                                    : {}),
+                                ...(typedPart.totalUsage.veryfrontChargeUsd !== undefined
+                                    ? { veryfrontChargeUsd: typedPart.totalUsage.veryfrontChargeUsd }
+                                    : {}),
+                                ...(typedPart.totalUsage.veryfrontBilledUsd !== undefined
+                                    ? { veryfrontBilledUsd: typedPart.totalUsage.veryfrontBilledUsd }
+                                    : {}),
+                                ...(typedPart.totalUsage.costCredits !== undefined
+                                    ? { costCredits: typedPart.totalUsage.costCredits }
+                                    : {}),
+                                ...(typedPart.totalUsage.costSource !== undefined
+                                    ? { costSource: typedPart.totalUsage.costSource }
+                                    : {}),
+                                ...(typedPart.totalUsage.billingMode !== undefined
+                                    ? { billingMode: typedPart.totalUsage.billingMode }
+                                    : {}),
+                                ...(typedPart.totalUsage.usageCaptureStatus !== undefined
+                                    ? { usageCaptureStatus: typedPart.totalUsage.usageCaptureStatus }
+                                    : {}),
+                            };
+                            callbacks?.onUsage?.(state.usage);
+                            setActiveSpanAttributes(buildRuntimeUsageTraceAttributes(state.usage));
+                        }
+                        break;
                     }
-                    if (typedPart.totalUsage) {
-                        const input = typedPart.totalUsage.inputTokens ?? 0;
-                        const output = typedPart.totalUsage.outputTokens ?? 0;
-                        const cacheReadInputTokens = typedPart.totalUsage.cacheReadInputTokens;
-                        const cacheCreationInputTokens = typedPart.totalUsage.cacheCreationInputTokens;
-                        const cachedInputTokens = typedPart.totalUsage.cachedInputTokens ??
-                            cacheReadInputTokens;
-                        state.usage = {
-                            promptTokens: input,
-                            completionTokens: output,
-                            totalTokens: typedPart.totalUsage.totalTokens ?? input + output,
-                            ...(cachedInputTokens !== undefined ? { cachedInputTokens } : {}),
-                            ...(cacheCreationInputTokens !== undefined ? { cacheCreationInputTokens } : {}),
-                            ...(cacheReadInputTokens !== undefined ? { cacheReadInputTokens } : {}),
-                            ...(typedPart.totalUsage.reasoningTokens !== undefined
-                                ? { reasoningTokens: typedPart.totalUsage.reasoningTokens }
-                                : {}),
-                            ...(typedPart.totalUsage.billableInputTokens !== undefined
-                                ? { billableInputTokens: typedPart.totalUsage.billableInputTokens }
-                                : {}),
-                            ...(typedPart.totalUsage.billableOutputTokens !== undefined
-                                ? { billableOutputTokens: typedPart.totalUsage.billableOutputTokens }
-                                : {}),
-                            ...(typedPart.totalUsage.costUsd !== undefined
-                                ? { costUsd: typedPart.totalUsage.costUsd }
-                                : {}),
-                            ...(typedPart.totalUsage.providerInputCostUsd !== undefined
-                                ? { providerInputCostUsd: typedPart.totalUsage.providerInputCostUsd }
-                                : {}),
-                            ...(typedPart.totalUsage.providerOutputCostUsd !== undefined
-                                ? { providerOutputCostUsd: typedPart.totalUsage.providerOutputCostUsd }
-                                : {}),
-                            ...(typedPart.totalUsage.providerCostUsd !== undefined
-                                ? { providerCostUsd: typedPart.totalUsage.providerCostUsd }
-                                : {}),
-                            ...(typedPart.totalUsage.veryfrontInputChargeUsd !== undefined
-                                ? { veryfrontInputChargeUsd: typedPart.totalUsage.veryfrontInputChargeUsd }
-                                : {}),
-                            ...(typedPart.totalUsage.veryfrontOutputChargeUsd !== undefined
-                                ? { veryfrontOutputChargeUsd: typedPart.totalUsage.veryfrontOutputChargeUsd }
-                                : {}),
-                            ...(typedPart.totalUsage.veryfrontChargeUsd !== undefined
-                                ? { veryfrontChargeUsd: typedPart.totalUsage.veryfrontChargeUsd }
-                                : {}),
-                            ...(typedPart.totalUsage.veryfrontBilledUsd !== undefined
-                                ? { veryfrontBilledUsd: typedPart.totalUsage.veryfrontBilledUsd }
-                                : {}),
-                            ...(typedPart.totalUsage.costCredits !== undefined
-                                ? { costCredits: typedPart.totalUsage.costCredits }
-                                : {}),
-                            ...(typedPart.totalUsage.costSource !== undefined
-                                ? { costSource: typedPart.totalUsage.costSource }
-                                : {}),
-                            ...(typedPart.totalUsage.billingMode !== undefined
-                                ? { billingMode: typedPart.totalUsage.billingMode }
-                                : {}),
-                            ...(typedPart.totalUsage.usageCaptureStatus !== undefined
-                                ? { usageCaptureStatus: typedPart.totalUsage.usageCaptureStatus }
-                                : {}),
-                        };
-                        callbacks?.onUsage?.(state.usage);
-                        setActiveSpanAttributes(buildRuntimeUsageTraceAttributes(state.usage));
+                    case "error": {
+                        closeTextSegment();
+                        closeReasoningSegment();
+                        logger.warn("Runtime stream error:", typedPart.error);
+                        sendSSE(controller, encoder, {
+                            type: "error",
+                            error: typedPart.error instanceof Error
+                                ? typedPart.error.message
+                                : String(typedPart.error),
+                        });
+                        break;
                     }
-                    break;
-                }
-                case "error": {
-                    closeTextSegment();
-                    closeReasoningSegment();
-                    logger.warn("Runtime stream error:", typedPart.error);
-                    sendSSE(controller, encoder, {
-                        type: "error",
-                        error: typedPart.error instanceof Error
-                            ? typedPart.error.message
-                            : String(typedPart.error),
-                    });
-                    break;
+                    default:
+                        // Ignore other stream parts (source, file, reasoning-*, etc.)
+                        break;
                 }
-                default:
-                    // Ignore other stream parts (source, file, reasoning-*, etc.)
-                    break;
+                throwIfAborted(abortSignal);
             }
             throwIfAborted(abortSignal);
-        }
-        throwIfAborted(abortSignal);
-        if (callbacks?.streamLifecycleMode === "shadow") {
-            let observed = { count: 0, categories: [] };
-            try {
-                observed = shadowLifecycle?.compareLegacySnapshot(state) ?? observed;
-            }
-            catch {
-                shadowLifecycleFailed = true;
+            if (callbacks?.streamLifecycleMode === "shadow") {
+                let observed = { count: 0, categories: [] };
+                try {
+                    observed = shadowLifecycle?.compareLegacySnapshot(state) ?? observed;
+                }
+                catch {
+                    shadowLifecycleFailed = true;
+                }
+                const categories = new Set(observed.categories);
+                if (shadowLifecycleFailed)
+                    categories.add("shadow_error");
+                const report = {
+                    count: categories.size,
+                    categories: [...categories].sort(),
+                };
+                callbacks.onLifecycleShadowReport?.(report);
+                setActiveSpanAttributes({
+                    "stream.lifecycle_shadow.divergence_count": report.count,
+                    "stream.lifecycle_shadow.divergence_categories": [...report.categories],
+                });
             }
-            const categories = new Set(observed.categories);
-            if (shadowLifecycleFailed)
-                categories.add("shadow_error");
-            const report = {
-                count: categories.size,
-                categories: [...categories].sort(),
-            };
-            callbacks.onLifecycleShadowReport?.(report);
-            setActiveSpanAttributes({
-                "stream.lifecycle_shadow.divergence_count": report.count,
-                "stream.lifecycle_shadow.divergence_categories": [...report.categories],
-            });
+        }
+        finally {
+            finalizeUnresolvedProviderToolCalls();
+            // `throwIfAborted` and `streamIterator.next()` can both throw past the
+            // loop, so the upstream iterator is released here rather than only on the
+            // timeout path.
+            returnStreamIteratorOnce();
         }
         setActiveSpanAttributes({
             "stream.event_count": eventCount,