@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
296 lines (276 loc) • 15.1 kB
text/typescript
import type { OcxContext } from "../types";
/**
* Central routed-model identity repair.
*
* Codex sends the SAME GPT-5 identity line to EVERY model at request time (the per-model catalog
* `base_instructions` is ignored on the wire). For routed, non-OpenAI providers that line is both
* wrong (the model isn't GPT-5) and a liability: the previous fix replaced it with text that
* advertised "...served through / running via the opencodex proxy", which leaked our proxy identity
* into the upstream payload — a signature no first-party client (Claude Code, Gemini CLI, Kiro) ever
* sends, and a likely ToS trigger.
*
* The replacement keeps the necessary instruction (don't misreport as GPT-5/OpenAI), names the
* model id that is actually sent on the wire when it is safe to interpolate, and names no proxy.
* Provider-native identity blocks (e.g. the anthropic OAuth "You are a Claude agent..." prefix)
* are layered on TOP of this by the individual adapters; this module never claims to be a specific
* first-party client.
*/
/** Historical exact identity line Codex injected for every model. */
export const CODEX_GPT5_IDENTITY_LINE = "You are Codex, a coding agent based on GPT-5.";
/** Codex CLI 0.145.0+ wording (#622) — still GPT-5 identity, slightly different phrasing. */
export const CODEX_GPT5_IDENTITY_LINE_AGENT = "You are Codex, an agent based on GPT-5.";
/**
* Known Codex identity sentences. Narrow: only "coding agent" / "an agent" + GPT-<major>(.minor)*.
* Avoid a broad `You are Codex.*` rewrite that could touch unrelated content.
*
* The major version is a wildcard because Codex writes the CURRENT generation into this line and
* bumps it: `gpt-6-astra` (upstream #42607) ships "You are Codex, an agent based on GPT-6.".
* Pinning `GPT-5` meant a GPT-6-era prompt routed to a third-party provider kept telling that
* model it was Codex-on-GPT-6 — the exact misattribution this chokepoint exists to remove, silently
* reintroduced by a version bump.
*/
const CODEX_GPT5_IDENTITY_RE =
/You are Codex, (?:a coding agent|an agent) based on GPT-[0-9]+(?:\.[0-9]+)*\./g;
/** Proxy-neutral replacement: no "opencodex proxy" mention, just the GPT-5/OpenAI disclaimer. */
export const NEUTRAL_IDENTITY_LINE = "You are a coding agent. Do not claim to be GPT-5 or to be made by OpenAI.";
/**
* Replace Codex's hardcoded GPT-5 identity line with the proxy-neutral line. Safe to call on any
* system text: when the line is absent (already neutralized, or a provider that never received it)
* the input is returned unchanged. This is the single chokepoint every adapter routes through, so
* the leak can't reappear in one adapter while being fixed in another.
*/
export function neutralizeIdentity(systemText: string): string {
// A callback avoids `$&`, `$'`, and other replacement-string substitutions if this constant ever
// becomes configurable. Keep the same safe form in identifyRoutedModel below.
return systemText.replace(CODEX_GPT5_IDENTITY_RE, () => NEUTRAL_IDENTITY_LINE);
}
function safeRoutedModelIdentity(modelName: string): string | null {
// Callers pass the model id after adapter-specific wire normalization. Brackets remain valid for
// providers that intentionally send a suffix such as `[1m]`; the OpenAI-chat adapter strips that
// suffix before calling us only when modelSuffixBracketStrip is enabled.
const trimmed = modelName.trim();
if (trimmed.length === 0 || trimmed.length > 128) return null;
const allowedPunctuation = "._/@:+-[]~";
for (const char of trimmed) {
const code = char.charCodeAt(0);
const isAsciiAlphaNumeric = (code >= 48 && code <= 57)
|| (code >= 65 && code <= 90)
|| (code >= 97 && code <= 122);
if (!isAsciiAlphaNumeric && !allowedPunctuation.includes(char)) return null;
}
return trimmed;
}
/**
* Identity for a routed model. Callers pass the concrete model id that will be sent upstream, so
* identity questions can name it instead of falling back to Codex/GPT identity inherited from the
* native template.
*/
export function identifyRoutedModel(systemText: string, modelName: string): string {
const replacement = routedIdentityLine(modelName);
return systemText
.replace(CODEX_GPT5_IDENTITY_RE, () => replacement)
.replace(NEUTRAL_IDENTITY_RE, () => replacement)
.replace(ROUTED_IDENTITY_RE, () => replacement);
}
function routedIdentityLine(modelName: string): string {
const identity = safeRoutedModelIdentity(modelName);
return identity
? `You are a coding agent powered by the ${identity}. If asked which model you are, identify as ${identity}. Do not claim to be a different model or to have a different creator.`
: "You are a coding agent powered by the configured model. If asked which model you are, identify as configured model. Do not claim to be GPT-5 or made by OpenAI.";
}
/**
* This proxy's OWN generated identity sentence (both the named and the `configured model`
* fallback form). Codex stores a session's instructions once and replays them verbatim when it
* spawns a sub-agent on a DIFFERENT model (#5217), so a worker inherits the parent's sentence and
* then answers identity questions with the parent's model id.
*
* The pattern is deliberately anchored on the exact wording this module emits — the leading
* "You are a coding agent powered by the " and the matching "If asked which model you are,
* identify as " clause — so it can only ever rewrite text the proxy generated. The model id is
* matched with the same character class `safeRoutedModelIdentity` allows, never `.*`, so user
* prose, fenced code and provider-native identity blocks are out of reach.
*/
const ROUTED_IDENTITY_RE =
/You are a coding agent powered by the (?:configured model|[A-Za-z0-9._/@:+\-[\]~]+)\. If asked which model you are, identify as (?:configured model|[A-Za-z0-9._/@:+\-[\]~]+)\. Do not claim to be (?:a different model or to have a different creator|GPT-5 or made by OpenAI)\./g;
/**
* The model-neutral catalog line. Since #5217 the catalog no longer bakes a model id into
* `base_instructions` — a stored instruction block is replayed to sub-agents on other models —
* so the id is written at request time instead, where the destination is known.
*/
const NEUTRAL_IDENTITY_RE = new RegExp(
NEUTRAL_IDENTITY_LINE.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"),
"g",
);
/**
* True when `text` carries an identity sentence this proxy generated — either a sentence that names
* a model already, or the model-neutral catalog line. Both need request-time attention: the named
* form is renamed for the destination, the neutral form is named for the first time.
*/
export function hasRoutedIdentity(text: string): boolean {
ROUTED_IDENTITY_RE.lastIndex = 0;
NEUTRAL_IDENTITY_RE.lastIndex = 0;
return ROUTED_IDENTITY_RE.test(text) || NEUTRAL_IDENTITY_RE.test(text);
}
/**
* Request-time repair for a routed destination: rewrite an inherited identity sentence so it names
* the model this request is actually sent to. Text without one is returned unchanged.
*/
export function repairRoutedIdentity(text: string, modelName: string): string {
const replacement = routedIdentityLine(modelName);
return text.replace(ROUTED_IDENTITY_RE, () => replacement);
}
/**
* Request-time naming for text that will be handed to a routed model from a stored instruction
* block: rewrite the model-neutral catalog line AND any sentence naming an earlier model so both
* name this request's destination.
*
* This is the parser's entry point. A routed adapter that never calls `identifyRoutedModel` (the
* native-wire adapters build their own system text) would otherwise ship the catalog's neutral line
* with no model name at all, which is what `base_instructions` used to carry before #5217 made the
* on-disk block model-neutral.
*/
export function nameRoutedIdentity(text: string, modelName: string): string {
const replacement = routedIdentityLine(modelName);
// Name the neutral line first, then let the rename pass settle any earlier model id the block
// still carries — including the one just written, which the second pass rewrites to itself.
return repairRoutedIdentity(text.replace(NEUTRAL_IDENTITY_RE, () => replacement), modelName);
}
/**
* Settle this proxy's identity sentence on the model a routed request is actually dispatched to.
*
* The parser writes the CLIENT-selected id (an alias, a namespaced slug, a combo name) because
* routing has not run yet, and only some adapters rename the sentence afterwards: the ones that
* build their own system text and call `identifyRoutedModel`. Every other adapter — the native-wire
* ones and the `runTurn` ones — ships whatever the parser wrote, so a request routed anywhere else
* would hand the upstream an id it never sees, and an inherited sub-agent block the parent's id.
*
* The route owner knows the model id that will be sent, and this is the one place every dispatch
* path (passthrough, runTurn, request build) reads the context from. Text without a sentence of
* ours is returned unchanged, and the same by reference: the guard is a regex test, not a scan of
* every turn's text.
*/
export function renameRoutedIdentityInContext(context: OcxContext, wireModelId: string): OcxContext {
let changed = false;
const mapText = (text: string): string => {
if (!hasRoutedIdentity(text)) return text;
const next = repairRoutedIdentity(text, wireModelId);
if (next !== text) changed = true;
return next;
};
const systemPrompt = context.systemPrompt?.map(mapText);
const messages = context.messages.map((message) => {
// Instruction text only. A user turn is the caller's own content, and every other role is
// either model output or tool output — none of it is ours to rewrite.
if (message.role !== "developer") return message;
const content = message.content;
if (typeof content === "string") {
const next = mapText(content);
return next === content ? message : { ...message, content: next };
}
let partChanged = false;
const parts = content.map((part) => {
if (part.type !== "text" || !hasRoutedIdentity(part.text)) return part;
const next = repairRoutedIdentity(part.text, wireModelId);
if (next === part.text) return part;
partChanged = true;
return { ...part, text: next };
});
if (!partChanged) return message;
changed = true;
return { ...message, content: parts };
});
if (!changed) return context;
return { ...context, ...(systemPrompt ? { systemPrompt } : {}), messages };
}
/** A content part carrying no text is not content; every other part shape stays. */
function isEmptyTextPart(part: unknown): boolean {
if (!part || typeof part !== "object" || Array.isArray(part)) return false;
const record = part as Record<string, unknown>;
return typeof record.text === "string" && record.text.length === 0;
}
/**
* Apply `repair` to the instruction text of a Responses request body: the top-level `instructions`
* string and every developer/system `input` message. Nothing else is in reach — user turns, tool
* output and assistant history are the caller's content.
*
* Stripping consumes text rather than replacing it, so a value can end up empty. An empty
* `instructions` string is a different payload from an absent key, and an empty developer message is
* a message the caller never wrote, so both are removed instead of sent blank.
*/
export function repairIdentityInResponsesBody(body: unknown, repair: (text: string) => string): unknown {
if (!body || typeof body !== "object" || Array.isArray(body)) return body;
const record = body as Record<string, unknown>;
let changed = false;
const mapText = (text: string): string => {
if (!hasRoutedIdentity(text)) return text;
const next = repair(text);
if (next !== text) changed = true;
return next;
};
let instructions = record.instructions;
if (typeof instructions === "string") {
const next = mapText(instructions);
if (next !== instructions) {
changed = true;
instructions = next.length > 0 ? next : undefined;
}
}
const mapInputItem = (item: unknown): unknown => {
if (!item || typeof item !== "object" || Array.isArray(item)) return item;
const message = item as Record<string, unknown>;
if (message.type !== undefined && message.type !== "message") return item;
if (message.role !== "developer" && message.role !== "system") return item;
if (typeof message.content === "string") {
const next = mapText(message.content);
if (next === message.content) return item;
return next.length > 0 ? { ...message, content: next } : undefined;
}
if (!Array.isArray(message.content)) return item;
let partChanged = false;
const content = message.content.map((part: unknown) => {
if (!part || typeof part !== "object" || Array.isArray(part)) return part;
const partRecord = part as Record<string, unknown>;
if (typeof partRecord.text !== "string") return part;
const next = mapText(partRecord.text);
if (next === partRecord.text) return part;
partChanged = true;
return { ...partRecord, text: next };
});
if (!partChanged) return item;
return content.every(isEmptyTextPart) ? undefined : { ...message, content };
};
const input = Array.isArray(record.input)
? record.input.flatMap((item: unknown) => {
const next = mapInputItem(item);
return next === undefined ? [] : [next];
})
: record.input;
if (!changed) return body;
const next: Record<string, unknown> = { ...record, input };
// `...record` carries the original key, so a removed instruction has to be deleted rather than
// merely left out of the spread.
if (instructions === undefined) delete next.instructions;
else next.instructions = instructions;
return next;
}
/**
* Request-time repair for a native (Codex/OpenAI) destination: drop an inherited routed identity
* sentence instead of rewriting it. A native worker keeps Codex's own identity wording, which the
* client already sends in its `model_switch` block; re-stating a routed sentence there would tell
* a first-party model it is some third-party model.
*
* The model-neutral catalog line goes too. It is proxy-authored text as well, and unlike the named
* form it does not even have to be inherited from a routed parent: the on-disk catalog block
* carries it since #5217, so it rides along on every instruction block Codex replays to a worker.
* Left in place it reaches a first-party model as an instruction that contradicts the model_switch
* identity Codex sends for the same request.
*/
export function stripRoutedIdentity(text: string): string {
return text
.replace(ROUTED_IDENTITY_RE, () => "")
.replace(NEUTRAL_IDENTITY_RE, () => "")
.replace(/\n{3,}/g, "\n\n")
.trim();
}
/** The catalog (static, on-disk) replacement for `base_instructions`. Same neutral wording. */
export const NEUTRAL_IDENTITY_CATALOG = NEUTRAL_IDENTITY_LINE;