@bitkyc08/opencodex 2.83.0 → 2.84.0

package/src/server/responses/codex-ws-wire.ts

@@ -1,9 +1,11 @@
 import { MAX_CLIENT_SSE_FRAME_BYTES } from "../sse-frame-buffer";
 import {
+  isTransientUpstreamStatus,
   markResponseNonReplayable,
   UPSTREAM_CLOSED_BEFORE_RESPONSE_CODE,
   UPSTREAM_NO_RESPONSE_CODE,
 } from "../../lib/upstream-retry";
+import { isRateLimitOrQuotaFailureMessage, recognizedUpstreamError } from "../../lib/errors";
 import type { RequestFailureCause, RequestFailureStage } from "../../lib/request-failure-model";
 import { packageVersion } from "../../lib/package-version";
 // If the 101 never arrives (network black hole), give SSE a chance well before
@@ -107,8 +109,209 @@ export type CodexWsStageRecord = Omit<CodexWsFailureStage, "requestBytes"> & {
   ocxVersion: string;
   /** Bun runtime version the exchange gated on. */
   bunVersion: string;
+  /**
+   * Normalized type of the Responses terminal frame that ended a plain exchange, as the upstream
+   * sent it and before any tail this proxy synthesizes (#6740). It is what separates an upstream
+   * `error` frame from a genuine `response.failed` when both reach a row as the same synthetic 502.
+   * Null when no terminal frame arrived, and on native-control exchanges, which can end on an
+   * acknowledgement instead. Records written before it existed read as null.
+   */
+  terminalEvent: CodexWsTerminalEvent | null;
+  /** Wrapper status of a terminal `error` frame ({@link codexWsWrapperStatus}); null otherwise. */
+  terminalErrorStatus: number | null;
 };
 
+/** The frames a plain exchange ends on, closed so a stage record can never carry free text. */
+export const CODEX_WS_TERMINAL_EVENTS = [
+  "response.completed",
+  "response.failed",
+  "response.incomplete",
+  "error",
+] as const;
+export type CodexWsTerminalEvent = typeof CODEX_WS_TERMINAL_EVENTS[number];
+
+export function isCodexWsTerminalEvent(value: unknown): value is CodexWsTerminalEvent {
+  return typeof value === "string" && (CODEX_WS_TERMINAL_EVENTS as readonly string[]).includes(value);
+}
+
+/**
+ * The HTTP status a Codex WebSocket `error` frame states on its wrapper, or undefined.
+ *
+ * The backend wraps a failure as `{type:"error", status|status_code, error}` and the native client
+ * turns that status into an HTTP error of the same status
+ * (codex-rs/codex-api/src/endpoint/responses_websocket.rs map_wrapped_websocket_error_event). Only
+ * that contract is read: a top-level integer in 100..599 under exactly one of the two aliases, the
+ * same rule the pre-commit rejection projection applies.
+ */
+export function codexWsWrapperStatus(payload: Record<string, unknown>): number | undefined {
+  if (payload.type !== "error") return undefined;
+  const hasStatus = Object.hasOwn(payload, "status");
+  if (hasStatus === Object.hasOwn(payload, "status_code")) return undefined;
+  const status = hasStatus ? payload.status : payload.status_code;
+  return typeof status === "number" && Number.isInteger(status) && status >= 100 && status <= 599
+    ? status
+    : undefined;
+}
+
+function plainRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+/** An absent or empty `output` array; anything else may already be visible to the client. */
+function emptyOutput(response: Record<string, unknown>): boolean {
+  const output = response.output;
+  return output === undefined || (Array.isArray(output) && output.length === 0);
+}
+
+/**
+ * Upper bound on how long an exchange may hold empty lifecycle frames while it waits to see
+ * whether the upstream refuses the turn before any output (#6969).
+ *
+ * Field rows put 97.5% of authoritative refusals within 5 s of the first Responses event and
+ * 98.2% within 10 s, with nothing gained after that.
+ */
+export const CODEX_WS_PRE_OUTPUT_REFUSAL_HOLD_MAX_MS = 10_000;
+
+/**
+ * The hold one send may use: at most `maxMs` from the first empty lifecycle frame, and never past
+ * `until`, an absolute time.
+ */
+export interface CodexWsPreOutputRefusalHold {
+  maxMs: number;
+  until: number;
+}
+
+/**
+ * The hold for a send starting now. The caller's header deadline (`connectTimeoutMs`) starts no
+ * earlier than this, so ending every hold by half of it means a held turn always commits well before
+ * that deadline could abort it, however late the first lifecycle frame arrives.
+ */
+export function codexWsPreOutputRefusalHold(connectMs: number, now = Date.now()): CodexWsPreOutputRefusalHold {
+  const half = Math.max(0, Math.floor(connectMs / 2));
+  return { maxMs: Math.min(CODEX_WS_PRE_OUTPUT_REFUSAL_HOLD_MAX_MS, half), until: now + half };
+}
+
+/**
+ * A lifecycle frame that commits nothing the client could see or act on (#6969): created,
+ * in-progress or queued, carrying a response object whose output is absent or empty. A snapshot
+ * with any output item, an unknown event, or a frame addressed to another stream is not one.
+ */
+export function isEmptyCodexWsLifecycleEvent(payload: Record<string, unknown>): boolean {
+  if (payload.type !== "response.created" && payload.type !== "response.in_progress"
+    && payload.type !== "response.queued") return false;
+  if (payload.stream_id !== undefined) return false;
+  return plainRecord(payload.response) && emptyOutput(payload.response);
+}
+
+const QUOTA_REFUSAL_IDENTITIES: ReadonlySet<string> = new Set(["usage_limit_reached", "usage_not_included"]);
+
+/** Quota and rate-limit identities keep their own routing: every `rate_limit*` and `*quota*` name. */
+function quotaRefusalIdentity(value: string): boolean {
+  const name = value.toLowerCase();
+  return QUOTA_REFUSAL_IDENTITIES.has(name) || name.startsWith("rate_limit") || name.includes("quota");
+}
+
+/**
+ * The status of an authoritative upstream refusal that ended a turn before any output (#6969),
+ * or undefined.
+ *
+ * Only structured evidence counts: a bare `error` frame's single wrapper status (the alias the
+ * native client turns into an HTTP error of that status, see {@link codexWsWrapperStatus}), or,
+ * with no wrapper alias at all, the recognized overload class; and a `response.failed` with an
+ * empty output whose error is the recognized overload class. The status must be a transient
+ * gateway status. Message wording never authorizes anything here; it can only veto, so a 5xx whose
+ * error names quota or a rate limit keeps the routing it has today.
+ */
+export function codexWsPreOutputRefusalStatus(payload: Record<string, unknown>): number | undefined {
+  if (payload.stream_id !== undefined) return undefined;
+  let error: unknown;
+  let status: number | undefined;
+  if (payload.type === "error") {
+    error = payload.error;
+    if (error !== undefined && !plainRecord(error)) return undefined;
+    const statedAlias = Object.hasOwn(payload, "status") || Object.hasOwn(payload, "status_code");
+    status = codexWsWrapperStatus(payload);
+    // A malformed or doubled alias is not evidence of anything.
+    if (statedAlias && status === undefined) return undefined;
+    if (status === undefined && plainRecord(error)) status = recognizedUpstreamError(error)?.httpStatus;
+  } else if (payload.type === "response.failed") {
+    const response = payload.response;
+    if (!plainRecord(response) || !emptyOutput(response)) return undefined;
+    error = response.error;
+    if (!plainRecord(error)) return undefined;
+    status = recognizedUpstreamError(error)?.httpStatus;
+  } else {
+    return undefined;
+  }
+  if (status === undefined || !isTransientUpstreamStatus(status)) return undefined;
+  if (plainRecord(error)) {
+    const { code, type, message } = error;
+    if ([code, type, message].some(value => value != null && typeof value !== "string")) return undefined;
+    if (typeof code === "string" && quotaRefusalIdentity(code)) return undefined;
+    if (typeof type === "string" && quotaRefusalIdentity(type)) return undefined;
+    if (typeof message === "string" && isRateLimitOrQuotaFailureMessage(message)) return undefined;
+  }
+  return status;
+}
+
+/**
+ * The response ids a frame names, for the exchange's replay-eligibility latch (#6969): the nested
+ * `response.id` and the top-level `response_id`. Null when a present id is not a string, which the
+ * latch treats as a conflict.
+ */
+export function codexWsFrameResponseIds(payload: Record<string, unknown>): string[] | null {
+  const ids: string[] = [];
+  const nested = plainRecord(payload.response) ? payload.response.id : undefined;
+  for (const value of [nested, payload.response_id]) {
+    if (value === undefined) continue;
+    if (typeof value !== "string") return null;
+    if (!ids.includes(value)) ids.push(value);
+  }
+  return ids;
+}
+
+interface PreOutputRefusalRecord {
+  restore: (() => Response) | null;
+  outcomeRecorded: boolean;
+}
+
+const preOutputRefusals = new WeakMap<Response, PreOutputRefusalRecord>();
+
+/**
+ * Register a pre-output refusal projection (#6969): a replayable gateway status standing in for a
+ * WebSocket exchange whose upstream refused the turn before any output. `restore` rebuilds the
+ * 200 event stream the client would have received without the projection.
+ */
+export function markCodexWsPreOutputRefusal(projection: Response, restore: () => Response): void {
+  preOutputRefusals.set(projection, { restore, outcomeRecorded: false });
+}
+
+export function isCodexWsPreOutputRefusal(response: Response): boolean {
+  return preOutputRefusals.has(response);
+}
+
+/** Record that this projection's account outcome was written, so no later owner writes it again. */
+export function noteCodexWsPreOutputRefusalOutcome(response: Response): void {
+  const record = preOutputRefusals.get(response);
+  if (record) record.outcomeRecorded = true;
+}
+
+export function codexWsPreOutputRefusalOutcomeRecorded(response: Response): boolean {
+  return preOutputRefusals.get(response)?.outcomeRecorded === true;
+}
+
+/**
+ * The response the client should receive in place of a projection no recovery replaced: the
+ * original event stream, byte for byte. Single use; any other response is returned unchanged.
+ */
+export function restoreCodexWsPreOutputRefusal(response: Response): Response {
+  const record = preOutputRefusals.get(response);
+  const restore = record?.restore;
+  if (!record || !restore) return response;
+  record.restore = null;
+  return restore();
+}
+
 const codexWsStageByResponse = new WeakMap<Response, CodexWsStageRecord>();
 
 export function markCodexWsStage(response: Response, record: CodexWsStageRecord): void {

package/src/server/responses/collaboration.ts

@@ -9,6 +9,8 @@ import {
 import { parseRequest } from "../../responses/parser";
 import { externalTaskInputContent } from "../../responses/task-input";
 import { MULTI_AGENT_MODE_HINT_RECOMMENDATION } from "../../codex/multi-agent-mode-policy";
+import { analyzeCodeModeExec } from "./code-mode-collab-surface";
+import { deferredV1Evidence } from "./deferred-collab-surface";
 import { buildCompactV1Output, COMPACT_PROMPT, decodeCompactionSummary, extractCompactUserMessages } from "../../responses/compaction";
 import { FORWARD_HEADERS, sanitizeReasoningInputContent } from "../../adapters/openai-responses";
 import { expandPreviousResponseInput, previousResponseProviderState, rememberResponseState } from "../../responses/state";
@@ -316,26 +318,53 @@ export function isV1CollabSurface(parsed: OcxParsedRequest): boolean {
 
 
 export function collabSurface(parsed: OcxParsedRequest): "v1" | "v2" | null {
+  const direct = directCollabSurface(parsed.context.tools);
+  // #6844: code-mode-only turns nest the collaboration tools inside `exec`, and tool-search turns
+  // defer them entirely. A rendered V1 listing or the deferred-namespace fragment can each infer V1;
+  // neither ever yields v2, overrides a different direct surface, or survives a rendered foreign
+  // collaboration claim.
+  const codeMode = analyzeCodeModeExec(parsed.context.tools);
+  if (codeMode.renderedV1 && codeMode.foreignCollabClaim) return null;
+  const inferredV1 = codeMode.renderedV1 || deferredV1Evidence(parsed, codeMode);
+  if (!inferredV1) return direct.surface;
+  if (codeMode.foreignCollabClaim) return null;
+  return !direct.sawNativeCollabTool || direct.surface === "v1" ? "v1" : null;
+}
+
+function directCollabSurface(tools: OcxParsedRequest["context"]["tools"]): {
+  surface: "v1" | "v2" | null;
+  sawNativeCollabTool: boolean;
+} {
   let namespacedSpawn = false;
   let flatSpawn = false;
   let v1Only = false;
   let v2Only = false;
-  for (const t of parsed.context.tools ?? []) {
+  // Collaboration-named direct tools outside an MCP namespace; an MCP server's own send_message or
+  // spawn_agent says nothing about the native surface, matching the nested check.
+  let sawNativeCollabTool = false;
+  for (const t of tools ?? []) {
+    const native = !t.namespace?.startsWith("mcp__");
     if (t.name === "spawn_agent") {
       if (t.namespace) namespacedSpawn = true;
       else flatSpawn = true;
+      if (native) sawNativeCollabTool = true;
     } else if (t.name === "send_input" || t.name === "resume_agent" || t.name === "close_agent") {
       v1Only = true;
+      if (native) sawNativeCollabTool = true;
     } else if (t.name === "send_message" || t.name === "followup_task" || t.name === "interrupt_agent" || t.name === "list_agents") {
       v2Only = true;
+      if (native) sawNativeCollabTool = true;
     }
   }
-  if (!namespacedSpawn && !flatSpawn) return null; // no spawn_agent -> no collab surface
-  if (namespacedSpawn && flatSpawn) return null;   // contradictory spawn shapes
-  if (v1Only && v2Only) return null;               // contradictory companions
-  if (v1Only) return "v1";
-  if (v2Only) return "v2";
-  return namespacedSpawn ? "v1" : "v2"; // companionless fallbacks (legacy defaults)
+  const surface = (): "v1" | "v2" | null => {
+    if (!namespacedSpawn && !flatSpawn) return null; // no spawn_agent -> no collab surface
+    if (namespacedSpawn && flatSpawn) return null;   // contradictory spawn shapes
+    if (v1Only && v2Only) return null;               // contradictory companions
+    if (v1Only) return "v1";
+    if (v2Only) return "v2";
+    return namespacedSpawn ? "v1" : "v2"; // companionless fallbacks (legacy defaults)
+  };
+  return { surface: surface(), sawNativeCollabTool };
 }
 
 

package/src/server/responses/compact.ts

@@ -200,6 +200,7 @@ import {
   usesCodexForwardPoolAuth,
 } from "./core";
 import { fetchWithHeaderTimeout, providerFetch, safeHostLabel, safeOriginLabel } from "./fetch-helpers";
+import { shouldRetryCodexPoolAccountQuota, shouldRetryCodexPoolAccountTransient } from "./core-codex-account";
 import { mapCodexAuthContextErrorToResponse, nativeMainRefreshFailureResponse } from "./codex-auth-error";
 import { linkRequestSessionLane, sessionLaneIdFromRequest } from "../request-log-conversation";
 import { recallComboForLane } from "./combo-session-recall";
@@ -1048,7 +1049,11 @@ export async function handleResponsesCompact(
         targetKey: compactTargetKey,
       });
       if (!decision.allowed) return Promise.reject(new SendBudgetExhaustedError(safeHostLabel(compactUrl)));
-      if (!decision.permit.use()) return Promise.reject(new SendBudgetExhaustedError(safeHostLabel(compactUrl)));
+      if (!decision.permit.use()) {
+        // Nothing was sent, so the reservation goes back rather than holding a send against the request.
+        decision.permit.release();
+        return Promise.reject(new SendBudgetExhaustedError(safeHostLabel(compactUrl)));
+      }
       return doFetch();
     };
     const sendCompactAttempt = (
@@ -1056,6 +1061,7 @@ export async function handleResponsesCompact(
       sendHeaders: Headers,
       recovery: "normal" | "single",
       sendAuthCtx: CodexAuthContext,
+      onPhysicalDispatch?: () => void,
     ): Promise<Response> => {
       const doFetch = (upstreamRecovery?: UpstreamSendRecovery) => fetchWithHeaderTimeout(
         compactUrl,
@@ -1072,6 +1078,7 @@ export async function handleResponsesCompact(
           modelId: route.modelId,
           beforeDispatch: isCanonicalOpenAiForwardProvider(sendProvider)
             ? createCodexAuthDispatchGuard(sendAuthCtx, config, selectedModelId, admission) : undefined,
+          ...(onPhysicalDispatch ? { onPhysicalDispatch } : {}),
         }),
         // Every credential-bearing forward send gets manual redirects, not only
         // pool sends: direct mode carries the caller's credential too (#914).
@@ -1217,6 +1224,53 @@ export async function handleResponsesCompact(
       }
     }
 
+    // The settle for an alternate send that threw, shared by the quota and transient moves. By the
+    // time it runs the request already names the alternate (outcomeCtx), so health goes to it.
+    const failedAlternateCompactSend = (err: unknown): Response => {
+      if (req.signal.aborted) {
+        recordCompactPoolOutcome(outcomeCtx, 499);
+        return formatErrorResponse(499, "client_cancelled", "Client cancelled compact request");
+      }
+      const localRefusal = localDispatchRefusal(err);
+      if (localRefusal) return localRefusal;
+      const outcome = classifyTransportFailureKind(err);
+      // Host-level evidence stands regardless of pool membership (#914 review).
+      if (outcome === "connect_neutral") {
+        if (compactHostCircuitEnabled) {
+          recordUpstreamHostFailure(actualCompactHostKey, {
+            code: transportErrorCode(err),
+            threshold: config.upstreamHostCircuitThreshold,
+            lease: compactHostAdmissionLease,
+          });
+        } else {
+          recordUpstreamHostFailure(actualCompactHostKey, { code: transportErrorCode(err) });
+        }
+      } else {
+        releaseUpstreamHostAdmission(compactHostAdmissionLease);
+      }
+      compactHostAdmissionLease = null;
+      recordCompactPoolOutcome(outcomeCtx, outcome);
+      return formatErrorResponse(502, "upstream_error", "Failed to connect to compact upstream");
+    };
+    const scrubCompactStateForAlternate = (alternateAuthCtx: CodexAuthContext): void => {
+      const binding = conversationStateBindingFromAuth(
+        alternateAuthCtx,
+        (authCtx.kind === "pool" || authCtx.kind === "main-pool")
+          ? authCtx.affinityKey
+          : codexPoolAffinityKey(req.headers),
+      );
+      if (!binding) return;
+      for (const body of [raw, compactBody]) {
+        applyAccountChangeConversationStateScrub({
+          body,
+          bindingKey: binding.bindingKey,
+          servingAccountId: binding.accountId,
+          priorAccountId: authCtx.accountId,
+          logCtx,
+        });
+      }
+    };
+
     // Bounded same-request alternate: the regular /v1/responses path already does this
     // (core.ts:319-423) and recognizes exactly 429/402. Without it a pool rejection
     // surfaces to the client, which retries the compact task OUTSIDE the logical request
@@ -1317,57 +1371,81 @@ export async function handleResponsesCompact(
         await upstream.body?.cancel().catch(() => undefined);
         outcomeCtx = alternate.authCtx;
         logCtx.accountLogLabel = codexAuthContextLogLabel(alternate.authCtx, config);
-        {
-          const binding = conversationStateBindingFromAuth(
-            alternate.authCtx,
-            (authCtx.kind === "pool" || authCtx.kind === "main-pool")
-              ? authCtx.affinityKey
-              : codexPoolAffinityKey(req.headers),
-          );
-          if (binding) {
-            applyAccountChangeConversationStateScrub({
-              body: raw,
-              bindingKey: binding.bindingKey,
-              servingAccountId: binding.accountId,
-              priorAccountId: authCtx.accountId,
-              logCtx,
-            });
-            applyAccountChangeConversationStateScrub({
-              body: compactBody,
-              bindingKey: binding.bindingKey,
-              servingAccountId: binding.accountId,
-              priorAccountId: authCtx.accountId,
-              logCtx,
-            });
-          }
-        }
+        scrubCompactStateForAlternate(alternate.authCtx);
         try {
           upstream = await sendCompactAttempt(alternate.provider, alternate.headers, "single", alternate.authCtx);
         } catch (err) {
-          if (req.signal.aborted) {
-            recordCompactPoolOutcome(outcomeCtx, 499);
-            return formatErrorResponse(499, "client_cancelled", "Client cancelled compact request");
-          }
-          const localRefusal = localDispatchRefusal(err);
-          if (localRefusal) return localRefusal;
-          const outcome = classifyTransportFailureKind(err);
-          // Host-level evidence stands regardless of pool membership (#914 review).
-          if (outcome === "connect_neutral") {
-            if (compactHostCircuitEnabled) {
-              recordUpstreamHostFailure(actualCompactHostKey, {
-                code: transportErrorCode(err),
-                threshold: config.upstreamHostCircuitThreshold,
-                lease: compactHostAdmissionLease,
-              });
-            } else {
-              recordUpstreamHostFailure(actualCompactHostKey, { code: transportErrorCode(err) });
-            }
-          } else {
-            releaseUpstreamHostAdmission(compactHostAdmissionLease);
+          return failedAlternateCompactSend(err);
+        }
+      }
+    }
+    // A transient 5xx that survived the same-account ladder above (#6969). The regular path moves
+    // it to another Pool account; compact used to move only on 429/402, so the client retried the
+    // compact task outside this request while another account sat idle. One bounded alternate send,
+    // the same guards as the quota move, and a 5xx whose body confirms quota keeps today's path.
+    if (
+      shouldRetryCodexPoolAccountTransient(upstream)
+      && !storedPool401ReplayAttempted
+      && usesCodexForwardPoolAuth(authCtx, route.provider)
+      && !authCtx.fixedAccount
+      && route.codexAccountMode
+      && outcomeCtx === authCtx
+      && !req.signal.aborted
+      && !conversationCarriesUploadedFiles(raw)
+      && !await shouldRetryCodexPoolAccountQuota(upstream, req.signal)
+    ) {
+      const firstStatus = upstream.status;
+      const firstRetryAfter = upstream.headers.get("retry-after");
+      const firstResetAt = [
+        upstream.headers.get("x-codex-primary-reset-at"),
+        upstream.headers.get("x-codex-secondary-reset-at"),
+        upstream.headers.get("x-codex-tertiary-reset-at"),
+      ].filter(Boolean);
+      const alternate = await resolveAlternateCompactContext({
+        req,
+        admission,
+        config,
+        route,
+        selectedModelId,
+        excludeAccountId: authCtx.accountId,
+        turnAdmissionLease,
+      });
+      if (alternate && req.signal.aborted) {
+        releaseCodexAuthContextProbeLease(alternate.authCtx);
+        recordCompactPoolOutcome(outcomeCtx, 499);
+        void upstream.body?.cancel(req.signal.reason).catch(() => undefined);
+        return formatErrorResponse(499, "client_cancelled", "Client cancelled compact request");
+      }
+      if (alternate) {
+        const firstLabel = logCtx.accountLogLabel;
+        // B's identity before B's admission, so every budget and spend check runs against B. A's
+        // response stays intact until B is actually sent.
+        logCtx.accountLogLabel = codexAuthContextLogLabel(alternate.authCtx, config);
+        scrubCompactStateForAlternate(alternate.authCtx);
+        const recordFirstMove = () => {
+          recordCompactPoolOutcome(authCtx, firstStatus, { retryAfter: firstRetryAfter, resetAt: firstResetAt });
+          void upstream.body?.cancel().catch(() => undefined);
+          outcomeCtx = alternate.authCtx;
+        };
+        let alternateResponse: Response | undefined;
+        // Whether B's send actually left this process. Every local refusal before that point -- a
+        // spent budget, a dispatch guard such as disabled credits, a pacing refusal -- keeps A.
+        let alternateDispatched = false;
+        try {
+          alternateResponse = await sendCompactAttempt(alternate.provider, alternate.headers, "single", alternate.authCtx,
+            () => { alternateDispatched = true; });
+        } catch (err) {
+          if (alternateDispatched) {
+            recordFirstMove();
+            return failedAlternateCompactSend(err);
           }
-          compactHostAdmissionLease = null;
-          recordCompactPoolOutcome(outcomeCtx, outcome);
-          return formatErrorResponse(502, "upstream_error", "Failed to connect to compact upstream");
+          // Refused before anything left: A's answer and identity stand, recorded once below.
+          logCtx.accountLogLabel = firstLabel;
+          releaseCodexAuthContextProbeLease(alternate.authCtx);
+        }
+        if (alternateResponse) {
+          recordFirstMove();
+          upstream = alternateResponse;
         }
       }
     }

package/src/server/responses/context-overflow.ts

@@ -1,7 +1,19 @@
-import { bridgeToResponsesSSE } from "../../bridge";
+import { bridgeToResponsesSSE, formatErrorResponse } from "../../bridge";
+import { OLLAMA_LATE_ATTRIBUTION_LIMIT_MESSAGE } from "../../adapters/ollama-native";
 import type { TranslatorBudget } from "../../lib/translator-budget";
 import type { AdapterEvent } from "../../types";
 
+/**
+ * The Ollama late-attribution refusal as a client response: the existing translator-budget
+ * wire shape (413 request_too_large) with only the proxy-owned constant as its message.
+ * It is deliberately not a context overflow: compacting on the same route cannot shrink it.
+ */
+export function lateAttributionLimitResponse(): Response {
+  return formatErrorResponse(413, "request_too_large", OLLAMA_LATE_ATTRIBUTION_LIMIT_MESSAGE, {
+    code: "translation_buffer_limit",
+  });
+}
+
 export const PROVIDER_INPUT_TOO_LARGE_MESSAGE =
   "The provider rejected this turn because its input exceeds the provider size or context limit. Reduce the current input or compact the conversation before retrying.";