clauderipple 0.2.0 → 0.3.0

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

@@ -1,15 +1,28 @@
 // ChatGPT subscription adapter: serves an Anthropic Messages request by calling the
 // Codex backend (OpenAI Responses over SSE) and streaming the translated answer back.
+import crypto from "node:crypto";
 import http from "node:http";
 import { CredentialStore } from "./auth.js";
 import { SseParser } from "./sse.js";
-import { StreamMapper, conversationKey, estimateTokens, formatSse, toResponsesRequest } from "./translate.js";
+import { fetchWithRetry } from "../retry.js";
+import { looksLikeAuth } from "../openai/index.js";
+import { StreamMapper, conversationKey, estimateTokens, formatSse, serverToolNames, toResponsesRequest, toolNameRestoreMap } from "./translate.js";
 import { credentialHeaderValues, redactErrorText } from "../../redact.js";
+import { codexClientVersion, parseCodexCatalog } from "./catalog.js";
 import fs from "node:fs";
 import path from "node:path";
 import { homeDir } from "../../config.js";
 export const DEFAULT_BASE = "https://chatgpt.com/backend-api";
 const PING_MS = 15_000;
+/** Active quota lookup. Measured 2026-09-20: GET {base}/wham/usage → 200 JSON. The binary also
+ * carries `/api/codex/usage`, but that path answers 403 here; `wham` is the one that works. */
+const USAGE_PATH = "/wham/usage";
+const USAGE_TIMEOUT_MS = 10_000;
+/** Model catalogue. Measured 2026-09-23: the backend filters this list by `client_version`, and an
+ * hour's cache is short enough that a model announced this morning shows up the same day. */
+const MODELS_PATH = "/codex/models";
+const MODELS_TIMEOUT_MS = 15_000;
+const MODELS_CACHE_MS = 60 * 60 * 1000;
 function anthropicError(status, type, message) {
     return { status, body: JSON.stringify({ type: "error", error: { type, message } }) };
 }
@@ -22,8 +35,15 @@ function mapHttpError(status, text) {
     catch {
         /* keep raw */
     }
-    if (status === 401 || status === 403)
+    if (status === 401)
         return anthropicError(401, "authentication_error", `ChatGPT: ${msg}`);
+    // Same reasoning as the openai-compatible adapter: a 403 is often about what the account may do,
+    // not about the credential, and naming it an auth error sends the user to check the wrong thing.
+    if (status === 403) {
+        return looksLikeAuth(text)
+            ? anthropicError(401, "authentication_error", `ChatGPT: ${msg}`)
+            : anthropicError(403, "permission_error", `ChatGPT: ${msg}`);
+    }
     if (status === 429)
         return anthropicError(429, "rate_limit_error", `ChatGPT: ${msg}`);
     if (status >= 500)
@@ -70,6 +90,40 @@ export function rateLimitsFromHeaders(h) {
         at: Date.now(),
     };
 }
+/**
+ * Map the `/wham/usage` JSON body onto the same shape as `rateLimitsFromHeaders`, so `/api/status`
+ * and the GUI read one thing whether the snapshot came from response headers or the active call.
+ * Shape measured 2026-09-20: `{plan_type, rate_limit: {primary_window:{used_percent,
+ * limit_window_seconds, reset_after_seconds, reset_at}, secondary_window}}`; window minutes are
+ * derived (the body reports seconds), and as with the headers a secondary window only counts when
+ * it has a real length.
+ */
+export function rateLimitsFromUsage(body) {
+    const b = body;
+    const win = (w) => {
+        const used = typeof w?.used_percent === "number" ? w.used_percent : undefined;
+        if (used === undefined)
+            return null;
+        const out = { used_percent: used };
+        if (typeof w.limit_window_seconds === "number")
+            out.window_minutes = Math.round(w.limit_window_seconds / 60);
+        if (typeof w.reset_after_seconds === "number")
+            out.reset_after_seconds = w.reset_after_seconds;
+        if (typeof w.reset_at === "number")
+            out.reset_at = w.reset_at;
+        return out;
+    };
+    const primary = win(b?.rate_limit?.primary_window);
+    if (!primary)
+        return null;
+    const secondary = win(b?.rate_limit?.secondary_window);
+    return {
+        type: "codex.rate_limits",
+        plan_type: typeof b?.plan_type === "string" ? b.plan_type : undefined,
+        rate_limits: { primary, secondary: secondary && secondary.window_minutes ? secondary : null },
+        at: Date.now(),
+    };
+}
 export class ChatGptAdapter {
     name;
     cfg;
@@ -85,8 +139,254 @@ export class ChatGptAdapter {
     describeAuth() {
         return this.creds.describe();
     }
+    /**
+     * Hosted web search through the same Codex backend and credential as ordinary ChatGPT turns.
+     * Wire measured 2026-09-20 against the live backend: a `web_search` Responses tool emits one
+     * `web_search_call`, URL citation annotations on the final output text, and
+     * `response.completed.response.tool_usage.web_search.num_requests`.
+     */
+    webSearch(model, maxResults) {
+        return {
+            name: this.name,
+            search: (query, signal) => this.searchWeb(model, query, maxResults, signal),
+        };
+    }
+    async searchWeb(model, query, maxResults = 10, signal) {
+        // The Responses tool exposes an allowed-domain filter but no exclusion filter. Ignoring a block
+        // would violate the caller's request; fail visibly so the proxy can choose another backend.
+        if (query.blockedDomains?.length)
+            throw new Error("ChatGPT web search does not support blocked_domains");
+        const tokens = await this.creds.get();
+        if (tokens instanceof Error)
+            throw tokens;
+        const id = crypto.randomUUID();
+        const filters = query.allowedDomains?.length ? { allowed_domains: query.allowedDomains } : undefined;
+        const tool = {
+            type: "web_search",
+            search_context_size: "low",
+            external_web_access: true,
+            ...(filters ? { filters } : {}),
+        };
+        const body = {
+            model,
+            instructions: "Perform the requested web search. Answer briefly and cite every source used.",
+            input: [{ type: "message", role: "user", content: [{ type: "input_text", text: query.query }] }],
+            tools: [tool],
+            tool_choice: "required",
+            reasoning: { effort: "low", summary: "auto" },
+            text: { verbosity: "low" },
+            store: false,
+            stream: true,
+            prompt_cache_key: id,
+            client_metadata: { session_id: id, thread_id: id, turn_id: crypto.randomUUID(), "x-codex-window-id": `${id}:0` },
+        };
+        const timeout = AbortSignal.timeout(60_000);
+        const requestSignal = signal ? AbortSignal.any([signal, timeout]) : timeout;
+        const res = await fetch(`${(this.cfg.url ?? DEFAULT_BASE).replace(/\/$/, "")}/codex/responses`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                accept: "text/event-stream",
+                authorization: `Bearer ${tokens.accessToken}`,
+                "chatgpt-account-id": tokens.accountId,
+                "OpenAI-Beta": "responses=experimental",
+                originator: "codex_cli_rs",
+                "session-id": id,
+                "thread-id": id,
+                "x-client-request-id": id,
+                "x-codex-window-id": `${id}:0`,
+            },
+            body: JSON.stringify(body),
+            signal: requestSignal,
+        });
+        const rateLimits = rateLimitsFromHeaders(res.headers);
+        if (rateLimits)
+            this.lastRateLimits = rateLimits;
+        if (!res.ok || !res.body) {
+            const text = await res.text().catch(() => "");
+            if (res.status === 401)
+                this.creds.invalidate();
+            throw new Error(`ChatGPT web search: HTTP ${res.status}${text ? ` ${redactErrorText(text, [tokens.accessToken], 200)}` : ""}`);
+        }
+        const parser = new SseParser();
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        const hits = [];
+        let text = "";
+        let searches = 0;
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                for (const event of parser.feed(decoder.decode(value, { stream: true }))) {
+                    if (event.type === "response.output_text.delta")
+                        text += String(event.delta ?? "");
+                    if (event.type === "response.output_text.annotation.added") {
+                        const a = event.annotation;
+                        if (a?.type === "url_citation" && typeof a.url === "string")
+                            hits.push({ title: typeof a.title === "string" && a.title ? a.title : a.url, url: a.url });
+                    }
+                    if (event.type === "response.completed") {
+                        const completed = event.response;
+                        searches = typeof completed?.tool_usage?.web_search?.num_requests === "number" ? completed.tool_usage.web_search.num_requests : searches;
+                    }
+                    if (event.type === "error")
+                        throw new Error(`ChatGPT web search: ${String(event.error?.message ?? "backend error")}`);
+                }
+            }
+        }
+        finally {
+            try {
+                await reader.cancel();
+            }
+            catch { /* already closed */ }
+        }
+        const unique = new Map();
+        for (const hit of hits)
+            if (!unique.has(hit.url))
+                unique.set(hit.url, hit);
+        const selected = [...unique.values()].slice(0, maxResults);
+        if (searches < 1 || selected.length === 0)
+            throw new Error(`ChatGPT web search: no cited results returned (searches=${searches})`);
+        const prose = text.trim();
+        return prose ? { hits: selected, text: prose } : { hits: selected };
+    }
+    /** One in-flight lookup shared by every caller (the status route and the startup refresh). */
+    rateLimitsInFlight = null;
+    /**
+     * Ask the backend for the current quota instead of waiting for a request to carry it in the
+     * response headers. Without this, `/api/status` shows the last time GPT traffic flowed — 11
+     * hours stale in one measurement (2026-09-20) — and the product's GPT budget read is wrong.
+     * Never throws and never clears a good snapshot; returns the new one, or null on failure.
+     */
+    fetchRateLimits() {
+        if (this.rateLimitsInFlight)
+            return this.rateLimitsInFlight;
+        this.rateLimitsInFlight = this.fetchRateLimitsOnce().finally(() => {
+            this.rateLimitsInFlight = null;
+        });
+        return this.rateLimitsInFlight;
+    }
+    async fetchRateLimitsOnce() {
+        const tokens = await this.creds.get();
+        if (tokens instanceof Error) {
+            this.log.warn(`chatgpt ${this.name}: rate-limit fetch skipped: ${tokens.message}`);
+            return null;
+        }
+        const ac = new AbortController();
+        const timer = setTimeout(() => ac.abort(), USAGE_TIMEOUT_MS);
+        let res;
+        try {
+            res = await fetch(`${(this.cfg.url ?? DEFAULT_BASE).replace(/\/$/, "")}${USAGE_PATH}`, {
+                method: "GET",
+                headers: {
+                    authorization: `Bearer ${tokens.accessToken}`,
+                    "chatgpt-account-id": tokens.accountId,
+                    originator: "codex_cli_rs",
+                    accept: "application/json",
+                },
+                signal: ac.signal,
+            });
+        }
+        catch (e) {
+            this.log.warn(`chatgpt ${this.name}: rate-limit fetch failed: ${e.message}`);
+            return null;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        if (!res.ok) {
+            if (res.status === 401)
+                this.creds.invalidate();
+            this.log.warn(`chatgpt ${this.name}: rate-limit fetch HTTP ${res.status}`);
+            return null;
+        }
+        const parsed = rateLimitsFromUsage(await res.json().catch(() => null));
+        if (!parsed) {
+            this.log.warn(`chatgpt ${this.name}: rate-limit fetch returned no primary window`);
+            return null;
+        }
+        this.lastRateLimits = parsed;
+        return parsed;
+    }
+    /** One in-flight catalogue lookup shared by every caller, and the last good list for an hour. */
+    modelsInFlight = null;
+    modelsCache = null;
+    /**
+     * The models this subscription can actually reach, from the backend's own catalogue. Without it
+     * a model OpenAI ships is invisible here until a router release names it (gpt-6-sol and gpt-6-luna,
+     * 2026-09-23). Never throws; null on any failure, and null
+     * rather than [] when parsing yields nothing, so the caller falls back instead of showing nothing.
+     */
+    fetchModels() {
+        if (this.modelsCache && Date.now() - this.modelsCache.at < MODELS_CACHE_MS)
+            return Promise.resolve(this.modelsCache.models);
+        if (this.modelsInFlight)
+            return this.modelsInFlight;
+        // A failed refresh keeps the last list it read: an expired catalogue is still closer to the
+        // backend than the fallback written into this repo.
+        this.modelsInFlight = this.fetchModelsOnce().then((models) => models ?? this.modelsCache?.models ?? null).finally(() => {
+            this.modelsInFlight = null;
+        });
+        return this.modelsInFlight;
+    }
+    async fetchModelsOnce() {
+        const tokens = await this.creds.get();
+        if (tokens instanceof Error) {
+            this.log.warn(`chatgpt ${this.name}: model-catalog fetch skipped: ${tokens.message}`);
+            return null;
+        }
+        const ac = new AbortController();
+        const timer = setTimeout(() => ac.abort(), MODELS_TIMEOUT_MS);
+        let res;
+        try {
+            res = await fetch(`${(this.cfg.url ?? DEFAULT_BASE).replace(/\/$/, "")}${MODELS_PATH}?client_version=${encodeURIComponent(codexClientVersion())}`, {
+                method: "GET",
+                headers: {
+                    authorization: `Bearer ${tokens.accessToken}`,
+                    "chatgpt-account-id": tokens.accountId,
+                    originator: "codex_cli_rs",
+                    accept: "application/json",
+                },
+                signal: ac.signal,
+            });
+        }
+        catch (e) {
+            this.log.warn(`chatgpt ${this.name}: model-catalog fetch failed: ${e.message}`);
+            return null;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        if (!res.ok) {
+            // The status only: the body can echo the request, and the token rides on it.
+            if (res.status === 401)
+                this.creds.invalidate();
+            this.log.warn(`chatgpt ${this.name}: model-catalog fetch HTTP ${res.status}`);
+            return null;
+        }
+        const models = parseCodexCatalog(await res.json().catch(() => null));
+        if (models.length === 0) {
+            this.log.warn(`chatgpt ${this.name}: model catalog returned no listed models`);
+            return null;
+        }
+        this.modelsCache = { at: Date.now(), models };
+        return models;
+    }
     /** Last measured total input (uncached + cached) per conversation, for the next message_start estimate. */
     lastInputByKey = new Map();
+    /**
+     * The backend's `x-codex-turn-state` per conversation. Every response carries this opaque
+     * token and the Codex CLI sends it back on the conversation's next turn (it sits in the
+     * binary's request-header list beside `x-codex-installation-id`). Without it the backend
+     * answered `cached_tokens: 0` on every turn of a conversation whose prompt_cache_key,
+     * instructions, tools and input prefix were byte-identical 3–6s apart (measured 2026-09-20,
+     * five turns, GPT-6 Astra) — the same adapter read 93% on 2026-09-13, so the backend began
+     * keying cache affinity on this token in between. Keyed on the cache key, which is what a
+     * conversation is to us.
+     */
+    turnStateByKey = new Map();
     rememberInput(key, u) {
         const total = u.input_tokens + u.cache_read_input_tokens;
         if (total > 0) {
@@ -123,6 +423,11 @@ export class ChatGptAdapter {
             res.writeHead(e.status, { "content-type": "application/json" }).end(e.body);
             return { status: e.status, bytes: e.body.length, note: "no credentials" };
         }
+        // Dropping a tool the model was meant to have is worth a line: the alternative to this drop is
+        // an empty answer with nothing logged anywhere, which is what made it expensive to find.
+        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",
@@ -136,6 +441,7 @@ export class ChatGptAdapter {
         const ac = new AbortController();
         const onClose = () => ac.abort();
         res.on("close", onClose);
+        const turnState = this.turnStateByKey.get(cacheKey);
         const upstreamHeaders = {
             "content-type": "application/json",
             accept: "text/event-stream",
@@ -143,16 +449,25 @@ export class ChatGptAdapter {
             "chatgpt-account-id": tokens.accountId,
             "OpenAI-Beta": "responses=experimental",
             originator: "codex_cli_rs",
+            // The conversation's identity, as the Codex CLI states it. This is what the backend keys
+            // the prompt cache on since mid-September 2026 (see `conversationId` in translate.ts).
+            "session-id": cacheKey,
+            "thread-id": cacheKey,
+            "x-client-request-id": cacheKey,
+            "x-codex-window-id": `${cacheKey}:0`,
+            ...(turnState ? { "x-codex-turn-state": turnState } : {}),
         };
         const upstreamSecrets = credentialHeaderValues(Object.entries(upstreamHeaders));
         let upstream;
         try {
-            upstream = await fetch(`${(this.cfg.url ?? DEFAULT_BASE).replace(/\/$/, "")}/codex/responses`, {
+            // Retried here, before any status or byte reaches the client, so a relay's hiccup is absorbed
+            // inside the turn instead of arriving as an error the user has to retry by hand.
+            upstream = await fetchWithRetry(`${(this.cfg.url ?? DEFAULT_BASE).replace(/\/$/, "")}/codex/responses`, {
                 method: "POST",
                 headers: upstreamHeaders,
                 body,
                 signal: ac.signal,
-            });
+            }, { log: (line) => this.log.info(`chatgpt ${this.name}: ${line}`) });
         }
         catch (e) {
             res.off("close", onClose);
@@ -166,6 +481,12 @@ export class ChatGptAdapter {
         const fromHeaders = rateLimitsFromHeaders(upstream.headers);
         if (fromHeaders)
             this.lastRateLimits = fromHeaders;
+        const nextTurnState = upstream.headers.get("x-codex-turn-state");
+        if (nextTurnState) {
+            this.turnStateByKey.set(cacheKey, nextTurnState);
+            if (this.turnStateByKey.size > 500)
+                this.turnStateByKey.delete(this.turnStateByKey.keys().next().value);
+        }
         if (!upstream.ok || !upstream.body) {
             const text = await upstream.text().catch(() => "");
             const safeText = redactErrorText(text, upstreamSecrets);
@@ -182,7 +503,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);
+        const mapper = new StreamMapper(model, startInput, toolNameRestoreMap(json));
         const parser = new SseParser();
         let bytes = 0;
         let ping = null;
@@ -217,8 +538,12 @@ export class ChatGptAdapter {
                     break;
             }
             if (!mapper.isFinished) {
-                // Upstream ended without response.completed: treat as done with what we have.
-                const tail = mapper.finish();
+                // Upstream ended without response.completed. This used to be finished as done-with-what-we-
+                // have, which gave the client an empty or cut-off turn it accepted as final (gpt-6-astra,
+                // 12 empty turns at a median 105s, 2026-09). Overloaded is what Claude Code retries.
+                const tail = parser.sawDone
+                    ? mapper.finish()
+                    : mapper.fail(`${model}: upstream stream ended before the response completed`, "server_is_overloaded");
                 if (wantStream)
                     for (const o of tail)
                         bytes += write(res, formatSse(o));
@@ -226,7 +551,7 @@ export class ChatGptAdapter {
         }
         catch (e) {
             if (!ac.signal.aborted) {
-                const tail = mapper.fail(`stream interrupted: ${e.message}`);
+                const tail = mapper.fail(`stream interrupted: ${e.message}`, "server_is_overloaded");
                 if (wantStream)
                     for (const o of tail)
                         bytes += write(res, formatSse(o));
@@ -243,9 +568,12 @@ export class ChatGptAdapter {
                 /* already closed */
             }
         }
+        const failure = mapper.failure;
+        const failedStatus = failure?.type === "overloaded_error" ? 529 : failure?.type === "rate_limit_error" ? 429 : 502;
         if (!wantStream) {
-            const msg = JSON.stringify(mapper.message());
-            res.writeHead(200, { "content-type": "application/json", "content-length": String(Buffer.byteLength(msg)) }).end(msg);
+            // A failed turn is an error here too, not a 200 carrying whatever arrived before it failed.
+            const msg = failure ? anthropicError(failedStatus, failure.type, failure.message).body : JSON.stringify(mapper.message());
+            res.writeHead(failure ? failedStatus : 200, { "content-type": "application/json", "content-length": String(Buffer.byteLength(msg)) }).end(msg);
             bytes = msg.length;
         }
         else if (!res.writableEnded) {
@@ -253,9 +581,12 @@ export class ChatGptAdapter {
         }
         const u = mapper.usage;
         return {
-            status: 200,
+            // A stream has already sent 200; the record still says the turn failed.
+            status: failure ? failedStatus : 200,
             bytes,
-            note: `in=${u.input_tokens} cached=${u.cache_read_input_tokens} out=${u.output_tokens} stop=${mapper.stopReason}`,
+            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}`,
             usage: {
                 input: u.input_tokens,
                 cached: u.cache_read_input_tokens,

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

@@ -1,6 +1,8 @@
 // Minimal SSE parser: bytes in, `data:` payloads out. Handles multi-line data and CRLF.
 export class SseParser {
     buf = "";
+    /** The stream's own end marker arrived — a vendor that ends on `[DONE]` finished on purpose. */
+    sawDone = false;
     /** Feed a chunk; returns the parsed JSON objects of complete events (non-JSON data is skipped). */
     feed(chunk) {
         this.buf += chunk;
@@ -14,6 +16,8 @@ export class SseParser {
                 .filter((l) => l.startsWith("data:"))
                 .map((l) => l.slice(5).replace(/^ /, ""))
                 .join("\n");
+            if (data === "[DONE]")
+                this.sawDone = true;
             if (!data || data === "[DONE]")
                 continue;
             try {