clauderipple 0.9.4 → 0.10.0

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/index.js

@@ -8,6 +8,8 @@ import { credentialHeaderValues, redactErrorText } from "../../redact.js";
 import { SseParser } from "../chatgpt/sse.js";
 import { fetchWithRetry } from "../retry.js";
 import { estimateTokens, formatSse, OpenAiStreamMapper, toOpenAiRequest } from "./translate.js";
+import { refusesReplayedReasoning } from "../../reasoning.js";
+import { PRESETS } from "../../presets.js";
 import { conversationKey, serverToolNames, toolNameRestoreMap } from "../chatgpt/translate.js";
 const PING_MS = 15_000;
 function anthropicError(status, type, message) {
@@ -110,15 +112,25 @@ export class OpenAiCompatibleAdapter {
         const serverTools = serverToolNames(json.tools);
         if (serverTools.size > 0)
             this.log.warn(`${this.tag} ${this.name}: dropped server tools for ${model}: ${[...serverTools].join(", ")} (Anthropic runs these; this provider cannot)`);
-        const upstreamRequest = toOpenAiRequest(json, {
+        // The conversation is the storage for a reasoning model's reasoning (reasoning.ts), so what to
+        // replay is read out of the request itself and the tally is reported in the request log. `env`
+        // names this provider and model: reasoning sealed by another model is never replayed here.
+        const carried = { replayed: 0, undecodable: 0 };
+        const translate = (replay = true) => toOpenAiRequest(json, {
             model,
             wire,
             ...(effort ? { effort } : {}),
             caps,
+            replay,
+            env: { p: this.name, m: model },
+            ...(PRESETS.find((entry) => entry.id === this.cfg.preset)?.sealedReasoning ? { sealedReasoning: true } : {}),
+            carried,
+            log: (line) => this.log.info(`${this.tag} ${this.name}: ${line} (${model})`),
             ...(this.cfg.identity === undefined ? {} : { identity: this.cfg.identity }),
             ...(this.cfg.instructionsAppend ? { instructionsAppend: this.cfg.instructionsAppend } : {}),
         });
-        const requestBody = JSON.stringify(upstreamRequest);
+        const upstreamRequest = translate();
+        let requestBody = JSON.stringify(upstreamRequest);
         // Some vendors key their prompt cache on a session header rather than on the request's own
         // shape, and hand a cold cache to anyone who does not send one. `conversationKey` is the value
         // this codebase already trusts to be stable for one conversation and different between two.
@@ -173,6 +185,17 @@ export class OpenAiCompatibleAdapter {
                     upstream = new Response(refusal, { status: 401 });
                 }
             }
+            // A 4xx that names reasoning is this vendor refusing the reasoning the conversation carried
+            // back — a field it does not take, or a value from another model. The turn goes again without
+            // it: replaying is an optimisation the user's turn must never depend on (reasoning.ts).
+            if (carried.replayed > 0 && refusesReplayedReasoning(upstream.status, await upstream.clone().text().catch(() => ""))) {
+                const refusal = await upstream.text().catch(() => "");
+                this.log.warn(`${this.tag} ${this.name}: upstream ${upstream.status} refused ${carried.replayed} replayed reasoning turn(s) for ${model}; asking again without them: ${refusal.replace(/\s+/g, " ").slice(0, 200)}`);
+                carried.replayed = 0;
+                carried.undecodable = 0;
+                requestBody = JSON.stringify(translate(false));
+                upstream = await ask();
+            }
         }
         catch (error) {
             res.off("close", onClose);
@@ -202,7 +225,8 @@ export class OpenAiCompatibleAdapter {
             return { status: out.status, bytes: Buffer.byteLength(out.body), note: `upstream ${upstream.status}`, exhaustion: providerExhaustion(upstream.status, text, retryAfterMs(Object.fromEntries(upstream.headers))) };
         }
         const wantStream = json.stream === true;
-        const mapper = new OpenAiStreamMapper(model, startInput, toolNameRestoreMap(json));
+        const mapper = new OpenAiStreamMapper(model, startInput, toolNameRestoreMap(json), { p: this.name, m: model });
+        mapper.wire = wire;
         mapper.redactError = redact;
         const parser = new SseParser();
         const reader = upstream.body.getReader();
@@ -283,8 +307,8 @@ export class OpenAiCompatibleAdapter {
             exhaustion: failure ? providerExhaustion(429, `${failure.code ?? ""} ${failure.message}`, retryAfterMs(Object.fromEntries(upstream.headers))) : undefined,
             bytes,
             note: failure
-                ? `${wantStream ? "mid-stream " : ""}${failure.type}: ${failure.message} (in=${usage.input_tokens} cached=${usage.cache_read_input_tokens} out=${usage.output_tokens})`
-                : `in=${usage.input_tokens} cached=${usage.cache_read_input_tokens} out=${usage.output_tokens} stop=${mapper.stopReason}`,
+                ? `${wantStream ? "mid-stream " : ""}${failure.type}: ${failure.message} (in=${usage.input_tokens} cached=${usage.cache_read_input_tokens} out=${usage.output_tokens} replayed=${carried.replayed} reasoning=${mapper.reasoningCount})`
+                : `in=${usage.input_tokens} cached=${usage.cache_read_input_tokens} out=${usage.output_tokens} stop=${mapper.stopReason} replayed=${carried.replayed} reasoning=${mapper.reasoningCount}`,
             usage: { input: usage.input_tokens, cached: usage.cache_read_input_tokens, output: usage.output_tokens },
             stopReason: mapper.stopReason,
             ...(wantStream || !failure ? { messageId: mapper.messageId } : {}),