@juspay/neurolink 12.7.2 → 12.7.3

package/dist/cli/commands/proxy.js

@@ -25,6 +25,7 @@ import { configureProxyKeepAliveDispatcher } from "../../proxy/proxyDispatcher.j
 import { ProxyRuntimeConfigStore } from "../../proxy/runtimeConfig.js";
 import { startProxyLogCleanupScheduler } from "../../proxy/logCleanupScheduler.js";
 import { anthropicAccountKeysEqual, createAccountAllowlist, ENV_ANTHROPIC_ACCOUNT_KEY, isAccountAllowed, LEGACY_ANTHROPIC_ACCOUNT_KEY, normalizeAnthropicAccountKey, shouldLoadFallbackCredential, } from "../../proxy/accountSelection.js";
+import { resolveProxyStatusAccountIdentity } from "../../proxy/codexAccountUsage.js";
 import { beginProxyRequest, getProxyActivitySnapshot, trackProxyResponse, } from "../../proxy/proxyActivity.js";
 import { flushProxyLifecycleEvents, getProxyLifecycleLoggerSnapshot, hashProxyLifecycleSessionId, logProxyLifecycleEvent, } from "../../proxy/proxyLifecycle.js";
 import { describeInstallFailure, getGlobalInstallArgs, isTransientInstallFailure, resolveGlobalInstaller, validateInstalledVersion, } from "../../proxy/globalInstaller.js";
@@ -1688,6 +1689,7 @@ export async function createProxyStartApp(params) {
         const storedAccountKeys = new Set();
         const storedAccountExpirations = new Map();
         const disabledAccountKeys = new Set();
+        const disabledProviderAccountKeys = new Set();
         let accountInventoryLoaded = false;
         try {
             const { tokenStore } = await import("../../auth/tokenStore.js");
@@ -1720,6 +1722,7 @@ export async function createProxyStartApp(params) {
             }
             for (const key of inventory.disabledKeys) {
                 disabledAccountKeys.add(normalizeAnthropicAccountKey(key));
+                disabledProviderAccountKeys.add(key);
             }
         }
         catch (err) {
@@ -1742,28 +1745,46 @@ export async function createProxyStartApp(params) {
         }));
         const activeUpdaterPid = supervisorState?.updaterPid ?? runtimeState?.updaterPid;
         const accountRows = Object.values(stats.accounts).map((account) => {
-            const normalizedKey = normalizeAnthropicAccountKey(account.label);
-            const isLegacyAccount = account.type === "oauth" && account.label === legacyAccountLabel;
-            const accountKey = storedAccountKeys.has(normalizedKey)
-                ? normalizedKey
-                : isLegacyAccount
-                    ? LEGACY_ANTHROPIC_ACCOUNT_KEY
-                    : account.label === "env"
-                        ? ENV_ANTHROPIC_ACCOUNT_KEY
-                        : normalizedKey;
-            const isStored = storedAccountKeys.has(accountKey) || isLegacyAccount;
-            const { allowed, expired, cooling } = deriveAccountAllowance(accountKey, now, activeAccountAllowlist, storedAccountExpirations, cooldowns);
+            const identity = resolveProxyStatusAccountIdentity(account.label, account.type);
+            const isAnthropicAccount = identity.provider === "anthropic";
+            const isCodexAccount = identity.provider === "codex";
+            const normalizedKey = identity.provider === "anthropic" ? identity.key : null;
+            const isLegacyAccount = isAnthropicAccount && account.label === legacyAccountLabel;
+            const accountKey = isAnthropicAccount
+                ? storedAccountKeys.has(normalizedKey ?? "")
+                    ? normalizedKey
+                    : isLegacyAccount
+                        ? LEGACY_ANTHROPIC_ACCOUNT_KEY
+                        : account.label === "env"
+                            ? ENV_ANTHROPIC_ACCOUNT_KEY
+                            : normalizedKey
+                : identity.key;
+            const isStored = isAnthropicAccount &&
+                accountKey !== null &&
+                (storedAccountKeys.has(accountKey) || isLegacyAccount);
+            const { allowed, expired, cooling } = isAnthropicAccount && accountKey !== null
+                ? deriveAccountAllowance(accountKey, now, activeAccountAllowlist, storedAccountExpirations, cooldowns)
+                : {
+                    allowed: true,
+                    expired: false,
+                    cooling: accountKey !== null &&
+                        (cooldowns[accountKey]?.coolingUntil ?? 0) > now,
+                };
+            const isDisabled = (isAnthropicAccount &&
+                accountKey !== null &&
+                disabledAccountKeys.has(accountKey)) ||
+                (isCodexAccount &&
+                    accountKey !== null &&
+                    disabledProviderAccountKeys.has(accountKey));
             const accountStatus = account.type === "internal"
                 ? "internal"
-                : disabledAccountKeys.has(accountKey)
+                : isDisabled
                     ? "disabled"
-                    : expired
+                    : isAnthropicAccount && expired
                         ? "expired"
-                        : !allowed
+                        : isAnthropicAccount && !allowed
                             ? "excluded"
-                            : accountInventoryLoaded &&
-                                account.type === "oauth" &&
-                                !isStored
+                            : accountInventoryLoaded && isAnthropicAccount && !isStored
                                 ? "removed"
                                 : cooling
                                     ? "cooling"
@@ -1782,11 +1803,11 @@ export async function createProxyStartApp(params) {
                 cooling,
                 status: accountStatus,
                 allowed: account.type === "internal" ? undefined : allowed,
-                expired: account.type === "oauth" ? expired : undefined,
+                expired: isAnthropicAccount ? expired : undefined,
             };
         });
         const representedAccountKeys = new Set(accountRows
-            .filter((account) => account.type === "oauth")
+            .filter((account) => account.type === "oauth" || account.type === "api_key")
             .map((account) => normalizeAnthropicAccountKey(account.label)));
         for (const accountKey of storedAccountKeys) {
             if (representedAccountKeys.has(accountKey)) {

package/dist/proxy/codexAccountUsage.d.ts

@@ -6,8 +6,13 @@
  * map onto the shared AccountQuota session/weekly fields so the same routing,
  * cooldown, and display code works for both providers.
  */
+import type { CodexProxyStatusAccountIdentity } from "../types/index.js";
 import type { AccountQuota, CodexRateLimits, CodexUsageFetchResult, ProxyPassthroughAccount } from "../types/index.js";
 export declare const CODEX_ACCOUNT_PREFIX = "codex:";
+/** Keep an account label in the Codex namespace used by its token store. */
+export declare function normalizeCodexAccountKey(value: string): string;
+/** Resolve the provider-qualified key used to render a proxy status row. */
+export declare function resolveProxyStatusAccountIdentity(label: string, type: string): CodexProxyStatusAccountIdentity;
 /** Enumerate Codex OAuth accounts from the token store for usage refresh. */
 export declare function listCodexAccountsForUsage(): Promise<ProxyPassthroughAccount[]>;
 /** Normalise a Codex rate-limit block into the shared AccountQuota shape. */

package/dist/proxy/codexAccountUsage.js

@@ -7,9 +7,27 @@
  * cooldown, and display code works for both providers.
  */
 import { tokenStore } from "../auth/tokenStore.js";
+import { normalizeAnthropicAccountKey } from "./accountSelection.js";
 import { CODEX_ORIGINATOR, CODEX_USAGE_URL, CODEX_USER_AGENT, decodeCodexAccessToken, resolveCodexAccountId, } from "../auth/codexOAuth.js";
 import { logger } from "../utils/logger.js";
 export const CODEX_ACCOUNT_PREFIX = "codex:";
+/** Keep an account label in the Codex namespace used by its token store. */
+export function normalizeCodexAccountKey(value) {
+    const trimmed = value.trim();
+    return trimmed.startsWith(CODEX_ACCOUNT_PREFIX)
+        ? trimmed
+        : `${CODEX_ACCOUNT_PREFIX}${trimmed}`;
+}
+/** Resolve the provider-qualified key used to render a proxy status row. */
+export function resolveProxyStatusAccountIdentity(label, type) {
+    if (type === "oauth" || type === "api_key") {
+        return { provider: "anthropic", key: normalizeAnthropicAccountKey(label) };
+    }
+    if (type === "codex-oauth") {
+        return { provider: "codex", key: normalizeCodexAccountKey(label) };
+    }
+    return { provider: "other", key: null };
+}
 /** Enumerate Codex OAuth accounts from the token store for usage refresh. */
 export async function listCodexAccountsForUsage() {
     const keys = await tokenStore.listByPrefix(CODEX_ACCOUNT_PREFIX);

package/dist/proxy/codexFallback.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Anthropic Messages API fallback over the pooled Codex Responses transport.
+ *
+ * This module deliberately contains only wire-format conversion and buffered
+ * SSE parsing. Account selection, OAuth, cooldowns, and quota persistence stay
+ * in the native Codex proxy handler so fallback traffic follows the same pool
+ * rules as a native Codex request.
+ */
+import type { ClaudeRequest, CodexFallbackResult, CodexResponsesRequest } from "../types/index.js";
+export declare class CodexFallbackResponseError extends Error {
+    readonly status: number;
+    readonly responseBody: string;
+    constructor(status: number, responseBody: string);
+}
+/** Convert a Claude Messages request into the ChatGPT Codex Responses shape. */
+export declare function convertClaudeRequestToCodex(body: ClaudeRequest, model: string): CodexResponsesRequest;
+/**
+ * Parse a complete Codex Responses SSE stream before emitting Claude output.
+ *
+ * A missing terminal event, malformed JSON, terminal error, or empty response
+ * is rejected. That makes it safe for the caller to try the next configured
+ * fallback without ever replaying output already sent to a client.
+ */
+export declare function parseCodexFallbackSSE(sse: string): CodexFallbackResult;
+/** Consume and validate a native Codex response before producing Claude output. */
+export declare function consumeCodexFallbackResponse(response: Response): Promise<CodexFallbackResult>;

package/dist/proxy/codexFallback.js

@@ -0,0 +1,371 @@
+/**
+ * Anthropic Messages API fallback over the pooled Codex Responses transport.
+ *
+ * This module deliberately contains only wire-format conversion and buffered
+ * SSE parsing. Account selection, OAuth, cooldowns, and quota persistence stay
+ * in the native Codex proxy handler so fallback traffic follows the same pool
+ * rules as a native Codex request.
+ */
+import { extractCodexUsage } from "./codexUsage.js";
+export class CodexFallbackResponseError extends Error {
+    status;
+    responseBody;
+    constructor(status, responseBody) {
+        super(`Codex fallback request returned HTTP ${status}`);
+        this.name = "CodexFallbackResponseError";
+        this.status = status;
+        this.responseBody = responseBody;
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function asNonEmptyString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function buildSystemInstructions(body) {
+    if (typeof body.system === "string") {
+        return body.system || undefined;
+    }
+    if (Array.isArray(body.system)) {
+        const text = body.system
+            .map((block) => (typeof block.text === "string" ? block.text : ""))
+            .filter(Boolean)
+            .join("\n\n");
+        return text || undefined;
+    }
+    return undefined;
+}
+function imageUrlForBlock(block) {
+    if (block.source.type === "url" && block.source.url) {
+        return block.source.url;
+    }
+    if (block.source.type === "base64" && block.source.data) {
+        return `data:${block.source.media_type ?? "image/png"};base64,${block.source.data}`;
+    }
+    return undefined;
+}
+function flattenClaudeContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    return content
+        .map((block) => {
+        switch (block.type) {
+            case "text":
+                return block.text;
+            case "thinking":
+                return block.thinking;
+            case "image":
+                return "[image attachment]";
+            case "tool_use":
+                return `[tool call ${block.name}] ${JSON.stringify(block.input ?? {})}`;
+            case "tool_result":
+                return flattenClaudeContent(block.content);
+        }
+    })
+        .join("\n");
+}
+function toCodexContentPart(block, role) {
+    const textType = role === "assistant" ? "output_text" : "input_text";
+    switch (block.type) {
+        case "text":
+            return { type: textType, text: block.text };
+        case "thinking":
+            return { type: textType, text: block.thinking };
+        case "image": {
+            const imageUrl = imageUrlForBlock(block);
+            if (role === "user" && imageUrl) {
+                return { type: "input_image", image_url: imageUrl };
+            }
+            return { type: textType, text: "[image attachment]" };
+        }
+    }
+}
+function convertClaudeMessage(role, content) {
+    if (typeof content === "string") {
+        return [
+            {
+                role,
+                content: [
+                    {
+                        type: role === "assistant" ? "output_text" : "input_text",
+                        text: content,
+                    },
+                ],
+            },
+        ];
+    }
+    const input = [];
+    let messageContent = [];
+    const flushMessage = () => {
+        if (messageContent.length === 0) {
+            return;
+        }
+        input.push({ role, content: messageContent });
+        messageContent = [];
+    };
+    for (const block of content) {
+        if (block.type === "tool_use") {
+            flushMessage();
+            input.push({
+                type: "function_call",
+                call_id: block.id,
+                name: block.name,
+                arguments: JSON.stringify(block.input ?? {}),
+            });
+            continue;
+        }
+        if (block.type === "tool_result") {
+            flushMessage();
+            input.push({
+                type: "function_call_output",
+                call_id: block.tool_use_id,
+                output: flattenClaudeContent(block.content),
+            });
+            continue;
+        }
+        messageContent.push(toCodexContentPart(block, role));
+    }
+    flushMessage();
+    return input;
+}
+/** Convert a Claude Messages request into the ChatGPT Codex Responses shape. */
+export function convertClaudeRequestToCodex(body, model) {
+    const input = body.messages.flatMap((message) => convertClaudeMessage(message.role, message.content));
+    const request = {
+        model,
+        input,
+        stream: true,
+        // ChatGPT's backend rejects requests unless this is explicitly false.
+        store: false,
+    };
+    const instructions = buildSystemInstructions(body);
+    if (instructions) {
+        request.instructions = instructions;
+    }
+    if (body.tools && body.tools.length > 0) {
+        request.tools = body.tools.map((tool) => ({
+            type: "function",
+            name: tool.name,
+            ...(tool.description ? { description: tool.description } : {}),
+            parameters: tool.input_schema,
+        }));
+    }
+    if (body.tool_choice) {
+        switch (body.tool_choice.type) {
+            case "any":
+                request.tool_choice = "required";
+                break;
+            case "tool":
+                request.tool_choice = { type: "function", name: body.tool_choice.name };
+                break;
+            default:
+                request.tool_choice = body.tool_choice.type;
+                break;
+        }
+    }
+    // The ChatGPT Codex backend is not the public Responses API. In particular,
+    // it rejects `max_output_tokens`, and its model-owned sampling controls do
+    // not map safely from Anthropic's `temperature` or `top_p`. Omit all three
+    // so the backend uses its supported defaults instead of rejecting fallback
+    // traffic before it can be served.
+    return request;
+}
+function parseFunctionArguments(value) {
+    if (isRecord(value)) {
+        return value;
+    }
+    if (typeof value !== "string") {
+        throw new Error("Codex fallback function call is missing JSON arguments");
+    }
+    try {
+        const parsed = JSON.parse(value || "{}");
+        if (!isRecord(parsed)) {
+            throw new Error("not an object");
+        }
+        return parsed;
+    }
+    catch {
+        throw new Error("Codex fallback function call returned invalid JSON arguments");
+    }
+}
+function outputTextFromItem(value) {
+    if (!isRecord(value) ||
+        value.type !== "message" ||
+        !Array.isArray(value.content)) {
+        return "";
+    }
+    return value.content
+        .filter(isRecord)
+        .filter((part) => part.type === "output_text")
+        .map((part) => (typeof part.text === "string" ? part.text : ""))
+        .join("");
+}
+function addFunctionCall(item, toolCalls) {
+    if (item.type !== "function_call") {
+        return;
+    }
+    const callId = asNonEmptyString(item.call_id);
+    const name = asNonEmptyString(item.name);
+    if (!callId || !name) {
+        throw new Error("Codex fallback function call is missing an id or name");
+    }
+    toolCalls.set(callId, {
+        toolCallId: callId,
+        toolName: name,
+        args: parseFunctionArguments(item.arguments),
+    });
+}
+function parseSSEPayloads(sse) {
+    const frames = sse.replace(/\r\n?/g, "\n").split("\n\n");
+    const parsed = [];
+    for (const frame of frames) {
+        if (!frame.trim()) {
+            continue;
+        }
+        let event;
+        const data = [];
+        for (const line of frame.split("\n")) {
+            if (!line || line.startsWith(":")) {
+                continue;
+            }
+            if (line.startsWith("event:")) {
+                event = line.slice("event:".length).trim();
+                continue;
+            }
+            if (line.startsWith("data:")) {
+                data.push(line.slice("data:".length).trimStart());
+                continue;
+            }
+            if (line.startsWith("id:") || line.startsWith("retry:")) {
+                continue;
+            }
+            // SSE permits extension fields that this parser does not consume.
+            continue;
+        }
+        if (data.length === 0) {
+            continue;
+        }
+        const raw = data.join("\n").trim();
+        if (raw === "[DONE]") {
+            continue;
+        }
+        try {
+            const payload = JSON.parse(raw);
+            if (!isRecord(payload)) {
+                throw new Error("not an object");
+            }
+            parsed.push({ event, payload });
+        }
+        catch {
+            throw new Error("Codex fallback stream contains malformed JSON");
+        }
+    }
+    return parsed;
+}
+function responseStatus(payload) {
+    const response = payload.response;
+    return isRecord(response) ? asNonEmptyString(response.status) : undefined;
+}
+function outputTextFromResponse(payload) {
+    const response = payload.response;
+    if (!isRecord(response) || !Array.isArray(response.output)) {
+        return "";
+    }
+    return response.output.map(outputTextFromItem).join("");
+}
+/**
+ * Parse a complete Codex Responses SSE stream before emitting Claude output.
+ *
+ * A missing terminal event, malformed JSON, terminal error, or empty response
+ * is rejected. That makes it safe for the caller to try the next configured
+ * fallback without ever replaying output already sent to a client.
+ */
+export function parseCodexFallbackSSE(sse) {
+    const payloads = parseSSEPayloads(sse);
+    const toolCalls = new Map();
+    let textFromDeltas = "";
+    let textFromCompletedItems = "";
+    let textFromResponse = "";
+    let usage;
+    let sawCompleted = false;
+    for (const { event, payload } of payloads) {
+        const type = asNonEmptyString(payload.type) ?? event;
+        if (!type) {
+            throw new Error("Codex fallback stream event is missing a type");
+        }
+        if (type === "error" ||
+            type === "response.failed" ||
+            type === "response.incomplete") {
+            throw new Error(`Codex fallback stream terminated with ${type}`);
+        }
+        if (type === "response.output_text.delta") {
+            if (typeof payload.delta !== "string") {
+                throw new Error("Codex fallback text delta is malformed");
+            }
+            textFromDeltas += payload.delta;
+            continue;
+        }
+        if (type === "response.output_item.done") {
+            if (!isRecord(payload.item)) {
+                throw new Error("Codex fallback output item is malformed");
+            }
+            addFunctionCall(payload.item, toolCalls);
+            textFromCompletedItems += outputTextFromItem(payload.item);
+            continue;
+        }
+        if (type !== "response.completed") {
+            continue;
+        }
+        if (sawCompleted) {
+            throw new Error("Codex fallback stream emitted more than one completion event");
+        }
+        sawCompleted = true;
+        const status = responseStatus(payload);
+        if (status !== "completed") {
+            throw new Error(`Codex fallback stream completed with unexpected status ${status ?? "unknown"}`);
+        }
+        const parsedUsage = extractCodexUsage(payload);
+        if (parsedUsage) {
+            usage = {
+                input: parsedUsage.inputTokens,
+                output: parsedUsage.outputTokens,
+                total: parsedUsage.inputTokens + parsedUsage.outputTokens,
+                cacheReadTokens: parsedUsage.cacheReadTokens,
+                cacheCreationTokens: parsedUsage.cacheCreationTokens,
+            };
+        }
+        textFromResponse = outputTextFromResponse(payload);
+    }
+    if (!sawCompleted) {
+        throw new Error("Codex fallback stream ended before response.completed");
+    }
+    const text = textFromDeltas || textFromCompletedItems || textFromResponse;
+    const resolvedToolCalls = [...toolCalls.values()];
+    if (!text && resolvedToolCalls.length === 0) {
+        throw new Error("Codex fallback returned no content or tool calls");
+    }
+    return {
+        text,
+        toolCalls: resolvedToolCalls,
+        ...(usage ? { usage } : {}),
+        finishReason: resolvedToolCalls.length > 0 ? "tool_use" : "end_turn",
+    };
+}
+/** Consume and validate a native Codex response before producing Claude output. */
+export async function consumeCodexFallbackResponse(response) {
+    if (!response.ok) {
+        throw new CodexFallbackResponseError(response.status, await response.text().catch(() => ""));
+    }
+    if (!response.body) {
+        throw new Error("Codex fallback returned an empty stream");
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!contentType.toLowerCase().includes("text/event-stream")) {
+        // Consume it before failing so the underlying connection can be reused.
+        await response.text().catch(() => "");
+        throw new Error("Codex fallback returned a non-SSE response");
+    }
+    return parseCodexFallbackSSE(await response.text());
+}

package/dist/server/routes/claudeProxyRoutes.d.ts

@@ -12,7 +12,7 @@
 import { buildTranslationOptions } from "../../proxy/proxyTranslationEngine.js";
 import { ProxyTracer } from "../../proxy/proxyTracer.js";
 import { isPermanentRefreshFailure } from "../../proxy/tokenRefresh.js";
-import type { AccountAllowlist, AccountAdmissionLease, JsonObject, AccountCooldownPlan, AccountQuota, AccountQuotaWindow, AccountUsageFetchResult, AnthropicAttemptLogger, AnthropicAuthRetryResult, AnthropicEntitlementFailure, AnthropicLoopState, AnthropicScopedExhaustion, AnthropicNonOkResult, AnthropicSuccessResult, AnthropicUpstreamFetchResult, ClaudeFinalRequestLogger, ClaudeLoggedErrorBuilder, ClaudeRequest, ClaudeProxyRouteRuntimeOptions, ModelRouterInterface, ParsedClaudeError, ProxyAccountRoutingDecision, ProxyAccountSortMetrics, ProxyBodyCaptureLogger, ProxyLimitsRefreshResponse, ProxyQuotaCooldownUpdate, ProxyOveragePolicy, ProxyPassthroughAccount, QueuedAccountAdmission, RouteGroup, RuntimeAccountState, ServerContext, StreamTerminalOutcome } from "../../types/index.js";
+import type { AccountAllowlist, AccountAdmissionLease, JsonObject, AccountCooldownPlan, AccountQuota, AccountQuotaWindow, AccountUsageFetchResult, AnthropicAttemptLogger, AnthropicAuthRetryResult, AnthropicEntitlementFailure, AnthropicInvalidRequestFailure, AnthropicLoopState, AnthropicScopedExhaustion, AnthropicNonOkResult, AnthropicSuccessResult, AnthropicUpstreamFetchResult, ClaudeFinalRequestLogger, ClaudeLoggedErrorBuilder, ClaudeRequest, ClaudeProxyRouteRuntimeOptions, ModelRouterInterface, ParsedClaudeError, ProxyAccountRoutingDecision, ProxyAccountSortMetrics, ProxyBodyCaptureLogger, ProxyLimitsRefreshResponse, ProxyQuotaCooldownUpdate, ProxyOveragePolicy, ProxyPassthroughAccount, QueuedAccountAdmission, RouteGroup, RuntimeAccountState, ServerContext, StreamTerminalOutcome } from "../../types/index.js";
 declare function tryAcquireAccountAdmission(accountKey: string, capacity: number | undefined): AccountAdmissionLease | undefined;
 declare function enqueueAccountAdmission(accountKey: string, capacity: number): QueuedAccountAdmission;
 declare function acquireAccountAdmission(accountKey: string, capacity: number, abortSignal?: AbortSignal, timeoutMs?: number): Promise<AccountAdmissionLease | undefined>;
@@ -173,6 +173,18 @@ declare function trackUpstreamReadableStream(source: ReadableStream<Uint8Array>)
     stream: ReadableStream<Uint8Array>;
     outcome: Promise<StreamTerminalOutcome>;
 };
+/**
+ * Remove what a borrower has no business seeing.
+ *
+ * `x-neurolink-account` carries the lender's account label, which for an OAuth
+ * account is their email address; the pool counters describe the shape of a
+ * pool that is not the borrower's. The borrower's own routing needs the quota
+ * and grant headers, and nothing else here.
+ *
+ * A no-op for the node's own traffic, where these headers are exactly the
+ * diagnostics the operator wants.
+ */
+declare function redactHeadersForBorrower(headers: Record<string, string>): Record<string, string>;
 declare function executeClaudeFallbackTranslation(args: {
     ctx: ServerContext;
     body: ClaudeRequest;
@@ -203,6 +215,7 @@ declare function executeClaudeFallbackTranslation(args: {
     idleTimeoutMs?: number;
 }): Promise<unknown>;
 declare function executeClaudeFallbackWithRetry(args: Parameters<typeof executeClaudeFallbackTranslation>[0]): Promise<unknown>;
+declare function getCodexFallbackInvalidRequestFailure(error: unknown): AnthropicInvalidRequestFailure | null;
 declare function buildClaudeAnthropicFailureResponse(args: {
     tracer?: ProxyTracer;
     requestStartTime: number;
@@ -329,6 +342,7 @@ declare function handleAnthropicNonOkResponse(args: {
         contentType?: string;
     } | null;
     entitlementFailure: AnthropicEntitlementFailure | null;
+    allowConfiguredModelFallback?: boolean;
 }): Promise<AnthropicNonOkResult>;
 /**
  * Detect Anthropic's anti-abuse / request-construction 429.
@@ -388,6 +402,11 @@ export declare function parseClaudeErrorBody(errBody: string): ParsedClaudeError
  * Detect malformed request errors that should not trigger account/provider failover.
  */
 export declare function isInvalidRequestError(status: number, errBody: string): boolean;
+/**
+ * A 404 for a retired model can be served by an explicitly configured fallback;
+ * other 404s remain terminal so a bad endpoint or resource is never disguised.
+ */
+declare function isAnthropicModelNotFound(status: number, errBody: string): boolean;
 /**
  * A subscription-specific beta rejection. Anthropic returns
  * `400 invalid_request_error` with a message like
@@ -492,7 +511,10 @@ export declare const __testHooks: {
     redactProviderErrorMessage: typeof redactProviderErrorMessage;
     isUpstreamOverload: typeof isUpstreamOverload;
     getOverloadRotationDelayMs: typeof getOverloadRotationDelayMs;
+    redactHeadersForBorrower: typeof redactHeadersForBorrower;
     shouldAttemptClaudeFallback: typeof shouldAttemptClaudeFallback;
+    isAnthropicModelNotFound: typeof isAnthropicModelNotFound;
+    getCodexFallbackInvalidRequestFailure: typeof getCodexFallbackInvalidRequestFailure;
     executeClaudeFallbackWithRetry: typeof executeClaudeFallbackWithRetry;
     buildClaudeAnthropicFailureResponse: typeof buildClaudeAnthropicFailureResponse;
     isAccountEntitlementError: typeof isAccountEntitlementError;