@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
95 lines (85 loc) • 5.49 kB
text/typescript
import type { RequestFailureCause } from "../usage/telemetry-contract";
/**
* Meta's Muse Code subscription refusal (#8352).
*
* A Muse Code subscription key is valid, and Meta scopes it to the Muse Code client. Every request
* from another client is refused with HTTP 403 and one fixed sentence, so the credential is not
* rejected and no login can lift the restriction. Classifying it as `permission_denied` /
* `credential-rejected` sent operators to re-authenticate a key that works exactly as Meta sold it;
* the refusal is a plan restriction whose only remedy is a pay-as-you-go key.
*
* The match is deliberately narrow, in the shape of `anthropic-billing-refusal.ts`: a 403, an
* OpenAI-compatible `error` envelope, and that whole sentence. A missed match leaves the turn
* failing with Meta's own text, which is already legible; a loose match would relabel an unrelated
* permission denial that the operator fixes another way.
*/
/** The envelope and message are upstream-controlled input; this bounds what is read. */
const MAX_REFUSAL_CHARS = 8 * 1024;
/** Meta's two sentences, whole. A suffix, prefix, or reworded copy is a different refusal. */
const PLAN_REFUSAL = /^This API key is billed to a Muse Code subscription\. Muse Code subscriptions cover requests from the Muse Code client only\. Use it in Muse Code, or use a pay-as-you-go API key for other clients\.?$/i;
/** Classes Meta has been observed to put on this refusal; anything else is a different verdict. */
const PERMISSION_TYPES = new Set(["permission_error", "permission_denied", "invalid_request_error"]);
const PERMISSION_CODES = new Set(["permission_denied", "permission_error", "subscription_required", "forbidden"]);
/**
* The one sentence a client sees instead of Meta's refusal.
*
* It names the restriction, the fact that no retry or re-login changes it, and the supported path.
* It is also a proxy literal that later classification passes recognize verbatim, so the Chat and
* Anthropic formatters cannot fold it back into `permission_denied`.
*/
export const META_MUSE_PLAN_REFUSAL_MESSAGE = "Meta rejected this request because the configured key is billed to a Muse Code subscription, and Meta restricts Muse Code subscription keys to the Muse Code client. This is a plan restriction on a valid credential, not an expired one, so a new login cannot lift it. Use a pay-as-you-go Meta API key with the meta-model provider instead (export it as META_MODEL_API_KEY); OpenCodex cannot serve this request with a Muse Code subscription key.";
function record(value: unknown): value is Record<string, unknown> {
return value !== null && typeof value === "object" && !Array.isArray(value);
}
/** Only a 403 error envelope carrying Meta's whole sentence is evidence. */
export function isMetaMusePlanRefusal(status: number, payload: unknown): boolean {
if (status !== 403 || !record(payload) || !record(payload.error)) return false;
const error = payload.error;
if (typeof error.message !== "string" || error.message.length > MAX_REFUSAL_CHARS) return false;
if (error.type != null && (typeof error.type !== "string" || !PERMISSION_TYPES.has(error.type))) return false;
if (error.code != null && (typeof error.code !== "string" || !PERMISSION_CODES.has(error.code))) return false;
return PLAN_REFUSAL.test(error.message.trim());
}
/**
* The same evidence after HTTP error formatting, which frames the body as `Provider error 403: …`.
* A bare sentence body is accepted too: the refusal is the whole payload either way, and the
* sentence is the only thing that grants the verdict.
*/
export function isMetaMusePlanFailure(status: number, message: string): boolean {
if (status !== 403 || typeof message !== "string" || message.length > MAX_REFUSAL_CHARS) return false;
let text = message.trim();
// This proxy's own copy re-enters later formatters; keep it in the same class without re-reading
// upstream bytes.
if (text === META_MUSE_PLAN_REFUSAL_MESSAGE) return true;
const prefix = `Provider error ${status}: `;
if (text.startsWith(prefix)) text = text.slice(prefix.length).trim();
if (text === META_MUSE_PLAN_REFUSAL_MESSAGE) return true;
try {
const payload: unknown = JSON.parse(text);
if (isMetaMusePlanRefusal(status, payload)) return true;
// The proxy's own error envelope carrying its own sentence: a later pass that re-parses the
// rewritten body keeps the class.
if (record(payload) && record(payload.error) && payload.error.message === META_MUSE_PLAN_REFUSAL_MESSAGE) return true;
} catch {
// A non-JSON body falls through to the whole-sentence test below.
}
return PLAN_REFUSAL.test(text);
}
/**
* Stamp the plan-restriction cause on a request row and return the client sentence, or undefined
* for any other failure.
*
* The cause is stamped at the site that proved it: the status alone cannot tell this 403 from a
* rejected credential, and `quota-exhausted` is the closed roster's plan/entitlement class, whose
* resend verdict is `refused-futile`. `causeHint` outranks the status table in
* `deriveRequestFailureCause`, so both the row and the attempt report the plan class.
*/
export function stampMetaMusePlanRefusal(
logCtx: { causeHint?: RequestFailureCause },
status: number,
bodyText: string,
): string | undefined {
if (!isMetaMusePlanFailure(status, bodyText)) return undefined;
logCtx.causeHint = "quota-exhausted";
return META_MUSE_PLAN_REFUSAL_MESSAGE;
}