@bitkyc08/opencodex 2.47.0 → 2.48.0

package/src/server/claude-messages.ts

@@ -30,12 +30,13 @@ import {
 import { clearableDeadline, idleDeadline } from "../lib/abort";
 import { estimateTokens } from "../lib/token-estimate";
 import { NoEligiblePolicyCandidateError, UnknownRoutingPolicyError, routeModel } from "../router";
+import { registryEntryForProviderDestination } from "../providers/registry";
 import { evidenceFromBody } from "../routing/request-evidence";
 import { resolveWireProtocolOverride } from "./adapter-resolve";
 import type { OcxConfig } from "../types";
 import { readJsonRequestBody } from "./request-decompress";
 import { addFinalRequestLog, httpStatusForRequestLogTerminal, recordFirstOutput, type RequestLogContext, type RequestLogEntry } from "./request-log";
-import { conversationIdFromClaudeMetadata } from "./request-log-conversation";
+import { conversationIdFromClaudeMetadata, normalizeLogConversationId, sessionLaneIdFromRequest } from "./request-log-conversation";
 import { responseWithDeferredRequestLog } from "./relay";
 import { handleResponses } from "./responses";
 import {
@@ -786,8 +787,12 @@ async function handleClaudeMessagesWithBudget(
   // bodies: it 400s on sampling params ("Unsupported parameter: max_output_tokens",
   // verified live 2026-07-11). Strip them for that route; routed providers keep them.
   let nativeRoute = false;
+  let opencodeGoRoute = false;
   try {
     const route = routeModel(config, internalBody.model as string, evidenceFromBody(internalBody));
+    // Match the fixed key-auth destination before per-model wire overrides, including
+    // renamed Go providers without treating custom or lookalike URLs as Go.
+    opencodeGoRoute = registryEntryForProviderDestination(route.provider)?.id === "opencode-go";
     // Settle the wire once so the sampling decision below reads the effective
     // adapter rather than the provider-wide default (#404).
     route.provider = resolveWireProtocolOverride(route.providerName, route.modelId, route.provider, "anthropic");
@@ -851,15 +856,27 @@ async function handleClaudeMessagesWithBudget(
       headers.set("chatgpt-account-id", token.chatgptAccountId);
     }
   }
-  if (nativeRoute) {
+  if (opencodeGoRoute) {
+    const session = req.headers.get("x-opencode-session");
+    if (session) headers.set("x-opencode-session", session);
+  }
+  const hasExplicitGoSession = opencodeGoRoute
+    && (sessionLaneIdFromRequest(headers) !== undefined
+      || normalizeLogConversationId(headers.get("x-opencode-session")) !== undefined);
+  const synthesizeGoSession = opencodeGoRoute && !hasExplicitGoSession
+    && isRec(anthropicBody)
+    && conversationIdFromClaudeMetadata(isRec(anthropicBody.metadata) ? anthropicBody.metadata : undefined) !== undefined;
+  // Go can also use the Responses adapter; its eligibility gate must win on both wires.
+  if (opencodeGoRoute ? synthesizeGoSession : nativeRoute) {
     // ChatGPT-backend prompt-cache affinity rides the session_id HEADER (codex
     // clients always send their session uuid; devlog 090 follow-up: body-level
     // prompt_cache_key alone still yielded cached_tokens:0). Claude Code never sends
-    // the header, so synthesize a stable per-session uuid from the same cache key —
+    // the header, so synthesize a stable per-session uuid from the same cache key.
+    // Routed Go requests need this lane too for their x-opencode-session affinity —
     // but ONLY for a real per-session key (metadata.user_id). The system-hash fallback
     // key is shared across Desktop conversations, and a shared session_id's backend
     // semantics are unproven (audit 133 R2#3): body prompt_cache_key only there.
-    if (cacheKeySource === "metadata" && !headers.has("session_id") && typeof internalBody.prompt_cache_key === "string") {
+    if (cacheKeySource === "metadata" && (synthesizeGoSession || !headers.has("session_id")) && typeof internalBody.prompt_cache_key === "string") {
       headers.set("session_id", uuidFromHex(internalBody.prompt_cache_key));
     }
   }

package/src/server/live.ts

@@ -86,39 +86,29 @@ export const LIVE_CLIENT_PROTOCOL_HEADERS = [
  *
  * When `OCX_LIVE_FRAME_LOG` is set to a file path, every relayed sideband frame appends one
  * JSONL record: direction, frame kind, byte length, and whether the payload contains U+FFFD.
- * Privacy: full frame payloads are never written — only when U+FFFD is present, a short
- * excerpt around the first replacement character is included so the corruption point can be
- * attributed (upstream vs relay vs client). Disabled entirely when the env var is unset.
+ * Privacy: no frame content is written, including excerpts around replacement characters.
+ * For binary frames, U+FFFD may also be introduced by UTF-8 decoding; the flag alone does not
+ * identify the source of corruption. Disabled entirely when the env var is unset.
  */
 export const LIVE_FRAME_LOG_ENV = "OCX_LIVE_FRAME_LOG";
-const LIVE_FRAME_LOG_CONTEXT_CHARS = 24;
-
-function fffdContext(text: string): string | undefined {
-  const idx = text.indexOf("\uFFFD");
-  if (idx < 0) return undefined;
-  const start = Math.max(0, idx - LIVE_FRAME_LOG_CONTEXT_CHARS);
-  const end = Math.min(text.length, idx + LIVE_FRAME_LOG_CONTEXT_CHARS);
-  return text.slice(start, end);
-}
-
 export function logLiveSidebandFrame(dir: "c2u" | "u2c", data: unknown): void {
   const logPath = process.env[LIVE_FRAME_LOG_ENV];
   if (!logPath) return;
   try {
     let kind: "text" | "binary" = "binary";
     let bytes = 0;
-    let context: string | undefined;
+    let fffd = false;
     if (typeof data === "string") {
       kind = "text";
       bytes = Buffer.byteLength(data);
-      context = fffdContext(data);
+      fffd = data.includes("\uFFFD");
     } else if (data instanceof ArrayBuffer) {
       bytes = data.byteLength;
-      context = fffdContext(new TextDecoder().decode(new Uint8Array(data)));
+      fffd = new TextDecoder().decode(new Uint8Array(data)).includes("\uFFFD");
     } else if (ArrayBuffer.isView(data)) {
       const view = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
       bytes = data.byteLength;
-      context = fffdContext(new TextDecoder().decode(view));
+      fffd = new TextDecoder().decode(view).includes("\uFFFD");
     } else {
       return;
     }
@@ -127,8 +117,7 @@ export function logLiveSidebandFrame(dir: "c2u" | "u2c", data: unknown): void {
       dir,
       kind,
       bytes,
-      fffd: context !== undefined,
-      ...(context !== undefined ? { context } : {}),
+      fffd,
     };
     appendFileSync(logPath, `${JSON.stringify(record)}\n`);
   } catch {

package/src/server/management/agent-settings-routes.ts

@@ -40,6 +40,7 @@ import { clearThreadAccountMap } from "../../codex/routing";
 import { primeCodexPoolQuotas } from "../../codex/auth-api";
 import { DEFAULT_PROVIDER_CONTEXT_CAP, globalContextCapValue, providerContextCap, providerContextCaps, setAllProviderContextCaps, setGlobalContextCapValue, setProviderContextCap } from "../../providers/context-cap";
 import { resolveCodexHomeDir } from "../../codex/home";
+import { MULTI_AGENT_MODE_HINT_RECOMMENDATION } from "../../codex/multi-agent-mode-policy";
 import { readUsageEntries } from "../../usage/log";
 import { getUsageDebugLogEntries } from "../../usage/debug";
 import { parseRange, parseUsageSurface, summarizeUsage } from "../../usage/summary";
@@ -248,6 +249,7 @@ export async function handleAgentSettingsRoutes(ctx: ManagementContext): Promise
       agentsMaxDepth: getAgentsMaxDepth(),
       subagentDeveloperInstructions: getSubagentDeveloperInstructions(),
       multiAgentModeHintText: getMultiAgentModeHintText(),
+      multiAgentModeHintRecommendation: MULTI_AGENT_MODE_HINT_RECOMMENDATION,
       // max_depth is V1-only upstream; this is the global-flag statement, derived
       // server-side so no client can present it as an effective V2 limit.
       agentsMaxDepthAppliesWhenV2Disabled: !enabled,
@@ -421,6 +423,7 @@ export async function handleAgentSettingsRoutes(ctx: ManagementContext): Promise
       agentsMaxDepth: getAgentsMaxDepth(),
       subagentDeveloperInstructions: getSubagentDeveloperInstructions(),
       multiAgentModeHintText: getMultiAgentModeHintText(),
+      multiAgentModeHintRecommendation: MULTI_AGENT_MODE_HINT_RECOMMENDATION,
       agentsMaxDepthAppliesWhenV2Disabled: !enabled,
       warnings,
       catalogRefresh,

package/src/server/responses/collaboration.ts

@@ -241,6 +241,9 @@ export const PROACTIVE_MULTI_AGENT_MODE_TEXT = [
   "This mode remains active until a later multi-agent mode developer message changes it.",
 ].join(" ");
 
+const OPENCODEX_SUBAGENT_GUIDANCE_OPEN_TAG = "<opencodex_subagent_guidance>";
+const OPENCODEX_SUBAGENT_GUIDANCE_CLOSE_TAG = "</opencodex_subagent_guidance>";
+
 export function isV1CollabSurface(parsed: OcxParsedRequest): boolean {
   return collabSurface(parsed) === "v1";
 }
@@ -468,18 +471,15 @@ export async function multiAgentGuidanceText(
       // fallback only for explicit routed/account-qualified ids.
       const promptModel = preferred?.model
         ?? (injectionModel?.includes("/") ? injectionModel : undefined);
-      return `<multi_agent_mode>${applyInjectionPlaceholders(injectionPrompt, promptModel, injectionEffort, roster, fallbackGuidance)}</multi_agent_mode>`;
+      return `${OPENCODEX_SUBAGENT_GUIDANCE_OPEN_TAG}${applyInjectionPlaceholders(injectionPrompt, promptModel, injectionEffort, roster, fallbackGuidance)}${OPENCODEX_SUBAGENT_GUIDANCE_CLOSE_TAG}`;
     }
     if (!preferred && roster === "" && fallbackGuidance === "") return null;
-    let text = "When the active spawn_agent tool supports optional \"model\" or \"reasoning_effort\" overrides, "
-      + "use only models listed for this collaboration surface. "
-      + "When setting either override, set fork_turns to \"none\" "
-      + "(or a positive turn count such as \"3\"; full-history forks reject overrides) "
-      + "and make the task message self-contained.";
+    let text = "OpenCodex sub-agent routing metadata for this collaboration surface. "
+      + "This metadata does not override Codex delegation or model-selection rules.";
     if (preferred) {
       text += ` Preferred sub-agent: model "${preferred.model}"`
         + (injectionEffort ? `, reasoning_effort "${injectionEffort}"` : "")
-        + " — use it unless the user names another.";
+        + ".";
     }
     text += fallbackGuidance;
     text += roster;
@@ -487,7 +487,7 @@ export async function multiAgentGuidanceText(
       // Roster is the only unbounded part — drop it before breaking the budget.
       text = text.slice(0, text.length - roster.length);
     }
-    return `<multi_agent_mode>${text}</multi_agent_mode>`;
+    return `${OPENCODEX_SUBAGENT_GUIDANCE_OPEN_TAG}${text}${OPENCODEX_SUBAGENT_GUIDANCE_CLOSE_TAG}`;
   }
 
   const effort = parsed.options.reasoning;
@@ -544,6 +544,17 @@ function isGeneratedDeveloperItem(item: unknown, text: string): boolean {
   return generatedDeveloperText(item) === text;
 }
 
+function generatedGuidanceFamily(text: string): "multi_agent_mode" | "opencodex_subagent_guidance" | undefined {
+  if (text.startsWith("<multi_agent_mode>") && text.endsWith("</multi_agent_mode>")) {
+    return "multi_agent_mode";
+  }
+  if (text.startsWith(OPENCODEX_SUBAGENT_GUIDANCE_OPEN_TAG)
+      && text.endsWith(OPENCODEX_SUBAGENT_GUIDANCE_CLOSE_TAG)) {
+    return "opencodex_subagent_guidance";
+  }
+  return undefined;
+}
+
 function isDeveloperPrefixItem(item: unknown): boolean {
   if (!isRecord(item)) return false;
   if (item.type === "additional_tools") return item.role === "developer";
@@ -583,13 +594,13 @@ export function injectDeveloperMessage(parsed: OcxParsedRequest, text: string):
   const devItem = { type: "message", role: "developer", content: [{ type: "input_text", text }] };
   if (rawInput) {
     const replayPrefix = rawInput.slice(0, replayPrefixLen);
-    const taggedGuidance = text.startsWith("<multi_agent_mode>") && text.endsWith("</multi_agent_mode>");
-    const lastTaggedGuidance = taggedGuidance
+    const guidanceFamily = generatedGuidanceFamily(text);
+    const lastTaggedGuidance = guidanceFamily
       ? replayPrefix.map(generatedDeveloperText)
-        .filter(item => item?.startsWith("<multi_agent_mode>") && item.endsWith("</multi_agent_mode>"))
+        .filter(item => item !== undefined && generatedGuidanceFamily(item) === guidanceFamily)
         .at(-1)
       : undefined;
-    if (taggedGuidance ? lastTaggedGuidance === text : replayPrefix.some(item => isGeneratedDeveloperItem(item, text))) {
+    if (guidanceFamily ? lastTaggedGuidance === text : replayPrefix.some(item => isGeneratedDeveloperItem(item, text))) {
       return;
     }
   }

package/src/server/responses/combo-session-recall.ts

@@ -0,0 +1,89 @@
+/** Process-local recall of the last completed combo response on an explicit session lane. */
+import { getCombo, targetKey } from "../../combos/types";
+import { captureConfigGeneration, type GenerationContext } from "../../lib/state-store-sweeper";
+import type { OcxConfig, OcxComboTarget } from "../../types";
+
+interface ComboRecallEntry {
+  comboId: string;
+  target: Pick<OcxComboTarget, "provider" | "model">;
+  responseModel: string;
+  at: number;
+}
+
+const RECALL_CAPACITY = 256;
+const RECALL_TTL_MS = 30 * 60 * 1000;
+const recall = new Map<string, ComboRecallEntry>();
+let lastReconciledGeneration = 0;
+let liveOwners: Pick<GenerationContext, "comboIds" | "comboTargets" | "providerNames"> | undefined;
+
+function ownsEntry(context: Pick<GenerationContext, "comboIds" | "comboTargets" | "providerNames">, entry: ComboRecallEntry): boolean {
+  return context.comboIds.has(entry.comboId)
+    && context.providerNames.has(entry.target.provider)
+    && context.comboTargets.has(`${entry.comboId}::${targetKey(entry.target)}`);
+}
+
+export function rememberComboForLane(
+  lane: string | undefined,
+  comboId: string,
+  target: Pick<OcxComboTarget, "provider" | "model">,
+  responseModel: string,
+  writerGeneration: number,
+): void {
+  if (!lane || !comboId || !responseModel.trim()) return;
+  // Reject even a same-named recreated owner: its previous in-flight turn is obsolete.
+  if (writerGeneration < Math.max(lastReconciledGeneration, captureConfigGeneration())) return;
+  const entry = { comboId, target: { provider: target.provider, model: target.model }, responseModel, at: Date.now() };
+  if (liveOwners && !ownsEntry(liveOwners, entry)) return;
+  recall.delete(lane);
+  recall.set(lane, entry);
+  while (recall.size > RECALL_CAPACITY) {
+    const oldest = recall.keys().next().value;
+    if (oldest === undefined) break;
+    recall.delete(oldest);
+  }
+}
+
+export function recallComboForLane(
+  config: OcxConfig,
+  lane: string | undefined,
+  model: string,
+): string | undefined {
+  if (!lane || !model || model.includes("/")) return undefined;
+  const entry = recall.get(lane);
+  if (!entry) return undefined;
+  const combo = getCombo(config, entry.comboId);
+  const provider = config.providers[entry.target.provider];
+  if (Date.now() - entry.at >= RECALL_TTL_MS
+    || !Object.hasOwn(config.providers, entry.target.provider)
+    || !provider || provider.disabled === true
+    || !combo?.targets.some(target => targetKey(target) === targetKey(entry.target))) {
+    recall.delete(lane);
+    return undefined;
+  }
+  return entry.responseModel === model ? entry.comboId : undefined;
+}
+
+export function reconcileComboRecall(context: GenerationContext): number {
+  if (context.generation <= lastReconciledGeneration) return 0;
+  lastReconciledGeneration = context.generation;
+  liveOwners = {
+    comboIds: new Set(context.comboIds),
+    comboTargets: new Set(context.comboTargets),
+    providerNames: new Set(context.providerNames),
+  };
+  let removed = 0;
+  for (const [lane, entry] of recall) {
+    if (!ownsEntry(context, entry) || Date.now() - entry.at >= RECALL_TTL_MS) {
+      recall.delete(lane);
+      removed += 1;
+    }
+  }
+  return removed;
+}
+
+/** Test-only reset, alongside the combo rotation/cooldown resets. */
+export function clearComboRecallForTests(): void {
+  recall.clear();
+  lastReconciledGeneration = 0;
+  liveOwners = undefined;
+}

package/src/server/responses/compact.ts

@@ -18,6 +18,7 @@ import {
   comboIdFromRawBody,
   concreteComboRequestBody,
   getCombo,
+  resolveComboId,
   isComboTargetInCooldown,
   NoAvailableComboTargetsError,
   noteComboSuccess,
@@ -152,6 +153,7 @@ import {
 import { fetchWithHeaderTimeout, providerFetch, safeHostLabel, safeOriginLabel } from "./fetch-helpers";
 import { mapCodexAuthContextErrorToResponse, nativeMainRefreshFailureResponse } from "./codex-auth-error";
 import { sessionLaneIdFromRequest } from "../request-log-conversation";
+import { recallComboForLane } from "./combo-session-recall";
 
 export const COMPACT_RESPONSE_MAX_BYTES = 32 * 1024 * 1024;
 
@@ -536,13 +538,29 @@ export async function handleResponsesCompact(
   // a local rather than written back to `raw.model`: assigning to the property widens it out
   // of the `string` narrowing the guard above just established.
   const compactFastRow = parseFastOnlyRowId(config, () => raw.model as string);
-  const compactModel = compactFastRow ? compactFastRow.baseId : raw.model;
+  let compactModel = compactFastRow ? compactFastRow.baseId : raw.model;
   if (compactFastRow) (raw as Record<string, unknown>).model = compactModel;
   // The client's own selector, kept for the request log: `raw.model` is rewritten to the
   // base id above, and logCtx.requestedModel is assigned from it further down, so without
   // this the log would lose which id the client actually asked for.
   const compactRequestedModel = compactFastRow ? compactFastRow.baseId + "--fast" : raw.model;
 
+  // Recall the last completed client-visible bare model after a combo switch (#3891).
+  // Configured selectors take precedence over this implicit session hint.
+  if (typeof compactModel === "string" && !compactModel.includes("/") && !compactFastRow
+    && !resolveComboId(config, compactModel)) {
+    const recalledComboId = recallComboForLane(config, sessionLaneIdFromRequest(req.headers), compactModel);
+    if (recalledComboId) {
+      (raw as Record<string, unknown>).model = `combo/${recalledComboId}`;
+      // Keep the routed identity in sync: the bare model can 404 outright (no
+      // canonical openai provider) or resolve straight onto a native-compact
+      // provider, both bypassing combo failover. The combo selector resolves
+      // through tryPickComboModel, whose route.combo skips the native compact
+      // endpoint.
+      compactModel = `combo/${recalledComboId}`;
+    }
+  }
+
   let route;
   try {
     // Compact requests route through the same policy evaluation as normal