clauderipple 0.9.4 → 0.10.0

package/dist/router/src/providers/openai/translate.js

@@ -5,6 +5,14 @@ import crypto from "node:crypto";
 import { clampEffort } from "../../compat.js";
 import { conversationKey, estimateTokens, normalizeSchema, serverToolNames, systemWithDroppedToolNote, toolNameForResponses } from "../chatgpt/translate.js";
 import { identityPrefix, instructionsSuffix } from "../../identity.js";
+import { encodeEnvelope, envelopeFor, replayableReasoning } from "../../reasoning.js";
+/** Counts a replay outcome, creating the tally the adapter reports from when it is the first. */
+function bump(opts, kind, by = 1) {
+    if (!opts)
+        return;
+    const carried = opts.carried ?? (opts.carried = { replayed: 0, undecodable: 0 });
+    carried[kind] += by;
+}
 function textOf(content) {
     if (typeof content === "string")
         return content;
@@ -104,6 +112,14 @@ export function toChatMessages(req, opts) {
         if (role === "assistant") {
             const text = [];
             const calls = [];
+            // The reasoning this turn came back with, rejoined into one string and sent as
+            // `reasoning_content` on the same assistant message — the shape DeepSeek's own example builds
+            // by appending the whole response message, and the only shape its API documents. The field
+            // name is the one the vendor sent it under, carried in the envelope: a model heard on
+            // `reasoning` is answered on `reasoning` (reasoning.ts).
+            const reasoning = [];
+            let field = "reasoning_content";
+            let carriedHere = 0;
             for (const block of message.content) {
                 if (block.type === "text")
                     text.push(String(block.text ?? ""));
@@ -112,9 +128,31 @@ export function toChatMessages(req, opts) {
                     knownCalls.add(call.id);
                     calls.push({ id: call.id, type: "function", function: { name: toolNameForResponses(call.name), arguments: typeof call.input === "string" ? call.input : JSON.stringify(call.input ?? {}) } });
                 }
+                const envelope = envelopeFor(block, "chat", opts?.env, (reason) => {
+                    bump(opts, "undecodable");
+                    if (opts?.replay !== false)
+                        opts?.log?.(`dropped a reasoning carrier: ${reason}`);
+                });
+                if (!envelope || opts?.replay === false)
+                    continue;
+                const held = block.thinking;
+                if (typeof held === "string" && held.length > 0)
+                    reasoning.push(held);
+                field = envelope.f === "reasoning" ? "reasoning" : "reasoning_content";
+                carriedHere++;
+            }
+            if (carriedHere > 0)
+                bump(opts, "replayed", carriedHere);
+            // A turn whose only content was reasoning is still a turn the model had: it goes out with the
+            // reasoning alone rather than vanishing, which is what dropping thinking did before.
+            if (text.some(Boolean) || calls.length || reasoning.length) {
+                messages.push({
+                    role: "assistant",
+                    content: text.join("\n") || null,
+                    ...(calls.length ? { tool_calls: calls } : {}),
+                    ...(reasoning.length ? (field === "reasoning" ? { reasoning: reasoning.join("\n\n") } : { reasoning_content: reasoning.join("\n\n") }) : {}),
+                });
             }
-            if (text.some(Boolean) || calls.length)
-                messages.push({ role: "assistant", content: text.join("\n") || null, ...(calls.length ? { tool_calls: calls } : {}) });
             continue;
         }
         let parts = [];
@@ -125,13 +163,23 @@ export function toChatMessages(req, opts) {
             messages.push({ role: "user", content: onlyText ? parts.map((part) => part.text).join("\n") : parts });
             parts = [];
         };
+        // A tool result's images (and the fallback text of an unknown call) wait until the run of tool
+        // results ends: every `tool` message must follow the assistant's tool_calls directly, and a user
+        // message between parallel results is refused (DeepSeek: "insufficient tool messages", #64).
+        let deferred = [];
+        const release = () => {
+            parts.push(...deferred);
+            deferred = [];
+        };
         for (const block of message.content) {
             if (block.type === "text") {
+                release();
                 const text = String(block.text ?? "");
                 if (text)
                     parts.push({ type: "text", text });
             }
             else if (block.type === "image") {
+                release();
                 const url = imageUrl(block);
                 if (url)
                     parts.push({ type: "image_url", image_url: { url } });
@@ -148,19 +196,27 @@ export function toChatMessages(req, opts) {
                 if (knownCalls.has(result.tool_use_id))
                     messages.push({ role: "tool", tool_call_id: result.tool_use_id, content: output });
                 else
-                    parts.push({ type: "text", text: `[Tool result]\n${output}` });
+                    deferred.push({ type: "text", text: `[Tool result]\n${output}` });
                 for (const url of images)
-                    parts.push({ type: "image_url", image_url: { url } });
+                    deferred.push({ type: "image_url", image_url: { url } });
             }
         }
+        release();
         flush();
     }
     return messages;
 }
 /** Translate to the stateless OpenAI Responses input grammar. */
-export function toResponsesInput(req) {
+export function toResponsesInput(req, opts) {
     const input = [];
     const knownCalls = new Set();
+    let lastCallId;
+    // A translation with no options is a translation with nothing to say about reasoning: there is no
+    // provider to name in an envelope and no model to check it against, so nothing is carried either
+    // way. `opts` is only consulted when it is there.
+    const carried = (count) => {
+        bump(opts, count);
+    };
     for (const message of req.messages) {
         const role = message.role === "assistant" ? "assistant" : "user";
         if (typeof message.content === "string") {
@@ -177,6 +233,27 @@ export function toResponsesInput(req) {
             parts = [];
         };
         for (const block of message.content) {
+            // A reasoning item this conversation came back with, in the position it was replayed from —
+            // beside the function calls of that turn, and never for the other wire's carrier (reasoning.ts).
+            const envelope = envelopeFor(block, "responses", opts?.env, (reason) => {
+                carried("undecodable");
+                if (opts?.replay !== false)
+                    opts?.log?.(`dropped a reasoning carrier: ${reason}`);
+            });
+            if (envelope) {
+                if (opts?.replay !== false) {
+                    const item = replayableReasoning(envelope.r);
+                    if (item) {
+                        flush();
+                        input.push(item);
+                        carried("replayed");
+                        opts?.onArrival?.(item, lastCallId);
+                    }
+                    else
+                        carried("undecodable");
+                }
+                continue;
+            }
             if (block.type === "text") {
                 const text = String(block.text ?? "");
                 if (text)
@@ -191,6 +268,7 @@ export function toResponsesInput(req) {
                 flush();
                 const call = block;
                 knownCalls.add(call.id);
+                lastCallId = call.id;
                 input.push({ type: "function_call", call_id: call.id, name: toolNameForResponses(call.name), arguments: typeof call.input === "string" ? call.input : JSON.stringify(call.input ?? {}) });
             }
             else if (block.type === "tool_result") {
@@ -243,11 +321,18 @@ export function toOpenAiRequest(req, opts) {
         return out;
     }
     const responseTools = tools.map(({ function: fn }) => ({ type: "function", ...fn }));
+    const input = toResponsesInput(req, opts);
     const out = {
         model: opts.model,
-        input: toResponsesInput(req),
+        input,
         stream: true,
     };
+    // A vendor marked `sealedReasoning` is asked for its reasoning on every turn, the way OpenCode's own
+    // client asks: asking only once a conversation already carried some would never start one on a
+    // vendor that seals nothing unasked. Anyone else is asked only when the conversation is already
+    // carrying its reasoning, so a request for a vendor never measured stays as it was.
+    if (opts.replay !== false && (opts.sealedReasoning || input.some((item) => item.type === "reasoning")))
+        out.include = ["reasoning.encrypted_content"];
     const instructions = systemWithIdentity(systemWithDroppedToolNote(req), opts);
     if (instructions)
         out.instructions = instructions;
@@ -268,7 +353,7 @@ export function toOpenAiRequest(req, opts) {
     if (typeof req.temperature === "number")
         out.temperature = req.temperature;
     if (effort)
-        out.reasoning = { effort };
+        out.reasoning = opts.sealedReasoning && opts.replay !== false ? { effort, summary: "auto" } : { effort };
     return out;
 }
 export { conversationKey, estimateTokens };
@@ -277,26 +362,43 @@ export class OpenAiStreamMapper {
     started = false;
     finished = false;
     blockIndex = -1;
+    /** `block` is the content entry this block writes into; `signature` seals a Responses item. */
     open = null;
     sawTool = false;
     finishReason;
     responseItems = [];
     responseItemsById = new Map();
+    /** Reasoning items of a Responses stream, by item id, until the item that carries one is done. */
+    reasoningItems = new Map();
+    /** The item id of the most recent function_call, which is what a following reasoning describes. */
+    lastCallId;
+    /** The field a Chat vendor's reasoning arrived under; the same one it is replayed under. */
+    chatReasoningField = "reasoning_content";
     messageId = `msg_${crypto.randomBytes(12).toString("hex")}`;
     servedTier;
     content = [];
     usage = { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 };
     stopReason = "end_turn";
+    /** How many reasoning items this response handed over whole. The `reasoning=` figure in the log. */
+    reasoningCount = 0;
     model;
     startInput;
     /** Mangled tool name → the name Claude Code knows, from `toolNameRestoreMap`. */
     toolNames;
+    /** What goes in each envelope: the provider and model this stream is going to (reasoning.ts). */
+    env;
+    /**
+     * The wire this stream is on. It is fixed for the mapper's life — the adapter knows it before the
+     * first event. Decides what a closing block does: on Chat the block itself is the carrier.
+     */
+    wire = "chat";
     /** Applied to every error message before it is stored or sent. */
     redactError = (message) => message;
-    constructor(model, startInput = 0, toolNames = new Map()) {
+    constructor(model, startInput = 0, toolNames = new Map(), env = { p: "", m: "" }) {
         this.model = model;
         this.startInput = startInput;
         this.toolNames = toolNames;
+        this.env = { p: env.p, m: env.m || model };
     }
     get isFinished() { return this.finished; }
     /**
@@ -315,17 +417,40 @@ export class OpenAiStreamMapper {
         this.started = true;
         return [{ event: "message_start", data: { type: "message_start", message: { id: this.messageId, type: "message", role: "assistant", model: this.model, content: [], stop_reason: null, stop_sequence: null, usage: { input_tokens: this.startInput, output_tokens: 0, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 } } } }];
     }
+    /**
+     * Close the block that is open, writing any envelope it carries as a `signature_delta` first — last
+     * in the block, after all of its text, the order Anthropic's own thinking blocks use.
+     *
+     * A Chat reasoning block is sealed here, because only now is its text whole; a Responses one was
+     * sealed by its item (see `sealReasoningItem`) before this is reached, so it never gets here
+     * unsigned.
+     */
     closeBlock() {
         if (!this.open)
             return [];
-        const index = this.open.index;
+        const { index, kind, block } = this.open;
+        let signature = this.open.signature;
+        if (signature === undefined && kind === "thinking" && this.wire === "chat") {
+            signature = this.signatureForChat(block);
+        }
         this.open = null;
-        return [{ event: "content_block_stop", data: { type: "content_block_stop", index } }];
+        const out = [];
+        if (signature !== undefined)
+            out.push({ event: "content_block_delta", data: { type: "content_block_delta", index, delta: { type: "signature_delta", signature } } });
+        out.push({ event: "content_block_stop", data: { type: "content_block_stop", index } });
+        return out;
     }
-    openBlock(kind, contentBlock, toolIndex) {
+    /**
+     * `block` is the caller's entry in `this.content` for this block, when it has one. It is held here
+     * rather than found as the last entry, because a Chat caller pushes the entry it is about to open
+     * *before* calling this — which would close the block against the wrong entry.
+     */
+    openBlock(kind, contentBlock, toolIndex, block) {
         const out = this.closeBlock();
         const index = ++this.blockIndex;
-        this.open = { kind, index, ...(toolIndex === undefined ? {} : { toolIndex }) };
+        if (block !== undefined)
+            this.content.push(block);
+        this.open = { kind, index, ...(toolIndex === undefined ? {} : { toolIndex }), ...(block === undefined ? {} : { block }) };
         out.push({ event: "content_block_start", data: { type: "content_block_start", index, content_block: contentBlock } });
         return out;
     }
@@ -371,27 +496,34 @@ export class OpenAiStreamMapper {
         for (const choice of choices) {
             const delta = choice.delta ?? {};
             // Thinking arrives before the answer, so it opens the first block of the turn. `reasoning` is
-            // accepted alongside `reasoning_content` because vendors on this wire disagree on the name.
-            const reasoning = typeof delta.reasoning_content === "string" && delta.reasoning_content ? delta.reasoning_content
-                : typeof delta.reasoning === "string" && delta.reasoning ? delta.reasoning : "";
+            // accepted alongside `reasoning_content` because vendors on this wire disagree on the name;
+            // the name it arrived under is remembered, because the same name is what the reasoning has to
+            // be replayed under on the next turn (reasoning.ts).
+            const field = typeof delta.reasoning_content === "string" && delta.reasoning_content ? "reasoning_content"
+                : typeof delta.reasoning === "string" && delta.reasoning ? "reasoning" : null;
+            const reasoning = field === "reasoning_content" ? delta.reasoning_content : field === "reasoning" ? delta.reasoning : "";
+            if (field)
+                this.chatReasoningField = field;
             if (reasoning) {
                 if (!this.open || this.open.kind !== "thinking") {
-                    this.content.push({ type: "thinking", thinking: "" });
-                    out.push(...this.openBlock("thinking", { type: "thinking", thinking: "" }));
+                    // A Chat model's reasoning has no sealed blob to resume from, so the carrier is the block
+                    // itself: the block's text is the reasoning to replay, and its signature is the envelope
+                    // naming the field to replay it under (reasoning.ts). It is sealed when the block closes,
+                    // so the envelope is built once the whole string has arrived (see `signatureForChat`).
+                    out.push(...this.openBlock("thinking", { type: "thinking", thinking: "" }, undefined, { type: "thinking", thinking: "" }));
                 }
-                const last = this.content[this.content.length - 1];
-                if (last?.type === "thinking")
-                    last.thinking += reasoning;
+                const block = this.open?.block;
+                if (block)
+                    block.thinking += reasoning;
                 out.push({ event: "content_block_delta", data: { type: "content_block_delta", index: this.open.index, delta: { type: "thinking_delta", thinking: reasoning } } });
             }
             if (typeof delta.content === "string" && delta.content) {
                 if (!this.open || this.open.kind !== "text") {
-                    this.content.push({ type: "text", text: "" });
-                    out.push(...this.openBlock("text", { type: "text", text: "" }));
+                    out.push(...this.openBlock("text", { type: "text", text: "" }, undefined, { type: "text", text: "" }));
                 }
-                const last = this.content[this.content.length - 1];
-                if (last?.type === "text")
-                    last.text += delta.content;
+                const block = this.open?.block;
+                if (block)
+                    block.text += delta.content;
                 out.push({ event: "content_block_delta", data: { type: "content_block_delta", index: this.open.index, delta: { type: "text_delta", text: delta.content } } });
             }
             if (Array.isArray(delta.tool_calls)) {
@@ -417,6 +549,42 @@ export class OpenAiStreamMapper {
         }
         return out;
     }
+    /**
+     * Seal a closing thinking block of our own: a Chat block into the envelope that names the field to
+     * replay its text under (see `feedChat`).
+     */
+    signatureForChat(block) {
+        if (this.wire !== "chat" || block?.type !== "thinking" || block.thinking.length === 0)
+            return undefined;
+        const signature = encodeEnvelope({ w: "chat", p: this.env.p, m: this.env.m, f: this.chatReasoningField });
+        block.signature = signature;
+        this.reasoningCount++;
+        return signature;
+    }
+    /**
+     * Put the finished Responses reasoning item into the envelope its block carries: the wire, this
+     * provider and model, and the item itself — type, id, summary and the backend's sealed blob,
+     * untouched (reasoning.ts). An item the backend did not seal has nothing to resume, so its block
+     * stays unsigned and only its summary survives, as display text.
+     */
+    sealReasoningItem(item) {
+        const held = this.reasoningItems.get(item.id);
+        const block = item.block;
+        block.thinking = held?.text.trim() || block.thinking.trim() || (typeof held?.summary === "string" ? held.summary.trim() : "");
+        if (!held?.encrypted) {
+            // An item the backend did not seal has nothing to resume. The block stays unsigned, so the
+            // client treats it as display text and never replays it (reasoning.ts).
+            block.signature = "";
+            return;
+        }
+        const reasoning = { type: "reasoning", encrypted_content: held.encrypted };
+        if (item.id)
+            reasoning.id = item.id;
+        if (Array.isArray(held.summary))
+            reasoning.summary = held.summary;
+        block.signature = encodeEnvelope({ w: "responses", p: this.env.p, m: this.env.m, r: reasoning });
+        this.reasoningCount++;
+    }
     responseItem(id, kind) {
         if (typeof id === "string")
             return this.responseItemsById.get(id);
@@ -452,6 +620,24 @@ export class OpenAiStreamMapper {
                 item.closed = true;
                 continue;
             }
+            if (item.kind === "reasoning") {
+                // Emitted only once the item is done, because the block is handed over whole: the sealed
+                // reasoning is what goes in the envelope, and it may only arrive with the completed item.
+                // `sealReasoningItem` has already put the envelope on the block by then.
+                if (!item.done)
+                    break;
+                const reasoning = item.block;
+                out.push(...this.openBlock("thinking", { type: "thinking", thinking: "" }));
+                if (reasoning.signature !== undefined)
+                    this.open = { ...this.open, signature: reasoning.signature };
+                if (reasoning.thinking)
+                    out.push({ event: "content_block_delta", data: { type: "content_block_delta", index: this.open.index, delta: { type: "thinking_delta", thinking: reasoning.thinking } } });
+                item.emitted = true;
+                item.emittedText = reasoning.thinking.length;
+                out.push(...this.closeBlock());
+                item.closed = true;
+                continue;
+            }
             const tool = item.block;
             out.push(...this.openBlock("tool", { type: "tool_use", id: tool.id, name: tool.name, input: {} }, tool.index));
             if (tool.args) {
@@ -480,12 +666,28 @@ export class OpenAiStreamMapper {
                 this.responseItemsById.set(id, responseItem);
             }
             else if (id && item?.type === "function_call") {
+                this.lastCallId = item.call_id === undefined || item.call_id === null ? id : String(item.call_id);
                 const index = this.content.filter((block) => block.type === "tool_use").length;
                 const tool = this.toolFor(index, { id: item.call_id ?? item.id, function: { name: item.name } });
                 const responseItem = { id, kind: "tool", block: tool, done: false, emitted: false, closed: false, emittedText: 0 };
                 this.responseItems.push(responseItem);
                 this.responseItemsById.set(id, responseItem);
             }
+            else if (id && item?.type === "reasoning") {
+                // The item's sealed reasoning and summary, held until the item is done: the block handed over
+                // carries both, and a half-assembled one must not reach the client (reasoning.ts).
+                const reasoning = {
+                    ...(typeof item.encrypted_content === "string" && item.encrypted_content ? { encrypted: item.encrypted_content } : {}),
+                    summary: item.summary,
+                    text: "",
+                };
+                this.reasoningItems.set(id, reasoning);
+                const block = { type: "thinking", thinking: "" };
+                this.content.push(block);
+                const responseItem = { id, kind: "reasoning", block, done: false, emitted: false, closed: false, emittedText: 0 };
+                this.responseItems.push(responseItem);
+                this.responseItemsById.set(id, responseItem);
+            }
         }
         else if (type === "response.output_text.delta") {
             const text = typeof ev.delta === "string" ? ev.delta : "";
@@ -511,10 +713,40 @@ export class OpenAiStreamMapper {
                 }
             }
         }
+        else if (type === "response.reasoning_summary_text.delta" || type === "response.reasoning_text.delta") {
+            // The summary, shown as the thinking block's text. When there is none — which is the usual
+            // shape — nothing arrives and the block stays empty, exactly as the item was measured.
+            const text = typeof ev.delta === "string" ? ev.delta : "";
+            const item = this.responseItem(ev.item_id, "reasoning");
+            if (item?.kind === "reasoning" && text) {
+                const block = item.block;
+                block.thinking += text;
+                if (this.reasoningItems.get(item.id))
+                    this.reasoningItems.get(item.id).text += text;
+                if (item.emitted && this.open?.kind === "thinking") {
+                    out.push({ event: "content_block_delta", data: { type: "content_block_delta", index: this.open.index, delta: { type: "thinking_delta", thinking: text } } });
+                    item.emittedText += text.length;
+                }
+            }
+        }
         else if (type === "response.output_item.done") {
-            const item = this.responseItem(ev.item_id ?? ev.item?.id);
-            if (item)
+            const done = ev.item;
+            const item = this.responseItem(ev.item_id ?? done?.id);
+            if (done?.encrypted_content !== undefined || done?.summary !== undefined) {
+                // The backend may seal the reasoning only when the item completes; take it from there too.
+                const held = this.reasoningItems.get(typeof (ev.item_id ?? done?.id) === "string" ? String(ev.item_id ?? done?.id) : "");
+                if (held) {
+                    if (typeof done.encrypted_content === "string" && done.encrypted_content)
+                        held.encrypted = done.encrypted_content;
+                    if (done.summary !== undefined)
+                        held.summary = done.summary;
+                }
+            }
+            if (item) {
                 item.done = true;
+                if (item.kind === "reasoning")
+                    this.sealReasoningItem(item);
+            }
         }
         else if (type === "response.completed" || type === "response.incomplete") {
             const response = ev.response;
@@ -535,6 +767,7 @@ export class OpenAiStreamMapper {
     feed(ev, wire) {
         if (this.finished)
             return [];
+        this.wire = wire;
         // Some OpenAI-compatible servers emit an ordinary `{error:{...}}` JSON SSE payload
         // instead of the Responses `error` event shape. Do not finish it as a successful answer.
         if (ev.error && typeof ev.error === "object") {

package/dist/router/src/providers/opencode-usage.js

@@ -0,0 +1,116 @@
+// How much of an OpenCode Go subscription is used, for the status bar's limits row.
+//
+// One request per provider: GET {provider.url}/usage (measured 2026-10-15: https://opencode.ai/zen/go/v1/usage)
+// with the provider's own config headers (the bearer key) and the same default User-Agent Node's
+// fetch sends elsewhere — Cloudflare answers 403 `error 1010` to a request carrying no User-Agent
+// and no browser fingerprint, but accepts Node's fetch as it is. Source of the route (behavioral
+// only, no code copied): anomalyco/opencode packages/console/app/src/routes/zen/go/v1/usage.ts and
+// lib/inference-proxy.ts (the `GET /zen/go/v1/usage` → `/go/v1/usage` mapping).
+//
+// Measured answer:
+//   {"usage":{"rolling":{"status":"ok","percent":3,"resetsAt":"2026-10-15T05:39:48Z"},
+//             "weekly":{"status":"ok","percent":52,"resetsAt":"2026-10-19T00:00:00Z"},
+//             "monthly":{"status":"ok","percent":92,"resetsAt":"2026-10-18T05:43:30Z"}}}
+// `rolling` is the five-hour window, `weekly` the week, `monthly` roughly 30 days.
+/** The five-hour, weekly and ~monthly window lengths in minutes. */
+const FIVE_HOURS = 5 * 60;
+const WEEK = 7 * 24 * 60;
+const MONTH = 30 * 24 * 60;
+/** The window lengths and read order of the endpoint's three keys. */
+const KEYS = [
+    { key: "rolling", kind: "five_hour", window_minutes: FIVE_HOURS },
+    { key: "weekly", kind: "seven_day", window_minutes: WEEK },
+    { key: "monthly", kind: "window", window_minutes: MONTH },
+];
+/**
+ * Parse the `/usage` body into windows. A window missing a finite percent is dropped; null when the
+ * body carries no `usage` object at all (so the caller keeps its last good answer instead of
+ * blanking).
+ */
+export function opencodeWindowsFromBody(body) {
+    if (!body || typeof body !== "object" || Array.isArray(body))
+        return null;
+    const usage = body.usage;
+    if (!usage || typeof usage !== "object" || Array.isArray(usage))
+        return null;
+    const source = usage;
+    const out = [];
+    for (const { key, kind, window_minutes } of KEYS) {
+        const w = source[key];
+        if (!w || typeof w !== "object" || Array.isArray(w))
+            continue;
+        const win = w;
+        if (typeof win.percent !== "number" || !Number.isFinite(win.percent))
+            continue;
+        const at = typeof win.resetsAt === "string" ? Date.parse(win.resetsAt) : NaN;
+        out.push({ kind, used_percent: win.percent, window_minutes, ...(Number.isFinite(at) ? { reset_at: Math.round(at / 1000) } : {}) });
+    }
+    return out.length ? out : null;
+}
+/** Whether a provider is an OpenCode Go subscription: its preset, or an OpenCode Go endpoint. */
+export function isOpenCodeGo(p) {
+    if (p.type === "openai-compatible" && p.preset === "opencode-go")
+        return true;
+    if (typeof p.url !== "string")
+        return false;
+    try {
+        const url = new URL(p.url);
+        return url.hostname === "opencode.ai" && /^\/zen\/go\/v1(?:\/|$)/.test(url.pathname);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Per-provider usage windows, fetched at most once per `ttlMs` per provider. A failed lookup keeps
+ * the last good windows rather than blanking them, and only the status code is logged.
+ */
+export class OpenCodeUsage {
+    last = new Map();
+    at = new Map();
+    inFlight = new Map();
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    /** The provider's windows, cached for `ttlMs`; the last good ones survive a failed lookup. */
+    windows(name, url, headers) {
+        const now = (this.opts.now ?? Date.now)();
+        const ttl = this.opts.ttlMs ?? 5 * 60_000;
+        if (now - (this.at.get(name) ?? Number.NEGATIVE_INFINITY) < ttl)
+            return Promise.resolve(this.last.get(name) ?? []);
+        const running = this.inFlight.get(name);
+        if (running)
+            return running;
+        const task = this.fetchOne(name, url, headers).finally(() => {
+            this.at.set(name, (this.opts.now ?? Date.now)());
+            this.inFlight.delete(name);
+        });
+        this.inFlight.set(name, task);
+        return task;
+    }
+    async fetchOne(name, url, headers) {
+        const keep = () => this.last.get(name) ?? [];
+        try {
+            const res = await (this.opts.fetch ?? fetch)(`${url.replace(/\/+$/, "")}/usage`, {
+                method: "GET",
+                headers: { accept: "application/json", ...headers },
+                signal: AbortSignal.timeout(this.opts.timeoutMs ?? 5000),
+            });
+            if (!res.ok) {
+                // The status alone: the body of an auth failure is not worth the risk of echoing.
+                this.opts.warn?.(`opencode usage ${name}: HTTP ${res.status}`);
+                return keep();
+            }
+            const windows = opencodeWindowsFromBody(await res.json());
+            if (!windows)
+                return keep();
+            this.last.set(name, windows);
+            return windows;
+        }
+        catch (e) {
+            this.opts.warn?.(`opencode usage ${name}: ${e.message}`);
+            return keep();
+        }
+    }
+}