clauderipple 0.9.4 → 0.10.0

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

@@ -8,6 +8,7 @@ import { SseParser } from "./sse.js";
 import { fetchWithRetry } from "../retry.js";
 import { looksLikeAuth } from "../openai/index.js";
 import { StreamMapper, conversationKey, estimateTokens, formatSse, serverToolNames, toResponsesRequest, toolNameRestoreMap } from "./translate.js";
+import { refusesReplayedReasoning } from "../../reasoning.js";
 import { providerExhaustion } from "../../health.js";
 import { credentialHeaderValues, redactErrorText } from "../../redact.js";
 import { codexClientVersion, latestCodexVersion, parseCodexCatalog } from "./catalog.js";
@@ -963,6 +964,27 @@ export class ChatGptAdapter {
             res.end();
         return { status: upstream.status, bytes, ...(usage ? { usage } : {}), note: `codex passthrough account=${owner ? owner.slice(0, 8) : "caller"}` };
     }
+    /**
+     * The options one turn is translated with. The conversation is the storage (reasoning.ts), so what
+     * to replay is read out of the request itself; `carried` is filled in as the input is built and the
+     * outcome lands in the request log. `replay: false` is the retry after the backend refused that
+     * carrier, and it puts back exactly the request this adapter sent before any of this existed.
+     */
+    responsesOptions(carried, model, effort, replay = true) {
+        return {
+            model,
+            effort: effort ?? this.cfg.defaultEffort ?? "high",
+            identity: this.cfg.identity ?? true,
+            ...(this.cfg.instructionsAppend ? { instructionsAppend: this.cfg.instructionsAppend } : {}),
+            replay,
+            // The envelope names this provider and this model, and the request builder refuses anything
+            // else: reasoning outlives the turn that made it, and a conversation moved to another model
+            // must not carry the old one's sealed state with it (reasoning.ts).
+            env: { p: this.name, m: model },
+            carried,
+            log: (line) => this.log.info(`chatgpt ${this.name}: ${line} (${model})`),
+        };
+    }
     /** Handle a fully-read Messages request. `model`/`effort` already resolved by routing. */
     async handle(req, res, path, json, model, effort) {
         if (path.startsWith("/v1/messages/count_tokens")) {
@@ -975,13 +997,9 @@ export class ChatGptAdapter {
         const serverTools = serverToolNames(json.tools);
         if (serverTools.size > 0)
             this.log.warn(`chatgpt ${this.name}: dropped server tools for ${model}: ${[...serverTools].join(", ")} (Anthropic runs these; this provider cannot)`);
-        const upstreamReq = toResponsesRequest(json, {
-            model,
-            effort: effort ?? this.cfg.defaultEffort ?? "high",
-            identity: this.cfg.identity ?? true,
-            ...(this.cfg.instructionsAppend ? { instructionsAppend: this.cfg.instructionsAppend } : {}),
-        });
-        const body = JSON.stringify(upstreamReq);
+        const carried = { replayed: 0, undecodable: 0 };
+        let upstreamReq = toResponsesRequest(json, this.responsesOptions(carried, model, effort));
+        let body = JSON.stringify(upstreamReq);
         const cacheKey = upstreamReq.prompt_cache_key;
         // Input estimate for message_start: a conversation only grows, so the last measured total is a floor.
         const startInput = Math.max(estimateTokens(json), this.lastInputByKey.get(cacheKey) ?? 0);
@@ -991,7 +1009,7 @@ export class ChatGptAdapter {
         // One account answers the turn. Which one is decided here, and a refusal before any byte has
         // reached the client moves the same turn to the next account, so the client is answered on its
         // first ask. The conversation stays on the account that answered: moving it costs the cache.
-        const sent = await this.sendToAnAccount({
+        const ask = () => this.sendToAnAccount({
             conversation: cacheKey,
             path: "/codex/responses",
             body,
@@ -1014,6 +1032,18 @@ export class ChatGptAdapter {
                 };
             },
         });
+        let sent = await ask();
+        // A 4xx that names reasoning is the backend refusing the sealed reasoning we replayed — the blob
+        // was minted by the model that is no longer answering, or by another account. The summary is
+        // worth nothing without it, so the turn is asked once without: replaying is an optimisation and
+        // must never be the reason a user's turn fails (reasoning.ts).
+        if (carried.replayed > 0 && sent.kind === "refused" && refusesReplayedReasoning(sent.status, sent.text)) {
+            this.log.warn(`chatgpt ${this.name}: upstream ${sent.status} refused ${carried.replayed} replayed reasoning item(s) for ${model}; asking again without them: ${sent.text.slice(0, 200)}`);
+            upstreamReq = toResponsesRequest(json, this.responsesOptions({ replayed: 0, undecodable: 0 }, model, effort, false));
+            body = JSON.stringify(upstreamReq);
+            carried.replayed = 0;
+            sent = await ask();
+        }
         if (sent.kind !== "ok") {
             res.off("close", onClose);
             if (sent.kind === "aborted")
@@ -1061,7 +1091,7 @@ export class ChatGptAdapter {
         if (this.cfg.debugDump === "all")
             this.dump(upstream.status, json, upstreamReq, "");
         const wantStream = json.stream === true;
-        const mapper = new StreamMapper(model, startInput, toolNameRestoreMap(json));
+        const mapper = new StreamMapper(model, startInput, toolNameRestoreMap(json), this.name);
         const parser = new SseParser();
         let bytes = 0;
         let ping = null;
@@ -1179,8 +1209,8 @@ export class ChatGptAdapter {
             exhaustion,
             bytes,
             note: failure
-                ? `${wantStream ? "mid-stream " : ""}${failure.type}: ${failure.message} (in=${u.input_tokens} cached=${u.cache_read_input_tokens} out=${u.output_tokens})`
-                : `in=${u.input_tokens} cached=${u.cache_read_input_tokens} out=${u.output_tokens} stop=${mapper.stopReason}${upstreamReq.service_tier ? " fast" : ""}`,
+                ? `${wantStream ? "mid-stream " : ""}${failure.type}: ${failure.message} (in=${u.input_tokens} cached=${u.cache_read_input_tokens} out=${u.output_tokens} replayed=${carried.replayed} reasoning=${mapper.reasoningCount})`
+                : `in=${u.input_tokens} cached=${u.cache_read_input_tokens} out=${u.output_tokens} stop=${mapper.stopReason} replayed=${carried.replayed} reasoning=${mapper.reasoningCount}${upstreamReq.service_tier ? " fast" : ""}`,
             usage: {
                 input: u.input_tokens,
                 cached: u.cache_read_input_tokens,

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

@@ -3,11 +3,15 @@
 // Prompt-cache rule: the Responses `input` we build must be a byte-stable prefix of the
 // next turn's `input`. Claude Code resends the whole history every turn, so the mapping
 // has to be deterministic and must not inject anything that varies (timestamps, salts,
-// re-signed reasoning). Thinking blocks from earlier assistant turns are dropped for the
-// same reason. `prompt_cache_key` is derived from the conversation's first user message — or,
+// re-signed reasoning). A reasoning item that came back from the backend is the exception
+// that proves the rule: it is put back exactly as it arrived, so the bytes are the
+// backend's own, and a turn that carried one maps the same way every time. Thinking
+// blocks with no stored item still have nothing to put back and are dropped as before.
+// `prompt_cache_key` is derived from the conversation's first user message — or,
 // for a request that is not a conversation at all, from its system prompt (see `conversationKey`).
 import crypto from "node:crypto";
 import { identityLine } from "../../identity.js";
+import { encodeEnvelope, envelopeFor, isOurSignature, replayableReasoning } from "../../reasoning.js";
 function blockText(c) {
     if (typeof c === "string")
         return c;
@@ -235,6 +239,7 @@ export function toResponsesRequest(req, opts) {
     // whose call_id has no function_call in the same input ("No tool call found…", measured 2026-09-13).
     // Such results are sent as plain user text instead.
     const knownCalls = new Set();
+    let lastCallId;
     for (const m of req.messages) {
         const role = m.role === "assistant" ? "assistant" : "user";
         if (typeof m.content === "string") {
@@ -251,6 +256,32 @@ export function toResponsesRequest(req, opts) {
             pending = [];
         };
         for (const b of m.content) {
+            // The reasoning this turn came back with, put back exactly where it was: the CLI replays the
+            // block in front of the function calls it belongs to, so iterating in order reproduces the
+            // original positions, parallel calls included. `lastCallId` is the call the carrier arrived
+            // after — the response path addresses the next turn's summary to it (see `onArrival`) — and is
+            // undefined for a lead-in item, which is where such a summary belongs.
+            const decoded = envelopeFor(b, "responses", opts.env, (reason) => {
+                (opts.carried ?? (opts.carried = { replayed: 0, undecodable: 0 })).undecodable++;
+                if (opts.replay !== false)
+                    opts.log?.(`dropped a reasoning carrier: ${reason}`);
+            });
+            // A carrier for the other wire is not ours to touch and falls through to the drop below.
+            if (decoded) {
+                if (opts.replay !== false) {
+                    const item = replayableReasoning(decoded.r);
+                    if (item) {
+                        flush();
+                        input.push(item);
+                        (opts.carried ?? (opts.carried = { replayed: 0, undecodable: 0 })).replayed++;
+                        opts.onArrival?.(item, lastCallId);
+                    }
+                    else {
+                        (opts.carried ?? (opts.carried = { replayed: 0, undecodable: 0 })).undecodable++;
+                    }
+                }
+                continue;
+            }
             switch (b.type) {
                 case "text": {
                     const t = b.text;
@@ -272,6 +303,7 @@ export function toResponsesRequest(req, opts) {
                     flush();
                     const tu = b;
                     knownCalls.add(tu.id);
+                    lastCallId = tu.id;
                     input.push({ type: "function_call", call_id: tu.id, name: toolNameForResponses(tu.name), arguments: typeof tu.input === "string" ? tu.input : JSON.stringify(tu.input ?? {}) });
                     break;
                 }
@@ -293,7 +325,8 @@ export function toResponsesRequest(req, opts) {
                     break;
                 }
                 default:
-                    // thinking / redacted_thinking / unknown: dropped on purpose (see header comment)
+                    // thinking, an unmarked redacted_thinking, anything unknown: no stored item to put back,
+                    // so dropped as before (see header comment)
                     break;
             }
         }
@@ -327,6 +360,11 @@ export function toResponsesRequest(req, opts) {
         prompt_cache_key: conversationId(req),
         client_metadata: { session_id: conversationId(req), thread_id: conversationId(req), turn_id: crypto.randomUUID(), "x-codex-window-id": `${conversationId(req)}:0` },
     };
+    // On every turn, as Codex asks. With `store: false` the backend keeps nothing, and without
+    // `include` it hands back no sealed item either — so a conversation that waited until it already
+    // carried reasoning before asking would never carry any. Only the retry after a refusal leaves it off.
+    if (opts.replay !== false)
+        out.include = ["reasoning.encrypted_content"];
     if (tools.length > 0) {
         out.tools = tools;
         out.parallel_tool_calls = !(tc?.disable_parallel_tool_use ?? false);
@@ -348,6 +386,7 @@ export function estimateTokens(req) {
 export class StreamMapper {
     started = false;
     blockIndex = -1;
+    /** `signed` marks a thinking block that already carries its signature — the envelope we wrote. */
     open = null;
     sawToolCall = false;
     finished = false;
@@ -360,14 +399,30 @@ export class StreamMapper {
     /** Accumulated content for non-streaming responses. */
     content = [];
     stopReason = "end_turn";
+    /**
+     * How many reasoning items this response carried whole — the ones the client will replay. The
+     * `reasoning=` figure the request log shows next to `replayed=`.
+     */
+    reasoningCount = 0;
+    /** The reasoning item being assembled: its identity so far and the call it followed. */
+    pendingReasoning = null;
+    /** The most recent function_call item added, which is what a following reasoning item describes. */
+    lastCallId;
     /** Input-token figure announced in message_start (the real one only arrives with response.completed). */
     startInput;
     /** Mangled tool name → the name Claude Code knows, from `toolNameRestoreMap`. */
     toolNames;
-    constructor(model, startInput = 0, toolNames = new Map()) {
+    /**
+     * The provider name that goes in each reasoning envelope (see reasoning.ts). A blob sealed here is
+     * only sent back here: reasoning outlives the request that made it, and a conversation moved to
+     * another provider must not carry this one's sealed state with it.
+     */
+    provider;
+    constructor(model, startInput = 0, toolNames = new Map(), provider = "") {
         this.model = model;
         this.startInput = startInput;
         this.toolNames = toolNames;
+        this.provider = provider;
         this.messageId = `msg_${crypto.randomBytes(12).toString("hex")}`;
     }
     get isFinished() {
@@ -393,11 +448,17 @@ export class StreamMapper {
             },
         ];
     }
+    /**
+     * A thinking block must carry a signature even when there is none to give — an unsigned one is
+     * refused the moment the session moves to a Claude model (`thinking.ts`) — so a block that was
+     * opened without one gets an empty `signature_delta` as it closes. A block that already carries
+     * the envelope is left alone: a second, empty delta would replace it on the client.
+     */
     closeBlock() {
         if (!this.open)
             return [];
         const evs = [];
-        if (this.open.kind === "thinking")
+        if (this.open.kind === "thinking" && !this.open.signed)
             evs.push({ event: "content_block_delta", data: { type: "content_block_delta", index: this.blockIndex, delta: { type: "signature_delta", signature: "" } } });
         evs.push({ event: "content_block_stop", data: { type: "content_block_stop", index: this.blockIndex } });
         this.open = null;
@@ -410,6 +471,56 @@ export class StreamMapper {
         evs.push({ event: "content_block_start", data: { type: "content_block_start", index: this.blockIndex, content_block: block } });
         return evs;
     }
+    /**
+     * Finish the reasoning item being assembled and hand the client the block that carries it: a
+     * thinking block whose text is the summary (empty when the backend sent none — measured
+     * 2026-10-14: Claude Code keeps and replays such a block, signature and all) and whose signature
+     * is the envelope around the sealed reasoning.
+     *
+     * An item with nothing sealed is only worth its summary, and then only if it has one: there is
+     * nothing to replay, and an empty thinking block is refused by Anthropic the moment the session
+     * switches to a Claude model (`thinking.ts`).
+     */
+    sealReasoning() {
+        const pending = this.pendingReasoning;
+        if (!pending)
+            return [];
+        this.pendingReasoning = null;
+        const text = pending.text.trim() || (typeof pending.summary === "string" ? pending.summary.trim() : "");
+        const events = [];
+        if (!pending.encrypted) {
+            if (text) {
+                events.push(...this.openBlock("thinking", { type: "thinking", thinking: "" }));
+                events.push({ event: "content_block_delta", data: { type: "content_block_delta", index: this.blockIndex, delta: { type: "thinking_delta", thinking: text } } });
+                events.push({ event: "content_block_delta", data: { type: "content_block_delta", index: this.blockIndex, delta: { type: "signature_delta", signature: "" } } });
+                events.push(...this.closeBlock());
+                this.content.push({ type: "thinking", thinking: text, signature: "" });
+            }
+            return events;
+        }
+        const item = { type: "reasoning", encrypted_content: pending.encrypted };
+        if (pending.id)
+            item.id = pending.id;
+        if (Array.isArray(pending.summary))
+            item.summary = pending.summary;
+        const signature = encodeEnvelope(this.envelopeFor(item));
+        events.push(...this.openBlock("thinking", { type: "thinking", thinking: "" }));
+        if (text)
+            events.push({ event: "content_block_delta", data: { type: "content_block_delta", index: this.blockIndex, delta: { type: "thinking_delta", thinking: text } } });
+        // The signature must arrive on this very block: it is the carrier, and the client keeps the block
+        // whole or not at all. It goes last, after the text, which is the order Anthropic's own blocks use.
+        events.push({ event: "content_block_delta", data: { type: "content_block_delta", index: this.blockIndex, delta: { type: "signature_delta", signature } } });
+        if (this.open)
+            this.open.signed = true;
+        events.push(...this.closeBlock());
+        this.content.push({ type: "thinking", thinking: text, signature });
+        this.reasoningCount++;
+        return events;
+    }
+    /** Where this item's envelope says it came from — this adapter's own provider and model. */
+    envelopeFor(item) {
+        return { w: "responses", p: this.provider, m: this.model, r: item };
+    }
     /** Map one upstream event. Returns Anthropic events to emit (possibly none). */
     feed(ev) {
         const type = ev.type;
@@ -426,12 +537,23 @@ export class StreamMapper {
                     // The model echoes the mangled name; Claude Code only recognises the original.
                     const called = item.name ?? "tool";
                     const name = this.toolNames.get(called) ?? called;
+                    this.lastCallId = id;
                     this.content.push({ type: "tool_use", id, name, input: {}, _args: "" });
                     out.push(...this.openBlock("tool", { type: "tool_use", id, name, input: {} }, item.id));
                 }
                 else if (item.type === "reasoning") {
-                    this.content.push({ type: "thinking", thinking: "", signature: "" });
-                    out.push(...this.openBlock("thinking", { type: "thinking", thinking: "" }, item.id));
+                    // The item's reasoning is held until it is complete and handed over whole (see
+                    // `sealReasoning`): one thinking block whose signature carries the envelope. The summary,
+                    // when the backend sends one, is that block's text — and the summary deltas below fill it
+                    // in. Passing the summary through `openBlock` here as well would split one item across two
+                    // blocks, so this opens nothing.
+                    this.pendingReasoning = {
+                        ...(item.id ? { id: item.id } : {}),
+                        ...(typeof item.encrypted_content === "string" && item.encrypted_content ? { encrypted: item.encrypted_content } : {}),
+                        ...(item.summary !== undefined ? { summary: item.summary } : {}),
+                        text: "",
+                        callId: this.lastCallId,
+                    };
                 }
                 else if (item.type === "message") {
                     this.content.push({ type: "text", text: "" });
@@ -454,6 +576,13 @@ export class StreamMapper {
             case "response.reasoning_summary_text.delta":
             case "response.reasoning_text.delta": {
                 const delta = String(ev.delta ?? "");
+                // The summary is the text of the reasoning item's block, and that block also carries the
+                // envelope — both are written when the item is done, so the block is not opened here. One
+                // item is one block; streaming the text into a block of its own would hand the client two.
+                if (this.pendingReasoning) {
+                    this.pendingReasoning.text += delta;
+                    break;
+                }
                 if (!this.open || this.open.kind !== "thinking") {
                     this.content.push({ type: "thinking", thinking: "", signature: "" });
                     out.push(...this.openBlock("thinking", { type: "thinking", thinking: "" }));
@@ -488,7 +617,18 @@ export class StreamMapper {
                 break;
             }
             case "response.output_item.done": {
+                const done = ev.item;
+                // The backend may put `encrypted_content` only on the completed item, so the seal is taken
+                // here as well as from `response.output_item.added`, and the item is only handed over now
+                // anyway — a half-assembled reasoning block must not reach the client.
+                if (done?.type === "reasoning" && this.pendingReasoning) {
+                    if (typeof done.encrypted_content === "string" && done.encrypted_content)
+                        this.pendingReasoning.encrypted = done.encrypted_content;
+                    if (done.summary !== undefined)
+                        this.pendingReasoning.summary = done.summary;
+                }
                 out.push(...this.closeBlock());
+                out.push(...this.sealReasoning());
                 break;
             }
             case "response.completed":

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

@@ -25,6 +25,8 @@ import { ThoughtSignatureStore } from "./thoughtSignatures.js";
 import { conversationKey, serverToolNames, toolNameRestoreMap } from "../chatgpt/translate.js";
 import { GoogleAccountPool } from "./accounts.js";
 import { fetchAvailableModels, staticAntigravityModels } from "./antigravity.js";
+import { GoogleUsage } from "./usage.js";
+import { ANTIGRAVITY_PROMPT_REFUSAL_MESSAGE, isAntigravityPromptRefusal } from "./prompt-refusal.js";
 const PING_MS = 15_000;
 /** How long the CCA model list is reused before asking again. */
 const MODELS_CACHE_MS = 60 * 60 * 1000;
@@ -113,6 +115,8 @@ export class GoogleAdapter {
     cfg;
     log;
     accounts;
+    /** Per-account quota, for the status bar's limits row (`GET /api/limits`). */
+    usage;
     /** Cooldowns and conversation stickiness, shared with the proxy's other credential pools. */
     pool;
     lastInputByKey = new Map();
@@ -130,6 +134,7 @@ export class GoogleAdapter {
         this.log = log;
         this.pool = pool;
         this.accounts = new GoogleAccountPool({ home, log, ...(fetchImpl ? { fetch: fetchImpl } : {}) });
+        this.usage = new GoogleUsage(this.accounts, { warn: (message) => log.warn(message), ...(fetchImpl ? { fetch: fetchImpl } : {}) });
     }
     describeAuth() {
         const all = this.accounts.summaries();
@@ -161,6 +166,13 @@ export class GoogleAdapter {
             };
         });
     }
+    /**
+     * Each account's quota groups by owner id, for the status bar's limits row. Never a token; a
+     * failed lookup keeps that account's last good groups.
+     */
+    usageSnapshot() {
+        return this.usage.snapshot();
+    }
     /**
      * Ask Google again whether an account still needs its verification page (dashboard action). The
      * mark otherwise clears only when the account next answers a turn, so a person who had just
@@ -338,6 +350,8 @@ export class GoogleAdapter {
         const sent = await this.sendToAnAccount({
             conversation: key,
             signal: controller.signal,
+            system: upstreamRequest.systemInstruction,
+            model,
             build: (credential) => {
                 const built = transport.build(upstreamRequest, {
                     model,
@@ -352,6 +366,11 @@ export class GoogleAdapter {
             res.off("close", onClose);
             if (sent.kind === "aborted")
                 return { status: 0, bytes: 0, note: "client closed" };
+            if (sent.kind === "prompt-refused") {
+                const err = anthropicError(400, "invalid_request_error", ANTIGRAVITY_PROMPT_REFUSAL_MESSAGE);
+                return { kind: "prompt-incompatible", status: 400, bytes: 0, errorBody: err.body,
+                    note: "upstream 429: suspected Antigravity SDK prompt refusal with remaining quota", refusal: "prompt-incompatible" };
+            }
             if (sent.kind === "unreachable") {
                 const err = anthropicError(502, "api_error", `Google provider unreachable: ${sent.error.message}`);
                 if (!res.headersSent)
@@ -557,6 +576,13 @@ export class GoogleAdapter {
             const safeText = redactErrorText(text, secrets);
             const status = upstream.status;
             this.log.warn(`google ${this.name}: account ${credential.ownerId.slice(0, 8)} answered ${status}: ${safeText.slice(0, 400)}`);
+            // The generic 429 is also real exhaustion. Only fresh quota evidence for this
+            // account/model permits a request-specific refusal; otherwise keep ordinary
+            // cooldown and account rotation. The proxy can still try a route fallback.
+            if (isAntigravityPromptRefusal(spec.system, status, text, upstream.headers.get("retry-after")) &&
+                this.usage.hasRemainingQuota(credential, spec.model)) {
+                return { kind: "prompt-refused" };
+            }
             // Not a rest and not a refresh: the account works again the moment its person finishes
             // Google's page, so it stays in rotation and the next turn finds out.
             const verifyUrl = status === 403 ? googleValidationUrl(text) : undefined;

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