opencode-cmd-provider 1.2.1 → 1.3.0

package/dist/src/provider/command-code-model.js

@@ -6,9 +6,11 @@
 // surfaced error, v3 stream parts on the wire.
 import { randomUUID } from "node:crypto";
 import { resolveApiKey } from "./auth-key.js";
-import { messagesToCC, toolsToJson, systemPromptToText, getEnvironmentInfo, isRecord, } from "./converters.js";
-import { parseStreamEventLine, ccEventToStreamPart } from "./stream.js";
-import { redactCommandCodeErrorText, commandCodeErrorMessage } from "./redact.js";
+import { messagesToCC, messagesToAnthropic, messagesToOpenAI, toolsToJson, systemPromptToText, getEnvironmentInfo, isRecord, stringValue, } from "./converters.js";
+import { parseStreamEventLine, ccEventToStreamPart, createOpenAIStreamParser, createAnthropicStreamParser, } from "./stream.js";
+import { getApiBase, getCmdZdr } from "../env.js";
+import { resolvePlan } from "../deals/plan-summary.js";
+import { redactCommandCodeErrorText, commandCodeErrorMessage, isUpgradeRequiredError, } from "./redact.js";
 import { calculateCommandCodeCost, costUsageFromAiSdkUsage } from "./cost.js";
 import { ZERO_MODEL_COST, MODEL_COSTS } from "./pricing.js";
 import { mappedReasoningEffort, resolveProviderReasoning, thinkingMetadataForModel, isReasoningModel, } from "./reasoning.js";
@@ -19,7 +21,28 @@ const COMMAND_CODE_CLI_VERSION = "1.15.1";
 const DEFAULT_GENERATE_MAX_TOKENS = 64_000;
 const DEFAULT_MAX_RETRIES = 0;
 const DEFAULT_MAX_RETRY_DELAY_MS = 60_000;
-const DEFAULT_BASE_URL = "https://api.commandcode.ai";
+function isClaudeModel(modelId) {
+    return modelId.startsWith("claude-");
+}
+function planFromProviderOptions(providerOptions) {
+    if (!isRecord(providerOptions))
+        return undefined;
+    const top = stringValue(providerOptions.plan);
+    if (top)
+        return top;
+    const topEnv = stringValue(providerOptions.COMMANDCODE_PLAN);
+    if (topEnv)
+        return topEnv;
+    for (const key of ["commandcode", "commandCode", "cmd", "command-code"]) {
+        const ns = providerOptions[key];
+        if (isRecord(ns)) {
+            const v = stringValue(ns.plan) ?? stringValue(ns.COMMANDCODE_PLAN);
+            if (v)
+                return v;
+        }
+    }
+    return undefined;
+}
 function promptSystem(prompt) {
     const system = prompt.filter((m) => m.role === "system").map((m) => m.content);
     return system.length > 0 ? system.join("\n") : undefined;
@@ -32,6 +55,17 @@ function errorStream(message) {
         },
     });
 }
+/**
+ * Internal marker (issue #56 safety net): the Provider API returned a
+ * documented `403 upgrade_required` ("You're on the Go plan, the only plan
+ * without API access"). The transport flips the session to the legacy
+ * `/alpha/generate` transport and retries once. Never surfaced to callers.
+ */
+class UpgradeRequiredError extends Error {
+    constructor() {
+        super("Command Code Provider API requires a plan upgrade (403 upgrade_required)");
+    }
+}
 export class CommandCodeLanguageModel {
     options;
     specificationVersion = "v3";
@@ -45,11 +79,59 @@ export class CommandCodeLanguageModel {
         this.modelId = modelId;
     }
     apiBase() {
-        return this.options.baseURL ?? DEFAULT_BASE_URL;
+        return this.options.baseURL ?? getApiBase();
     }
     costForModel() {
         return { cost: MODEL_COSTS[this.modelId] ?? ZERO_MODEL_COST };
     }
+    /**
+     * Per-instance whoami cache: the `GET /alpha/whoami` fetch happens at most
+     * once for the lifetime of this model instance and is reused across turns.
+     */
+    planCache = {};
+    /**
+     * Safety-net flag (issue #56): once the Provider API answers a documented
+     * `403 upgrade_required`, the session is pinned to the legacy
+     * `/alpha/generate` transport for the lifetime of this model instance —
+     * subsequent turns stay on legacy without re-hitting the Provider API (no
+     * second 403). The Provider API has no path for Go-plan users (that is
+     * exactly what the 403 documents), so the plugin's legacy transport is the
+     * only way to keep serving a plan-detection miss that routed a true Go user
+     * there.
+     */
+    pinnedToLegacy = false;
+    /**
+     * Resolves the transport plan through the shared plan-resolution seam:
+     * explicit override (providerOptions plan, model option `plan`) →
+     * COMMANDCODE_PLAN env → cached whoami → default Provider API. Only a
+     * resolved `go` selects the legacy transport; every other resolution
+     * selects the Provider API. The whoami fetch is cached for the lifetime of
+     * this instance (see planCache) and honours the same resolved key, base URL
+     * and injected fetch as inference.
+     */
+    async shouldUseProviderTransport(options) {
+        if (this.pinnedToLegacy)
+            return false;
+        const plan = await resolvePlan(this.planArgFor(options), process.env, {
+            defaultPlan: "provider",
+            cache: this.planCache,
+            apiKey: resolveApiKey({
+                apiKey: this.options.apiKey,
+                authPaths: this.options.authPaths,
+            }),
+            baseURL: this.options.baseURL,
+            fetch: this.options.fetch,
+        });
+        return plan !== "go";
+    }
+    planArgFor(options) {
+        return planFromProviderOptions(options.providerOptions) ?? this.options.plan;
+    }
+    providerEndpoint() {
+        return isClaudeModel(this.modelId)
+            ? `${this.apiBase()}/provider/v1/messages`
+            : `${this.apiBase()}/provider/v1/chat/completions`;
+    }
     async doGenerate(options) {
         const { parts, error } = await this.runOnce(options);
         if (error)
@@ -98,6 +180,14 @@ export class CommandCodeLanguageModel {
         return { content, finishReason, usage, warnings: [] };
     }
     async doStream(options) {
+        if (await this.shouldUseProviderTransport(options)) {
+            const isClaude = isClaudeModel(this.modelId);
+            const body = this.providerBodyFor(options, isClaude);
+            const headers = this.providerHeadersFor(options);
+            return {
+                stream: this.providerRunStream(body, headers, options.abortSignal, options, isClaude),
+            };
+        }
         return {
             stream: this.runStream(this.bodyFor(options), this.headersFor(options), options.abortSignal, options),
         };
@@ -119,7 +209,16 @@ export class CommandCodeLanguageModel {
             };
         }
         const parts = [];
-        const stream = this.runStream(this.bodyFor(options), this.headersFor(options), options.abortSignal, options, parts);
+        let stream;
+        if (await this.shouldUseProviderTransport(options)) {
+            const isClaude = isClaudeModel(this.modelId);
+            const body = this.providerBodyFor(options, isClaude);
+            const headers = this.providerHeadersFor(options);
+            stream = this.providerRunStream(body, headers, options.abortSignal, options, isClaude, parts);
+        }
+        else {
+            stream = this.runStream(this.bodyFor(options), this.headersFor(options), options.abortSignal, options, parts);
+        }
         const reader = stream.getReader();
         for (;;) {
             const { done } = await reader.read();
@@ -193,13 +292,101 @@ export class CommandCodeLanguageModel {
             ...(options.headers ?? {}),
         };
     }
+    providerBodyFor(options, isClaude) {
+        const allowImages = modelSupportsImageInput(this.modelId);
+        if (isClaude) {
+            return messagesToAnthropic(options.prompt, {
+                model: this.modelId,
+                maxOutputTokens: options.maxOutputTokens,
+                providerOptions: options.providerOptions,
+                tools: options.tools,
+                allowImages,
+            });
+        }
+        return messagesToOpenAI(options.prompt, {
+            model: this.modelId,
+            maxOutputTokens: options.maxOutputTokens,
+            providerOptions: options.providerOptions,
+            tools: options.tools,
+            allowImages,
+        });
+    }
+    providerHeadersFor(options) {
+        const apiKey = resolveApiKey({
+            apiKey: this.options.apiKey,
+            authPaths: this.options.authPaths,
+        });
+        const headers = {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey ?? ""}`,
+            ...this.options.headers,
+            ...(options.headers ?? {}),
+        };
+        // ZDR passthrough (issue #57): the Provider API honours the CLI's own
+        // opt-in — CMD_ZDR=1 → every Provider API request carries x-cmd-zdr: 1
+        // (https://commandcode.ai/docs/provider "Zero data retention (ZDR)").
+        // Only the exact value "1" opts in; the legacy /alpha/generate transport
+        // never sends the header (headersFor is untouched). The header's presence
+        // is owned solely by the env opt-in, not by caller-supplied headers: with
+        // CMD_ZDR=1 the value is forced to "1", and with it off any caller-supplied
+        // x-cmd-zdr (any casing) is stripped so a non-opted-in session never emits
+        // ZDR.
+        for (const key of Object.keys(headers)) {
+            if (key.toLowerCase() === "x-cmd-zdr")
+                delete headers[key];
+        }
+        if (getCmdZdr())
+            headers["x-cmd-zdr"] = "1";
+        return headers;
+    }
+    providerRunStream(body, headers, signal, options, isClaude, sink) {
+        const url = this.providerEndpoint();
+        const bodyStr = JSON.stringify(body);
+        // Per-stream stateful parsers complete tool calls whose arguments arrive
+        // across multiple SSE events (issue #55 tool-call parity); the stateless
+        // mappers are kept for direct codec use.
+        const parser = isClaude
+            ? createAnthropicStreamParser()
+            : createOpenAIStreamParser();
+        // Safety net (issue #56): a documented `403 upgrade_required` pins this
+        // session to the legacy transport and retries the same call once via
+        // POST {base}/alpha/generate with the legacy CLI wire format. The legacy
+        // descriptor itself never flips, so the retry is bounded to one.
+        const legacyFallback = {
+            url: `${this.apiBase()}/alpha/generate`,
+            bodyStr: JSON.stringify(this.bodyFor(options)),
+            headers: this.headersFor(options),
+            eventToParts: ccEventToStreamPart,
+            flipOnUpgradeRequired: false,
+        };
+        return this.transportStream({ url, bodyStr, headers, eventToParts: parser, flipOnUpgradeRequired: true }, signal, sink, legacyFallback);
+    }
     runStream(body, headers, signal, options, sink) {
+        const url = `${this.apiBase()}/alpha/generate`;
+        const bodyStr = JSON.stringify(body);
+        return this.transportStream({ url, bodyStr, headers, eventToParts: ccEventToStreamPart, flipOnUpgradeRequired: false }, signal, sink);
+    }
+    /**
+     * Deep internal seam: single SSE transport behind a small interface.
+     * All retry/timeout/abort/redaction/stream-parsing/cost/fallback logic
+     * lives here; callers supply only the endpoint URL, body, headers and
+     * the event→parts mapper. Depth gives leverage (N callers) and locality
+     * (fix once, fixed everywhere). The eventToParts adapter varies across
+     * the seam (CC vs OpenAI vs Anthropic) while the transport stays fixed.
+     *
+     * The optional legacyFallback implements the issue #56 safety net: when the
+     * Provider API answers a documented `403 upgrade_required` (Go plan, no API
+     * access), the session is pinned to the legacy `/alpha/generate` transport
+     * and the same call retries once there — the retry is bounded because only
+     * the provider descriptor carries flipOnUpgradeRequired. The pin is sticky
+     * for the lifetime of this model instance (no second Provider API hit on
+     * later turns).
+     */
+    transportStream(descriptor, signal, sink, legacyFallback) {
         const timeoutMs = this.options.timeout;
         const maxRetries = this.options.maxRetries ?? DEFAULT_MAX_RETRIES;
         const maxRetryDelayMs = this.options.maxRetryDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS;
         const fetchImpl = this.options.fetch ?? fetch;
-        const url = `${this.apiBase()}/alpha/generate`;
-        const bodyStr = JSON.stringify(body);
         return new ReadableStream({
             start: async (streamController) => {
                 const emit = (part) => {
@@ -224,192 +411,253 @@ export class CommandCodeLanguageModel {
                     fail("No Command Code API key. Run /connect and select Command Code, set the COMMANDCODE_API_KEY env var, or configure an auth file.");
                     return;
                 }
-                const handleEvent = (event) => {
-                    if (!isRecord(event))
-                        return false;
-                    try {
-                        const parts = ccEventToStreamPart(event);
-                        let finished = false;
-                        for (const part of parts) {
-                            if (part.type === "finish") {
-                                finished = true;
-                                calculateCommandCodeCost(this.costForModel(), costUsageFromAiSdkUsage(part.usage));
-                            }
-                            emit(part);
-                        }
-                        return finished;
-                    }
-                    catch (streamError) {
-                        fail(streamError);
-                        return true;
-                    }
-                };
-                let reader;
-                const controller = new AbortController();
-                const onOuterAbort = () => controller.abort();
-                try {
-                    signal?.addEventListener("abort", onOuterAbort, { once: true });
-                    if (signal?.aborted)
-                        throw abortError("Aborted");
-                    let response;
-                    let finished = false;
-                    retryLoop: for (let attempt = 0;; attempt++) {
-                        const attemptController = new AbortController();
-                        let attemptTimedOut = false;
-                        let attemptTimeoutId;
-                        const clearAttemptTimeout = () => {
-                            if (attemptTimeoutId !== undefined) {
-                                clearTimeout(attemptTimeoutId);
-                                attemptTimeoutId = undefined;
-                            }
-                        };
-                        if (timeoutMs !== undefined) {
-                            attemptTimeoutId = setTimeout(() => {
-                                attemptTimedOut = true;
-                                attemptController.abort();
-                            }, timeoutMs);
-                        }
-                        const onOuterAbort2 = () => attemptController.abort();
-                        controller.signal.addEventListener("abort", onOuterAbort2, { once: true });
-                        const raceAttempt = (promise) => raceAbort(promise, attemptController.signal).catch((error) => {
-                            if (attemptTimedOut)
-                                throw timeoutError(timeoutMs);
-                            throw error;
-                        });
+                /**
+                 * Runs one full request/read pass against a transport descriptor.
+                 * Emits parts as they arrive and closes the stream on success or on
+                 * an outer abort; any other error is rethrown so the caller decides
+                 * (upgrade fallback vs. surface as an error part).
+                 */
+                const runTransport = async (t) => {
+                    /**
+                     * The single `finish` part is held back and emitted only after the
+                     * response body is fully drained. OpenAI-style Provider streams send
+                     * `finish_reason` on the last content chunk and the real `usage` on
+                     * a *separate* trailing usage-only chunk (choices:[]); emitting the
+                     * finish as soon as a finish_reason chunk is seen would drop that
+                     * trailing usage and report zeroed usage/cost. Holding the finish
+                     * lets a later usage-bearing finish replace the earlier one.
+                     */
+                    let heldFinish;
+                    const handleEvent = (event) => {
+                        if (!isRecord(event))
+                            return false;
                         try {
-                            try {
-                                response = await fetchImpl(url, {
-                                    method: "POST",
-                                    headers,
-                                    body: bodyStr,
-                                    signal: attemptController.signal,
-                                });
-                            }
-                            catch (fetchError) {
-                                if (controller.signal.aborted)
-                                    throw abortError("Aborted");
-                                if (attemptTimedOut) {
-                                    if (attempt < maxRetries)
-                                        continue retryLoop;
-                                    throw timeoutError(timeoutMs);
+                            const parts = t.eventToParts(event);
+                            for (const part of parts) {
+                                if (part.type === "finish") {
+                                    heldFinish = part;
                                 }
-                                throw fetchError;
-                            }
-                            // --- HTTP-level retry ---
-                            if (!response.ok && isRetryableStatus(response.status)) {
-                                const retryAfter = response.headers.get("retry-after");
-                                const waitMs = retryDelayMs(attempt, retryAfter, maxRetryDelayMs);
-                                if (waitMs < 0) {
-                                    throw new Error(`Command Code API error ${response.status}: Retry-After delay exceeds max retry delay`);
+                                else {
+                                    emit(part);
                                 }
-                                if (attempt < maxRetries) {
-                                    await response.text().catch(() => "");
-                                    if (waitMs > 0)
-                                        await delay(waitMs, controller.signal);
-                                    continue retryLoop;
+                            }
+                            return heldFinish !== undefined;
+                        }
+                        catch (streamError) {
+                            fail(streamError);
+                            return true;
+                        }
+                    };
+                    let reader;
+                    const controller = new AbortController();
+                    const onOuterAbort = () => controller.abort();
+                    try {
+                        signal?.addEventListener("abort", onOuterAbort, { once: true });
+                        if (signal?.aborted)
+                            throw abortError("Aborted");
+                        let response;
+                        let finished = false;
+                        retryLoop: for (let attempt = 0;; attempt++) {
+                            const attemptController = new AbortController();
+                            let attemptTimedOut = false;
+                            let attemptTimeoutId;
+                            const clearAttemptTimeout = () => {
+                                if (attemptTimeoutId !== undefined) {
+                                    clearTimeout(attemptTimeoutId);
+                                    attemptTimeoutId = undefined;
                                 }
+                            };
+                            if (timeoutMs !== undefined) {
+                                attemptTimeoutId = setTimeout(() => {
+                                    attemptTimedOut = true;
+                                    attemptController.abort();
+                                }, timeoutMs);
                             }
-                            if (!response.ok) {
-                                const errBody = await raceAttempt(response.text().catch(() => ""));
-                                let errorDetail;
+                            const onOuterAbort2 = () => attemptController.abort();
+                            controller.signal.addEventListener("abort", onOuterAbort2, { once: true });
+                            const raceAttempt = (promise) => raceAbort(promise, attemptController.signal).catch((error) => {
+                                if (attemptTimedOut)
+                                    throw timeoutError(timeoutMs);
+                                throw error;
+                            });
+                            try {
                                 try {
-                                    const parsedBody = JSON.parse(errBody);
-                                    errorDetail = commandCodeErrorMessage(parsedBody);
+                                    response = await fetchImpl(t.url, {
+                                        method: "POST",
+                                        headers: t.headers,
+                                        body: t.bodyStr,
+                                        signal: attemptController.signal,
+                                    });
                                 }
-                                catch {
-                                    // Preserve useful plain-text provider errors only after secret
-                                    // redaction; upstream/proxy bodies may echo credentials.
+                                catch (fetchError) {
+                                    if (controller.signal.aborted)
+                                        throw abortError("Aborted");
+                                    if (attemptTimedOut) {
+                                        if (attempt < maxRetries)
+                                            continue retryLoop;
+                                        throw timeoutError(timeoutMs);
+                                    }
+                                    throw fetchError;
                                 }
-                                const safeBody = redactCommandCodeErrorText(errBody).slice(0, 500);
-                                const detail = redactCommandCodeErrorText(errorDetail ?? (safeBody || "Provider returned an error"));
-                                throw new Error(`Command Code API error ${response.status}: ${detail}`);
-                            }
-                            // --- Read response stream ---
-                            reader = response.body?.getReader();
-                            if (!reader)
-                                throw new Error("No response body");
-                            const decoder = new TextDecoder();
-                            let buffer = "";
-                            readLoop: for (;;) {
-                                if (controller.signal.aborted)
-                                    throw abortError("Aborted");
-                                const { done, value } = await raceAbort(reader.read(), attemptController.signal);
-                                if (done) {
-                                    if (buffer.trim())
-                                        handleEvent(parseStreamEventLine(buffer));
-                                    break;
+                                // --- HTTP-level retry ---
+                                if (!response.ok && isRetryableStatus(response.status)) {
+                                    const retryAfter = response.headers.get("retry-after");
+                                    const waitMs = retryDelayMs(attempt, retryAfter, maxRetryDelayMs);
+                                    if (waitMs < 0) {
+                                        throw new Error(`Command Code API error ${response.status}: Retry-After delay exceeds max retry delay`);
+                                    }
+                                    if (attempt < maxRetries) {
+                                        await response.text().catch(() => "");
+                                        if (waitMs > 0)
+                                            await delay(waitMs, controller.signal);
+                                        continue retryLoop;
+                                    }
                                 }
-                                if (controller.signal.aborted)
-                                    throw abortError("Aborted");
-                                buffer += decoder.decode(value, { stream: true });
-                                const lines = buffer.split("\n");
-                                buffer = lines.pop() ?? "";
-                                for (const line of lines) {
+                                if (!response.ok) {
+                                    const errBody = await raceAttempt(response.text().catch(() => ""));
+                                    let parsedBody;
+                                    let errorDetail;
+                                    try {
+                                        parsedBody = JSON.parse(errBody);
+                                        errorDetail = commandCodeErrorMessage(parsedBody);
+                                    }
+                                    catch {
+                                        // Preserve useful plain-text provider errors only after secret
+                                        // redaction; upstream/proxy bodies may echo credentials.
+                                    }
+                                    // Safety net (issue #56): a documented 403 upgrade_required
+                                    // on the Provider API flips the session to the legacy
+                                    // transport; the legacy descriptor itself never flips (so
+                                    // the retry is bounded to one), and any other status flows
+                                    // through the existing error/redaction pipeline unchanged.
+                                    if (t.flipOnUpgradeRequired &&
+                                        isUpgradeRequiredError(response.status, parsedBody ?? errBody)) {
+                                        throw new UpgradeRequiredError();
+                                    }
+                                    const safeBody = redactCommandCodeErrorText(errBody).slice(0, 500);
+                                    const detail = redactCommandCodeErrorText(errorDetail ?? (safeBody || "Provider returned an error"));
+                                    throw new Error(`Command Code API error ${response.status}: ${detail}`);
+                                }
+                                // --- Read response stream ---
+                                reader = response.body?.getReader();
+                                if (!reader)
+                                    throw new Error("No response body");
+                                const decoder = new TextDecoder();
+                                let buffer = "";
+                                readLoop: for (;;) {
                                     if (controller.signal.aborted)
                                         throw abortError("Aborted");
-                                    if (handleEvent(parseStreamEventLine(line))) {
-                                        finished = true;
-                                        break readLoop;
+                                    const { done, value } = await raceAbort(reader.read(), attemptController.signal);
+                                    if (done) {
+                                        if (buffer.trim()) {
+                                            if (handleEvent(parseStreamEventLine(buffer)))
+                                                finished = true;
+                                        }
+                                        break;
+                                    }
+                                    if (controller.signal.aborted)
+                                        throw abortError("Aborted");
+                                    buffer += decoder.decode(value, { stream: true });
+                                    const lines = buffer.split("\n");
+                                    buffer = lines.pop() ?? "";
+                                    for (const line of lines) {
+                                        if (controller.signal.aborted)
+                                            throw abortError("Aborted");
+                                        if (handleEvent(parseStreamEventLine(line)))
+                                            finished = true;
+                                        // Do NOT break on a finish event: an OpenAI Provider stream
+                                        // may send the terminal `usage`-only chunk (choices:[]) after
+                                        // a finish_reason chunk. Keep draining so heldFinish is
+                                        // replaced with the usage-bearing finish before we emit it.
                                     }
                                 }
+                                // Stream completed successfully.
+                                break retryLoop;
                             }
-                            // Stream completed successfully.
-                            break retryLoop;
-                        }
-                        catch (streamError) {
-                            // Stream-level error (e.g. API returned 200 OK but sent an error
-                            // event) or per-attempt timeout during stream reading.
-                            await reader?.cancel().catch(() => { });
-                            try {
-                                reader?.releaseLock();
-                            }
-                            catch { }
-                            reader = undefined;
-                            if (controller.signal.aborted)
+                            catch (streamError) {
+                                // Stream-level error (e.g. API returned 200 OK but sent an error
+                                // event) or per-attempt timeout during stream reading.
+                                await reader?.cancel().catch(() => { });
+                                try {
+                                    reader?.releaseLock();
+                                }
+                                catch { }
+                                reader = undefined;
+                                // 403 upgrade_required is a transport flip, never a retry:
+                                // fall back to the legacy transport immediately (issue #56),
+                                // regardless of maxRetries.
+                                if (streamError instanceof UpgradeRequiredError)
+                                    throw streamError;
+                                if (controller.signal.aborted)
+                                    throw streamError;
+                                // Never retry after visible content was emitted (including timeout mid-stream).
+                                const canRetry = !finished && attempt < maxRetries;
+                                if (canRetry) {
+                                    finished = false;
+                                    const waitMs = attemptTimedOut ? 0 : retryDelayMs(attempt, null, maxRetryDelayMs);
+                                    if (waitMs > 0)
+                                        await delay(waitMs, controller.signal);
+                                    continue retryLoop;
+                                }
+                                if (attemptTimedOut)
+                                    throw timeoutError(timeoutMs);
                                 throw streamError;
-                            // Never retry after visible content was emitted (including timeout mid-stream).
-                            const canRetry = !finished && attempt < maxRetries;
-                            if (canRetry) {
-                                finished = false;
-                                const waitMs = attemptTimedOut ? 0 : retryDelayMs(attempt, null, maxRetryDelayMs);
-                                if (waitMs > 0)
-                                    await delay(waitMs, controller.signal);
-                                continue retryLoop;
                             }
-                            if (attemptTimedOut)
-                                throw timeoutError(timeoutMs);
-                            throw streamError;
+                            finally {
+                                controller.signal.removeEventListener("abort", onOuterAbort2);
+                                clearAttemptTimeout();
+                            }
+                        }
+                        if (heldFinish) {
+                            // The finish part is emitted after the body is fully drained so
+                            // the terminal usage chunk (OpenAI: separate usage-only chunk;
+                            // Anthropic: message_delta) is incorporated.
+                            calculateCommandCodeCost(this.costForModel(), costUsageFromAiSdkUsage(heldFinish.usage));
+                            emit(heldFinish);
                         }
-                        finally {
-                            controller.signal.removeEventListener("abort", onOuterAbort2);
-                            clearAttemptTimeout();
+                        else if (!finished) {
+                            // The server closed the stream without a finish event; the AI SDK
+                            // expects a finish part to terminate a stream.
+                            emit({
+                                type: "finish",
+                                finishReason: { unified: "stop", raw: "stop" },
+                                usage: {
+                                    inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
+                                    outputTokens: { total: 0, text: 0, reasoning: 0 },
+                                },
+                            });
                         }
+                        streamController.close();
                     }
-                    if (!finished) {
-                        // The server closed the stream without a finish event; the AI SDK
-                        // expects a finish part to terminate a stream.
-                        emit({
-                            type: "finish",
-                            finishReason: { unified: "stop", raw: "stop" },
-                            usage: {
-                                inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
-                                outputTokens: { total: 0, text: 0, reasoning: 0 },
-                            },
-                        });
+                    catch (error) {
+                        if (controller.signal.aborted) {
+                            // Outer abort: emit a proper AbortError part (AI SDK contract).
+                            fail(abortError());
+                        }
+                        else {
+                            throw error;
+                        }
                     }
-                    streamController.close();
+                    finally {
+                        signal?.removeEventListener("abort", onOuterAbort);
+                    }
+                };
+                try {
+                    await runTransport(descriptor);
                 }
                 catch (error) {
-                    if (controller.signal.aborted) {
-                        // Outer abort: emit a proper AbortError part (AI SDK contract).
-                        fail(abortError());
-                    }
-                    else {
-                        fail(error);
+                    if (legacyFallback && error instanceof UpgradeRequiredError) {
+                        this.pinnedToLegacy = true;
+                        try {
+                            await runTransport(legacyFallback);
+                            return;
+                        }
+                        catch (fallbackError) {
+                            fail(fallbackError);
+                            return;
+                        }
                     }
-                }
-                finally {
-                    signal?.removeEventListener("abort", onOuterAbort);
+                    fail(error);
                 }
             },
         });