@bitkyc08/opencodex 2.64.0-preview.20260923 → 2.65.0-preview.20260925

package/src/adapters/identity.ts

@@ -1,3 +1,5 @@
+import type { OcxContext } from "../types";
+
 /**
  * Central routed-model identity repair.
  *
@@ -72,11 +74,221 @@ function safeRoutedModelIdentity(modelName: string): string | null {
  * 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);
-  const replacement = identity
+  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.";
-  return systemText.replace(CODEX_GPT5_IDENTITY_RE, () => replacement);
+}
+
+/**
+ * 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. */

package/src/adapters/openai-chat/passthrough.ts

@@ -96,6 +96,7 @@ export function buildOpenAIChatPassthroughRequest(
 
   if (modelInList(provider.noTemperatureModels, modelId)) delete body.temperature;
   if (modelInList(provider.noTopPModels, modelId)) delete body.top_p;
+  if (modelInList(provider.noStopModels, modelId)) delete body.stop;
   if (modelInList(provider.noPenaltyModels, modelId)) {
     delete body.presence_penalty;
     delete body.frequency_penalty;