clauderipple 0.9.5 → 0.10.0

package/dist/router/src/providers/google/prompt-refusal.js

@@ -0,0 +1,29 @@
+const SDK_PARAGRAPH = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
+const GENERIC_EXHAUSTED = "Resource has been exhausted (e.g. check quota).";
+export const ANTIGRAVITY_PROMPT_REFUSAL_MESSAGE = `Google Antigravity rejected this Claude Agent SDK system prompt (upstream 429: ${GENERIC_EXHAUSTED}). ` +
+    "This request appears incompatible with Antigravity; retrying or waiting on this account is unlikely to fix it. " +
+    "Choose another provider for this Claude Code request.";
+/**
+ * Measured 2026-10-16: the same Gemini 3.8 Flash / Claude Opus 5.5 request got 429
+ * with this standalone SDK paragraph and 200 without it. This is response-based
+ * classification, never a prompt rewrite or a prediction before Google answers.
+ * Keep any explicit quota/reset details on the ordinary rate-limit path. This shape
+ * alone also occurs on real exhaustion; callers must require fresh quota evidence.
+ */
+export function isAntigravityPromptRefusal(system, status, text, retryAfter) {
+    if (status !== 429 || retryAfter !== null)
+        return false;
+    if (!system?.parts.some(part => part.text?.split(/\r?\n\s*\r?\n/).some(paragraph => paragraph.trim() === SDK_PARAGRAPH)))
+        return false;
+    try {
+        const error = JSON.parse(text)?.error;
+        if (!error || typeof error !== "object" || Array.isArray(error))
+            return false;
+        const e = error;
+        return e.code === 429 && e.status === "RESOURCE_EXHAUSTED" && e.message === GENERIC_EXHAUSTED &&
+            (e.details === undefined || (Array.isArray(e.details) && e.details.length === 0));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/router/src/providers/google/usage.js

@@ -0,0 +1,257 @@
+// How much of each Antigravity (Cloud Code Assist) account's quota is left, for the dashboard and
+// the status bar's limits row. One request per account, like ClaudeUsage (anthropic-usage.ts): the
+// accounts store already refreshes the OAuth token, so this only reads.
+//
+// Measured 2026-10-15 against a live Antigravity subscription:
+//   POST {prodApi}/v1internal:retrieveUserQuotaSummary
+//   headers: authorization: Bearer <accessToken>, content-type: application/json, user-agent
+//   body:    {"project": "<projectId>"}
+//   answer:  {"groups":[{"displayName":"Gemini Models","buckets":[
+//              {"bucketId":"gemini-weekly","displayName":"Weekly","window":"weekly",
+//               "resetTime":"…","remainingFraction":0.98},
+//              {"bucketId":"gemini-5h","displayName":"5h","window":"5h",…}]},
+//            {"displayName":"Claude and GPT models","buckets":[
+//              {"bucketId":"3p-weekly",…},{"bucketId":"3p-5h",…}]}]}
+// `remainingFraction` is what is left (1 = untouched), so used = (1 - remainingFraction) * 100. The
+// older `retrieveUserQuota` returns meaningless values and is deliberately not used.
+import { GOOGLE_OAUTH, antigravityUserAgent } from "./antigravity.js";
+/** The five-hour and weekly window lengths in minutes, for the limits row's `window_minutes`. */
+const FIVE_HOURS = 5 * 60;
+const WEEK = 7 * 24 * 60;
+/**
+ * Parse the `retrieveUserQuotaSummary` body into groups. A group or bucket missing the fields the
+ * row reads is dropped rather than guessed; null when the body is not the shape at all (so the
+ * caller keeps its last good answer instead of blanking).
+ */
+export function parseQuotaSummary(body) {
+    if (!body || typeof body !== "object" || Array.isArray(body))
+        return null;
+    const groups = body.groups;
+    if (!Array.isArray(groups))
+        return null;
+    const out = [];
+    for (const g of groups) {
+        if (!g || typeof g !== "object" || Array.isArray(g))
+            continue;
+        const group = g;
+        if (typeof group.displayName !== "string" || !group.displayName)
+            continue;
+        const buckets = [];
+        if (Array.isArray(group.buckets)) {
+            for (const b of group.buckets) {
+                if (!b || typeof b !== "object" || Array.isArray(b))
+                    continue;
+                const bucket = b;
+                if (typeof bucket.remainingFraction !== "number" || !Number.isFinite(bucket.remainingFraction))
+                    continue;
+                if (typeof bucket.window !== "string" || !bucket.window)
+                    continue;
+                buckets.push({
+                    bucketId: typeof bucket.bucketId === "string" ? bucket.bucketId : "",
+                    displayName: typeof bucket.displayName === "string" ? bucket.displayName : "",
+                    window: bucket.window,
+                    ...(typeof bucket.resetTime === "string" ? { resetTime: bucket.resetTime } : {}),
+                    remainingFraction: bucket.remainingFraction,
+                });
+            }
+        }
+        if (buckets.length)
+            out.push({ displayName: group.displayName, buckets });
+    }
+    return out;
+}
+/** The window length in minutes, from the endpoint's own name ("5h", "weekly"). */
+function windowMinutes(window) {
+    if (window === "5h")
+        return FIVE_HOURS;
+    if (window === "weekly")
+        return WEEK;
+    return undefined;
+}
+const RANK = { five_hour: 0, seven_day: 1, scoped: 2, window: 3 };
+/** Five-hour, then weekly, then the rest: the same order the row shows Claude's own windows in. */
+function ordered(windows) {
+    return windows.map((w, i) => [w, i]).sort((a, b) => (RANK[a[0].kind] - RANK[b[0].kind]) || (a[1] - b[1])).map(([w]) => w);
+}
+/**
+ * The endpoint's groups as windows the limits row reads. "Gemini Models" carries the plan's own
+ * five-hour and weekly windows; every other group (the measured "Claude and GPT models") is a
+ * third-party window, shown as a `scoped` "3P" with its length in `window_minutes`.
+ */
+export function googleWindowsFromGroups(groups) {
+    const out = [];
+    for (const group of groups) {
+        const gemini = /gemini/i.test(group.displayName);
+        for (const bucket of group.buckets) {
+            const minutes = windowMinutes(bucket.window);
+            const used = Math.round((1 - bucket.remainingFraction) * 1000) / 10;
+            const at = bucket.resetTime ? Math.round(Date.parse(bucket.resetTime) / 1000) : NaN;
+            const reset = Number.isFinite(at) ? { reset_at: at } : {};
+            if (gemini) {
+                const kind = bucket.window === "5h" ? "five_hour" : bucket.window === "weekly" ? "seven_day" : "window";
+                out.push({ kind, used_percent: used, ...(minutes !== undefined ? { window_minutes: minutes } : {}), ...reset });
+            }
+            else {
+                out.push({ kind: "scoped", label: "3P", used_percent: used, ...(minutes !== undefined ? { window_minutes: minutes } : {}), ...reset });
+            }
+        }
+    }
+    return ordered(out);
+}
+/**
+ * The whole body as groups, or null when ANY group or bucket is malformed. The display parser drops
+ * what it cannot read; evidence must not, because a dropped bucket could be the exhausted one.
+ */
+function strictQuotaGroups(body) {
+    const isObject = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+    if (!isObject(body) || !Array.isArray(body.groups))
+        return null;
+    const out = [];
+    for (const g of body.groups) {
+        if (!isObject(g) || typeof g.displayName !== "string" || !g.displayName || !Array.isArray(g.buckets))
+            return null;
+        const buckets = [];
+        for (const b of g.buckets) {
+            if (!isObject(b) || typeof b.bucketId !== "string" || typeof b.window !== "string" || !b.window)
+                return null;
+            if (typeof b.remainingFraction !== "number" || !Number.isFinite(b.remainingFraction))
+                return null;
+            if (b.resetTime !== undefined && typeof b.resetTime !== "string")
+                return null;
+            buckets.push({ bucketId: b.bucketId, displayName: typeof b.displayName === "string" ? b.displayName : "", window: b.window, ...(typeof b.resetTime === "string" ? { resetTime: b.resetTime } : {}), remainingFraction: b.remainingFraction });
+        }
+        out.push({ displayName: g.displayName, buckets });
+    }
+    return out;
+}
+/** The measured group names and their bucket ids; the endpoint reports no per-model quota. */
+const GEMINI_GROUP = { name: "gemini models", ids: { "5h": "gemini-5h", weekly: "gemini-weekly" } };
+const THIRD_PARTY_GROUP = { name: "claude and gpt models", ids: { "5h": "3p-5h", weekly: "3p-weekly" } };
+/** gemini-* draws on "Gemini Models"; claude-* and gpt-oss* on "Claude and GPT models"; else unknown. */
+function groupFor(groups, model) {
+    const id = model.toLowerCase();
+    const known = /^gemini-/.test(id) ? GEMINI_GROUP : /^claude-/.test(id) || /^gpt-oss(-|$)/.test(id) ? THIRD_PARTY_GROUP : undefined;
+    if (!known)
+        return undefined;
+    const found = groups.filter((g) => g.displayName.trim().toLowerCase() === known.name);
+    return found.length === 1 ? { group: found[0], ids: known.ids } : undefined;
+}
+/** True when the group is exactly its 5h and weekly buckets, each with 0 < fraction <= 1 and a reset after `now`. */
+function groupHasQuota(group, ids, now) {
+    if (group.buckets.length !== 2)
+        return false;
+    return ["5h", "weekly"].every((window) => {
+        const matches = group.buckets.filter((b) => b.window === window && b.bucketId === ids[window]);
+        const bucket = matches[0];
+        if (matches.length !== 1 || !bucket)
+            return false;
+        if (bucket.remainingFraction <= 0 || bucket.remainingFraction > 1)
+            return false;
+        const reset = bucket.resetTime ? Date.parse(bucket.resetTime) : Number.NaN;
+        return Number.isFinite(reset) && reset > now;
+    });
+}
+/**
+ * Per-account quota groups, fetched at most once per `ttlMs` per account. A failed lookup keeps the
+ * last good groups rather than blanking them, and only the status code is logged.
+ */
+export class GoogleUsage {
+    last = new Map();
+    /** Per account, only the last SUCCESSFUL lookup; dropped as soon as a refresh fails. */
+    evidence = new Map();
+    inFlight = null;
+    fetchedAt = Number.NEGATIVE_INFINITY;
+    source;
+    opts;
+    constructor(source, opts) {
+        this.source = source;
+        this.opts = opts;
+    }
+    /** Groups by account owner id, from the store's own account ids. */
+    snapshot() {
+        const now = (this.opts.now ?? Date.now)();
+        if (now - this.fetchedAt < (this.opts.ttlMs ?? 5 * 60_000))
+            return Promise.resolve(Object.fromEntries(this.last));
+        this.inFlight ??= this.fetchAll().finally(() => {
+            this.fetchedAt = (this.opts.now ?? Date.now)();
+            this.inFlight = null;
+        });
+        return this.inFlight;
+    }
+    /**
+     * Whether the cached quota still shows room for `model` on this account and project. Reads the
+     * cache only (never fetches), and is true only when the last refresh of this account succeeded
+     * within the TTL, the model's group is recognized, and both its 5h and weekly buckets have a
+     * remaining fraction in (0, 1] and a reset time in the future. Everything else is false: this
+     * is positive evidence, not a guess, so "false" means "unknown or spent", not "refused".
+     */
+    hasRemainingQuota(credential, model) {
+        const evidence = this.evidence.get(credential.ownerId);
+        if (!evidence || evidence.projectId !== credential.projectId)
+            return false;
+        const now = (this.opts.now ?? Date.now)();
+        const age = now - evidence.observedAt;
+        if (!(age >= 0 && age < (this.opts.ttlMs ?? 5 * 60_000)))
+            return false;
+        const match = groupFor(evidence.groups, model);
+        return !!match && groupHasQuota(match.group, match.ids, now);
+    }
+    async fetchAll() {
+        let credentials;
+        try {
+            credentials = await this.source.credentials();
+        }
+        catch (e) {
+            this.opts.warn?.(`google usage: no credentials: ${e.message}`);
+            this.evidence.clear();
+            return Object.fromEntries(this.last);
+        }
+        await Promise.all(credentials.map(async (credential) => {
+            const fetched = await this.fetchOne(credential);
+            if (fetched) {
+                this.last.set(credential.ownerId, fetched.groups);
+                // A body with any malformed group or bucket is shown as far as it parses, but proves nothing.
+                if (fetched.strict)
+                    this.evidence.set(credential.ownerId, { projectId: credential.projectId, observedAt: (this.opts.now ?? Date.now)(), groups: fetched.strict });
+                else
+                    this.evidence.delete(credential.ownerId);
+            }
+            else {
+                // The displayed numbers stay, but they are no longer proof of anything.
+                this.evidence.delete(credential.ownerId);
+            }
+        }));
+        // An account that was removed must not keep its old numbers on the screen.
+        const owners = new Set(credentials.map((c) => c.ownerId));
+        for (const owner of [...this.last.keys()])
+            if (!owners.has(owner))
+                this.last.delete(owner);
+        for (const owner of [...this.evidence.keys()])
+            if (!owners.has(owner))
+                this.evidence.delete(owner);
+        return Object.fromEntries(this.last);
+    }
+    async fetchOne(credential) {
+        const owner = credential.ownerId.slice(0, 8);
+        try {
+            const res = await (this.opts.fetch ?? fetch)(`${GOOGLE_OAUTH.prodApi}/${GOOGLE_OAUTH.apiVersion}:retrieveUserQuotaSummary`, {
+                method: "POST",
+                headers: { authorization: `Bearer ${credential.accessToken}`, "content-type": "application/json", accept: "*/*", "user-agent": antigravityUserAgent() },
+                body: JSON.stringify({ project: credential.projectId }),
+                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?.(`google usage ${owner}: HTTP ${res.status}`);
+                return null;
+            }
+            const body = await res.json();
+            const groups = parseQuotaSummary(body);
+            return groups ? { groups, strict: strictQuotaGroups(body) } : null;
+        }
+        catch (e) {
+            this.opts.warn?.(`google usage ${owner}: ${e.message}`);
+            return null;
+        }
+    }
+}

package/dist/router/src/providers/grok/index.js

@@ -10,6 +10,7 @@
 import { OpenAiCompatibleAdapter } from "../openai/index.js";
 import { GROK_AUTH_HINT, GrokAuth, GrokAuthError, grokHome, sharedGrokAuth } from "./auth.js";
 import { GROK_DEFAULT_URL, GROK_EFFORT_LEVELS } from "./catalog.js";
+import { GrokUsage } from "./usage.js";
 /**
  * Facts only, returned by the probe in a `warning` field like the Antigravity one. Nothing published
  * by xAI says either way whether a third-party client may use the CLI's session.
@@ -34,8 +35,14 @@ export class GrokAdapter {
     name;
     auth;
     inner;
+    url;
+    clientVersion;
+    usageReader;
     constructor(name, cfg, log, auth) {
         this.name = name;
+        this.url = cfg.url ?? GROK_DEFAULT_URL;
+        this.clientVersion = cfg.clientVersion;
+        this.usageReader = new GrokUsage(name, { warn: (message) => log.warn(message) });
         // Shared with the dashboard's probe and with any other provider on the same session, and kept
         // across a config change that rebuilds this adapter.
         this.auth = auth ?? sharedGrokAuth({ home: cfg.home ?? grokHome(), ...(cfg.cli ? { cli: cfg.cli } : {}), log });
@@ -63,6 +70,17 @@ export class GrokAdapter {
             unauthorized: async (_model, sent) => this.auth.rejected(bearer(sent)),
         });
     }
+    /**
+     * The subscription's usage pool, for the status bar's limits row: what the CLI's `/usage` reads,
+     * with this adapter's own session and headers. Empty while no session is usable.
+     */
+    usage() {
+        return this.usageReader.windows(this.url, async () => {
+            const token = await this.auth.token();
+            const { "x-grok-model-override": _model, ...headers } = grokHeaders(token.key, "", await this.auth.clientVersion(this.clientVersion));
+            return headers;
+        }).catch(() => []);
+    }
     async handle(req, res, path, json, model, effort) {
         // Counting tokens is answered locally and needs no session.
         if (!path.startsWith("/v1/messages/count_tokens")) {

package/dist/router/src/providers/grok/usage.js

@@ -0,0 +1,77 @@
+// How much of a Grok subscription's usage pool is spent, for the status bar's limits row.
+//
+// The Grok CLI's `/usage` (alias `/cost`) shows it; the CLI reads it from the chat proxy it talks to
+// with the same session (CLI 1.0.5 strings: "/billing?format=credits", "Monthly limit", "Weekly
+// limit", "Next reset:", field names creditUsagePercent, currentPeriod, billingPeriodEnd).
+// Measured 2026-10-15, signed in on a SuperGrok account with nothing used that week:
+//   GET https://cli-chat-proxy.grok.com/v1/billing?format=credits   (the adapter's headers) → 200
+//   {"config":{"currentPeriod":{"type":"USAGE_PERIOD_TYPE_WEEKLY","start":"…","end":"2026-10-17T04:12:41Z"},
+//    "onDemandCap":{"val":0},"onDemandUsed":{"val":0},"isUnifiedBillingUser":true,"prepaidBalance":{"val":0},
+//    "billingPeriodStart":"…","billingPeriodEnd":"2026-10-17T04:12:41Z"}}
+// The body is protobuf JSON, which leaves zero values out: `creditUsagePercent` was absent at 0%
+// use, so absent reads as 0. Its scale (0–100, by its name) is not yet seen on a non-zero week.
+const WEEK = 7 * 24 * 60;
+const MONTH = 30 * 24 * 60;
+/** The usage pool's current period as a window, or null when the body names none. */
+export function grokWindowsFromBilling(body) {
+    const config = body?.config;
+    if (!config || typeof config !== "object" || Array.isArray(config))
+        return null;
+    const c = config;
+    const period = c.currentPeriod;
+    if (!period || typeof period !== "object")
+        return null;
+    const weekly = period.type === "USAGE_PERIOD_TYPE_WEEKLY";
+    const raw = c.creditUsagePercent;
+    const used = typeof raw === "number" && Number.isFinite(raw) ? raw : raw === undefined ? 0 : NaN;
+    if (!Number.isFinite(used))
+        return null;
+    const end = typeof period.end === "string" ? Date.parse(period.end) : typeof c.billingPeriodEnd === "string" ? Date.parse(c.billingPeriodEnd) : NaN;
+    return [{ kind: weekly ? "seven_day" : "window", used_percent: used, window_minutes: weekly ? WEEK : MONTH, ...(Number.isFinite(end) ? { reset_at: Math.round(end / 1000) } : {}) }];
+}
+/**
+ * One provider's pool, fetched at most once per `ttlMs`. A failed lookup keeps the last good
+ * window rather than blanking it, and only the status code is logged (never the session).
+ */
+export class GrokUsage {
+    last = [];
+    at = Number.NEGATIVE_INFINITY;
+    inFlight = null;
+    name;
+    opts;
+    constructor(name, opts = {}) {
+        this.name = name;
+        this.opts = opts;
+    }
+    windows(url, headers) {
+        const now = (this.opts.now ?? Date.now)();
+        if (now - this.at < (this.opts.ttlMs ?? 5 * 60_000))
+            return Promise.resolve(this.last);
+        this.inFlight ??= this.fetchOne(url, headers).finally(() => {
+            this.at = (this.opts.now ?? Date.now)();
+            this.inFlight = null;
+        });
+        return this.inFlight;
+    }
+    async fetchOne(url, headers) {
+        try {
+            const res = await (this.opts.fetch ?? fetch)(`${url.replace(/\/+$/, "")}/billing?format=credits`, {
+                method: "GET",
+                headers: { accept: "application/json", ...(await headers()) },
+                signal: AbortSignal.timeout(this.opts.timeoutMs ?? 5000),
+            });
+            if (!res.ok) {
+                this.opts.warn?.(`grok usage ${this.name}: HTTP ${res.status}`);
+                return this.last;
+            }
+            const windows = grokWindowsFromBilling(await res.json());
+            if (windows)
+                this.last = windows;
+            return this.last;
+        }
+        catch (e) {
+            this.opts.warn?.(`grok usage ${this.name}: ${e.message}`);
+            return this.last;
+        }
+    }
+}

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

@@ -163,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 } });
@@ -186,11 +196,12 @@ 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;

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();
+        }
+    }
+}