@sema-agent/core 7.55.0 → 7.57.0

package/dist/brain/anthropic.js

@@ -5,21 +5,15 @@ import { DEGENERATE_MESSAGE, trimDegenerateTail } from "./repetition.js";
 import { STREAM_TORN_WARNING, createRepetitionPoll, createStreamEndLedger, modelOutputInvalidOf, noteResponseModel, nameMissingCause, parseStreamedToolArgs, placeTurnNotes, truncationCauseClause } from "./stream-shared.js";
 import { admitToolCallId, providerResultIds, providerToolCallId, responseToolCallIds } from "./tool-call-id.js";
 import { emitBrainTelemetry, reportReasoningWireFacts } from "./status-sink.js";
-import { errorResultMediaNote, IMAGE_OMITTED_NO_VISION, modelSupportsVision, sendableImages } from "./media-degrade.js";
-import { ANTHROPIC_RESERVED, OUTPUT_CAP_KEYS, applyExtraBody, effectiveOutputCap, headerBagOnce, lockHeader, mergeHeaders, takeHeaderCasefold } from "./request-params.js";
+import { errorResultMediaNote, IMAGE_OMITTED_NO_VISION, imageWithholdOf, reportImagesWithheld, sendableImages } from "./media-degrade.js";
+import { ANTHROPIC_RESERVED, OUTPUT_CAP_KEYS, applyExtraBody, declaredRequestValues, effectiveOutputCap, headerBagOnce, headerListEntries, lockHeader, mergeHeaders, takeHeaderSpellings } from "./request-params.js";
 import { admitRouteRequest, applyRouteCredentialHeaders, assertServableRequestRoot, brainConfigSnapshot, createBrainRouteJudge, joinRequestUrl, resolveRequestRootOf, resolveRouteCredential } from "./route-adjudicator.js";
 import { requestRouteOf } from "./request-route.js";
 import { NAMES_AS_WRITTEN, resolveProviderDialect, endpointToolNames } from "./provider-dialect.js";
-import { MIN_THINKING_TOKENS, budgetCapSkipsThinking, declaredEffortLevels, reasoningBudgetShare, reasoningRequestCarried, resolveEffort } from "./reasoning.js";
+import { applyReasoningToRequest, mergeReasoningHeaders } from "./reasoning-request.js";
 import { runStreamingBrain } from "./stream-engine.js";
 import { refuseRetiredTimeoutKnobs } from "./timeout.js";
 import { resolveFetch } from "./transport.js";
-function thinkingBudget(maxTokens, share, fixed, hardCap = false) {
-    const max = hardCap ? maxTokens : Math.max(maxTokens, MIN_THINKING_TOKENS * 2);
-    const want = fixed ?? Math.floor(max * share);
-    const budget = Math.min(Math.max(MIN_THINKING_TOKENS, want), max - 1);
-    return { max, budget };
-}
 const EPHEMERAL = { type: "ephemeral" };
 const DOCUMENT_OMITTED_NO_VISION = "[PDF document omitted: the serving model does not support document input; extract the text via Bash instead (e.g. `pdftotext`).]";
 function textOf(content) {
@@ -27,7 +21,7 @@ function textOf(content) {
         ? content
         : content.filter((c) => c.type === "text" && typeof c.text === "string").map((c) => c.text).join("");
 }
-function toUserBlocks(content, supportsVision = true) {
+function toUserBlocks(content, withhold) {
     if (typeof content === "string") {
         return content.length > 0 ? [{ type: "text", text: content }] : [];
     }
@@ -38,7 +32,7 @@ function toUserBlocks(content, supportsVision = true) {
             blocks.push({ type: "text", text: c.text });
         }
         else if (c.type === "image" && c.data && c.mimeType) {
-            if (supportsVision)
+            if (withhold === undefined)
                 blocks.push({ type: "image", source: { type: "base64", media_type: c.mimeType, data: c.data } });
             else {
                 omitted++;
@@ -46,12 +40,13 @@ function toUserBlocks(content, supportsVision = true) {
             }
         }
     }
-    if (omitted > 0)
-        emitBrainTelemetry({ kind: "vision_placeholder", count: omitted });
+    if (withhold !== undefined)
+        reportImagesWithheld(withhold, omitted);
     return blocks;
 }
 function toAnthropicMessages(ctx, model, toolNames) {
-    const supportsVision = modelSupportsVision(model);
+    const imageWithhold = imageWithholdOf(model);
+    const supportsVision = imageWithhold === undefined;
     const raw = [];
     let pendingDocs = [];
     const flushDocs = () => {
@@ -65,7 +60,7 @@ function toAnthropicMessages(ctx, model, toolNames) {
         if (m.role !== "toolResult")
             flushDocs();
         if (m.role === "user") {
-            const ub = toUserBlocks(m.content, supportsVision);
+            const ub = toUserBlocks(m.content, imageWithhold);
             raw.push({ role: "user", content: ub.length ? ub : [{ type: "text", text: NO_CONTENT }] });
         }
         else if (m.role === "assistant") {
@@ -97,7 +92,7 @@ function toAnthropicMessages(ctx, model, toolNames) {
             const docs = parts ? parts.filter((c) => c.type === "document") : [];
             const rest = docs.length > 0 && parts ? parts.filter((c) => c.type !== "document") : m.content;
             const hasImage = !m.isError && Array.isArray(rest) && rest.some((c) => c.type === "image");
-            let inner = hasImage ? toUserBlocks(rest, supportsVision) : textOf(rest);
+            let inner = hasImage ? toUserBlocks(rest, imageWithhold) : textOf(rest);
             if (docs.length > 0 && !m.isError) {
                 if (supportsVision) {
                     for (const d of docs) {
@@ -290,68 +285,32 @@ export function createAnthropicBrain(given = {}) {
                 if (options?.temperature !== undefined && anthCompat.supportsTemperature !== false) {
                     body.temperature = options.temperature;
                 }
-                let builtReasoningFacts;
-                let thinkingOn = false;
-                if (reasoningRequestCarried(model, options?.reasoning)) {
-                    if (anthCompat.thinkingMode === "adaptive") {
-                        body.thinking = { type: "adaptive" };
-                        thinkingOn = true;
-                    }
-                    else {
-                        const hardCap = overrides?.maxOutputTokens !== undefined || options?.maxTokens !== undefined;
-                        builtReasoningFacts = { outputCapTokens: body.max_tokens, hardOutputCap: hardCap };
-                        if (budgetCapSkipsThinking(builtReasoningFacts.outputCapTokens, builtReasoningFacts.hardOutputCap)) {
-                            body.thinking = undefined;
-                            delete body.thinking;
-                        }
-                        else {
-                            const share = config.thinkingBudgetShare ?? reasoningBudgetShare(options.reasoning);
-                            const { max, budget } = thinkingBudget(body.max_tokens, share, config.thinkingBudgetTokens, hardCap);
-                            body.max_tokens = max;
-                            body.thinking = { type: "enabled", budget_tokens: budget };
-                            thinkingOn = true;
-                        }
-                    }
-                    if (thinkingOn)
-                        delete body.temperature;
-                }
-                else if (model.reasoning && options?.reasoning === "off" && anthCompat.thinkingMode !== "adaptive") {
-                    body.thinking = { type: "disabled" };
-                }
-                const betas = [];
-                let sendEffortBeta = false;
-                const declaredEffort = declaredEffortLevels(anthCompat.effortLevels);
-                if (declaredEffort !== undefined && reasoningRequestCarried(model, options?.reasoning)) {
-                    const { effective } = resolveEffort(options.reasoning, declaredEffort);
-                    const wireEffort = effective === "minimal" ? "low" : effective;
-                    body.output_config = { effort: wireEffort };
-                    sendEffortBeta = true;
-                }
-                if (sendEffortBeta)
-                    betas.push("effort-2025-11-24");
-                if (anthCompat.contextManagement && thinkingOn) {
-                    body.context_management = { edits: [{ type: "clear_thinking_20251015", keep: "all" }] };
-                    betas.push("context-management-2025-06-27");
-                }
-                if (anthCompat.interleavedThinking) {
-                    betas.push("interleaved-thinking-2025-05-14");
-                }
-                const headers = mergeHeaders(modelHeaders, config.headers, optionsHeaders);
+                const hardCap = overrides?.maxOutputTokens !== undefined || options?.maxTokens !== undefined;
+                const { body: reasoningBody, headers: reasoningHeaders, wireFacts: builtReasoningFacts, } = applyReasoningToRequest({
+                    api: "anthropic-messages",
+                    model,
+                    level: options?.reasoning,
+                    body,
+                    budget: { capIsHard: hardCap, share: config.thinkingBudgetShare, tokens: config.thinkingBudgetTokens },
+                });
+                const headerLayers = [modelHeaders, config.headers, optionsHeaders];
+                const headers = mergeHeaders(...headerLayers);
                 applyRouteCredentialHeaders(headers, routeCredential);
-                if (betas.length > 0) {
-                    const existing = (takeHeaderCasefold(headers, "anthropic-beta") ?? "").split(",").map((b) => b.trim()).filter(Boolean);
-                    for (const beta of betas) {
-                        if (!existing.includes(beta))
-                            existing.push(beta);
-                    }
-                    headers["anthropic-beta"] = existing.join(",");
+                const declaredBetas = headerLayers.flatMap((layer) => Object.entries(layer ?? {}).flatMap(([name, value]) => (name.toLowerCase() === "anthropic-beta" ? headerListEntries(value) : [])));
+                const declared = declaredRequestValues([...headerLayers, headers], [config.version, ...declaredBetas], apiKey);
+                takeHeaderSpellings(headers, "anthropic-beta");
+                for (const layer of headerLayers) {
+                    for (const [name, value] of Object.entries(layer ?? {}))
+                        if (name.toLowerCase() === "anthropic-beta")
+                            mergeReasoningHeaders(headers, { [name]: value });
                 }
+                mergeReasoningHeaders(headers, reasoningHeaders);
                 lockHeader(headers, "content-type", "application/json");
                 lockHeader(headers, "anthropic-version", config.version ?? "2023-06-01");
                 if (apiKey)
                     lockHeader(headers, ANTHROPIC_KEY_HEADER, apiKey);
-                const builtThinkingRequested = body.thinking !== undefined;
-                const builtMaxTokens = body.max_tokens;
+                const builtThinkingRequested = reasoningBody.thinking !== undefined;
+                const builtMaxTokens = reasoningBody.max_tokens;
                 const builtMaxTokensLane = overrides?.maxOutputTokens !== undefined
                     ? "engine"
                     : options?.maxTokens !== undefined
@@ -359,10 +318,11 @@ export function createAnthropicBrain(given = {}) {
                         : model.maxTokens !== undefined
                             ? "model"
                             : "config-default";
-                const { body: wire, dropped: extraBodyDropped } = applyExtraBody(body, model, ANTHROPIC_RESERVED);
+                const { body: wire, dropped: extraBodyDropped } = applyExtraBody(reasoningBody, model, ANTHROPIC_RESERVED);
                 return {
                     url,
                     headers,
+                    declared,
                     body: JSON.stringify(wire),
                     extraBodyDropped,
                     route: requestRouteOf(routeCredential, rootOrigin),
@@ -396,7 +356,7 @@ export function createAnthropicBrain(given = {}) {
                 let lastDegenCheckThinking = 0;
                 const detectRep = config.detectRepetition !== false;
                 let messageStopped = false;
-                const afterEnd = createStreamEndLedger();
+                const afterEnd = createStreamEndLedger(ctrl.providerWords);
                 const streamEnded = () => stopReason != null || messageStopped;
                 const mergeDeltaUsage = (u) => {
                     if (!u)
@@ -473,7 +433,7 @@ export function createAnthropicBrain(given = {}) {
                         else if (acc.type === "tool_use") {
                             const closed = acc.stopped === true || !endedCut;
                             if (!acc.toolName) {
-                                (nameMissingCause(closed) === "truncated" ? malformed : unnamed).push(`id="${acc.toolId || "?"}"(${acc.toolJson.slice(0, 200)})`);
+                                (nameMissingCause(closed) === "truncated" ? malformed : unnamed).push(`id="${ctrl.providerWords(acc.toolId || "?")}"(${ctrl.providerWords(acc.toolJson).slice(0, 200)})`);
                             }
                             else {
                                 const tc = closeToolUseBlock(acc, responseIds, closed);
@@ -482,7 +442,7 @@ export function createAnthropicBrain(given = {}) {
                                     finalContent.push(tc);
                                 }
                                 else {
-                                    malformed.push(`${acc.toolName}(${acc.toolJson.slice(0, 200)})`);
+                                    malformed.push(`${ctrl.providerWords(acc.toolName)}(${ctrl.providerWords(acc.toolJson).slice(0, 200)})`);
                                 }
                             }
                         }
@@ -623,8 +583,13 @@ export function createAnthropicBrain(given = {}) {
                             const d = evt.delta;
                             if (d?.stop_reason)
                                 stopReason = d.stop_reason;
-                            if (d?.stop_details)
-                                stopDetails = d.stop_details;
+                            if (d?.stop_details) {
+                                const raw = d.stop_details;
+                                stopDetails = {
+                                    ...(typeof raw.category === "string" ? { category: ctrl.providerWords(raw.category) } : {}),
+                                    ...(typeof raw.explanation === "string" ? { explanation: ctrl.providerWords(raw.explanation) } : {}),
+                                };
+                            }
                             mergeDeltaUsage(evt.usage);
                             break;
                         }
@@ -639,7 +604,7 @@ export function createAnthropicBrain(given = {}) {
                             const inputTooLong = e?.type === "request_too_large" ||
                                 (e?.type === "invalid_request_error" && typeof e.message === "string" && startsWithInputTooLongAnchor(e.message));
                             ctrl.keepOutput({ content: assembleTurn({}).content, ...reportedUsage() });
-                            throw new BrainError(anthropicStreamErrorCode(e?.type), `anthropic stream error (${e?.type ?? "unknown"}): ${e?.message ?? ""}`, undefined, { apiError: true, ...(e === undefined ? {} : inputTooLong ? { inputTooLong: true } : { inputTooLongRuledOut: true }) });
+                            throw new BrainError(anthropicStreamErrorCode(e?.type), `anthropic stream error ${ctrl.providerWords(`(${e?.type ?? "unknown"}): ${e?.message ?? ""}`)}`, undefined, { apiError: true, ...(e === undefined ? {} : inputTooLong ? { inputTooLong: true } : { inputTooLongRuledOut: true }) });
                         }
                         default:
                             break;
@@ -679,7 +644,7 @@ export function createAnthropicBrain(given = {}) {
                         }
                         catch {
                             malformedFrames++;
-                            malformedSample ??= data.slice(0, 160);
+                            malformedSample ??= ctrl.providerWords(data).slice(0, 160);
                             return;
                         }
                         handleEvent(evt);

package/dist/brain/media-degrade.d.ts

@@ -7,15 +7,26 @@
  * sentence that drifts is a string consumers grep for.
  */
 import type { Model } from "../internal/llm.js";
+import { type CapabilityDeclaration } from "./model-capability.js";
+/** Why a request's images are withheld from the SERVING model: the entry's image declaration, when it is not held
+ *  (the withheld-capability report's `cause`, `status-sink.ts`). */
+export type ImageWithholdCause = Exclude<CapabilityDeclaration, "declared_on">;
+/** A request whose images are withheld: which model, and why. */
+export interface ImageWithhold {
+    readonly modelId: string;
+    readonly cause: ImageWithholdCause;
+}
 /**
- * Whether the SERVING model accepts image input (`Model.input` contains "image").
- *
- * An ABSENT `input` is deliberately permissive (vision on): the field is caller-supplied metadata,
- * and treating "not declared" as "not capable" would silently downgrade every caller who never
- * filled it in. A caller that genuinely serves a text-only endpoint declares `input: ["text"]` and
- * gets the placeholder path — the case a text-only API rejects with a hard 400 on an image part.
+ * The image row of the capability table for one request: `undefined` = images ride as images; otherwise the model and
+ * the declaration that withholds them. Read off the one capability reading (`capabilityHeld` / `capabilityOf`), so an
+ * entry that never declared `input` gets its images exactly as the table says, and an entry that declares a list without
+ * `"image"` gets the placeholder path — the case a text-only API rejects with a hard 400 on an image part. No model =
+ * images ride.
  */
-export declare function modelSupportsVision(model?: Model): boolean;
+export declare function imageWithholdOf(model?: Model): ImageWithhold | undefined;
+/** Report `count` images of one request replaced by placeholders — the one emit for every lane: the operator trace frame
+ *  (telemetry, per request) and the leg's withheld-capability account (the person's notice, once per conversation). */
+export declare function reportImagesWithheld(withhold: ImageWithhold, count: number): void;
 /** Placeholder for an image block dropped because the serving model declares no image input. */
 export declare const IMAGE_OMITTED_NO_VISION = "[image omitted: the serving model does not support image input]";
 /** {@link IMAGE_OMITTED_NO_VISION}, counted — a batch of dropped images states how many were lost. */

package/dist/brain/media-degrade.js

@@ -1,5 +1,16 @@
-export function modelSupportsVision(model) {
-    return model?.input === undefined ? true : model.input.includes("image");
+import { capabilityHeld, capabilityOf } from "./model-capability.js";
+import { emitBrainTelemetry, reportCapabilityWithheld } from "./status-sink.js";
+export function imageWithholdOf(model) {
+    if (model === undefined)
+        return undefined;
+    const declared = capabilityOf(model, "image");
+    return declared === "declared_on" || capabilityHeld(model, "image") ? undefined : { modelId: model.id, cause: declared };
+}
+export function reportImagesWithheld(withhold, count) {
+    if (count === 0)
+        return;
+    emitBrainTelemetry({ kind: "vision_placeholder", count });
+    reportCapabilityWithheld({ modelId: withhold.modelId, capability: "image", cause: withhold.cause, count });
 }
 export const IMAGE_OMITTED_NO_VISION = "[image omitted: the serving model does not support image input]";
 export function imagesOmittedNoVisionNote(count) {

package/dist/brain/model-capability.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The ONE reading of a model's capability declarations — image input and reasoning.
+ *
+ * A `Model` declares each capability in one of three states: on (`reasoning: true`; `input` lists `"image"`), off
+ * (`reasoning: false`; an `input` list without `"image"`), or not at all (the key is absent). Every reader in the engine
+ * (bar the PDF profile's no-metadata shortcut in `pdfModelCapabilitiesOf`, which looks at the absence itself) asks {@link capabilityOf} for the declaration, or {@link capabilityHeld} for "does the engine treat this model as
+ * having it", and what an undeclared capability means is stated once, in {@link UNKNOWN_CAPABILITY_READS} — no caller
+ * decides it for itself. A request never carries a capability declared off; one declared on is never dropped here.
+ *
+ * A declaration of the wrong shape is refused where it is read: a `reasoning` that is not a boolean, or an `input` that
+ * is not a list of strings, throws, naming the model and the key. Reading it some other way (by truthiness, or as
+ * undeclared) would turn a typo into a capability nobody declared.
+ */
+import type { Model } from "../internal/llm.js";
+/** The capabilities a model declares. `image` = accepts image input (`Model.input` lists `"image"`). */
+export declare const MODEL_CAPABILITIES: readonly ["image", "reasoning"];
+export type ModelCapability = (typeof MODEL_CAPABILITIES)[number];
+/** What a model's entry says about one capability. `unknown` = the entry does not say. */
+export declare const CAPABILITY_DECLARATIONS: readonly ["declared_on", "declared_off", "unknown"];
+export type CapabilityDeclaration = (typeof CAPABILITY_DECLARATIONS)[number];
+/**
+ * What the engine does with a capability the entry does not declare, per capability — the only place this is said.
+ * Image input is used (an entry that never filled in `input` keeps the images it was always sent). Reasoning is not:
+ * no thinking keys go out for an entry that does not declare `reasoning` (the request is the provider's default).
+ */
+export declare const UNKNOWN_CAPABILITY_READS: Readonly<Record<ModelCapability, "held" | "not_held">>;
+/** The part of a model this module reads (`id` only names the model in a refusal; the structural readers that take a
+ *  model-shaped object without one still get the same answer). */
+export type CapabilityDeclaringModel = {
+    readonly id?: Model["id"];
+    readonly reasoning?: unknown;
+    readonly input?: unknown;
+};
+/** The entry's declaration of `cap`. Throws a `TypeError` on a declaration of the wrong shape (see the module note). */
+export declare function capabilityOf(model: CapabilityDeclaringModel, cap: ModelCapability): CapabilityDeclaration;
+/** Whether the engine treats the model as having `cap`: declared on, or undeclared where {@link UNKNOWN_CAPABILITY_READS} says held. */
+export declare function capabilityHeld(model: CapabilityDeclaringModel, cap: ModelCapability): boolean;

package/dist/brain/model-capability.js

@@ -0,0 +1,34 @@
+export const MODEL_CAPABILITIES = Object.freeze(["image", "reasoning"]);
+export const CAPABILITY_DECLARATIONS = Object.freeze(["declared_on", "declared_off", "unknown"]);
+export const UNKNOWN_CAPABILITY_READS = Object.freeze({
+    image: "held",
+    reasoning: "not_held",
+});
+function typeWordOf(value) {
+    return value === null ? "null" : Array.isArray(value) ? "array" : typeof value;
+}
+function nameOf(model) {
+    return typeof model.id === "string" ? `"${model.id}"` : "a model with no id";
+}
+export function capabilityOf(model, cap) {
+    if (cap === "reasoning") {
+        const declared = model.reasoning;
+        if (declared === undefined)
+            return "unknown";
+        if (typeof declared !== "boolean") {
+            throw new TypeError(`Model.reasoning of ${nameOf(model)} must be true, false or absent; got ${typeWordOf(declared)}`);
+        }
+        return declared ? "declared_on" : "declared_off";
+    }
+    const input = model.input;
+    if (input === undefined)
+        return "unknown";
+    if (!Array.isArray(input) || !input.every((m) => typeof m === "string")) {
+        throw new TypeError(`Model.input of ${nameOf(model)} must be a list of input kinds or absent; got ${Array.isArray(input) ? "a list holding a non-string" : typeWordOf(input)}`);
+    }
+    return input.includes("image") ? "declared_on" : "declared_off";
+}
+export function capabilityHeld(model, cap) {
+    const declared = capabilityOf(model, cap);
+    return declared === "declared_on" || (declared === "unknown" && UNKNOWN_CAPABILITY_READS[cap] === "held");
+}

package/dist/brain/model-presets.d.ts

@@ -19,16 +19,10 @@ import type { AnthropicMessagesCompat, Model } from "../internal/llm.js";
  * - `supportsTemperature: false` — CC never sends temperature to this class, thinking on OR off.
  */
 export declare const FABLE_5_COMPAT: AnthropicMessagesCompat;
-/**
- * The fable lines the classic prompt shape serves. They are prompt text, so they live with the prompt
- * text; this name stays exported for hosts that read them. The preset below no longer carries them as
- * `promptGuidance`: the prompt composes them itself, once, where they are the only fable text.
- */
-export declare const FABLE_5_PROMPT_GUIDANCE: readonly string[];
 /**
  * A ready-to-use `claude-fable-5` {@link Model} (registry facts: 1M-token native context
  * window, 64k default max output — the 128k tier is opt-in via `maxTokens` override, knowledge
- * cutoff Jan 2026, `default_effort: "high"`). Override anything per deployment; set `cost` for
- * accounting (not baked — see module note).
+ * cutoff Jan 2026, `default_effort: "high"`, prompt capabilities `lean_prompt` + `fable_5_mitigations`).
+ * Override anything per deployment; set `cost` for accounting (not baked — see module note).
  */
 export declare function fable5Model(overrides?: Partial<Model>): Model;

package/dist/brain/model-presets.js

@@ -1,15 +1,9 @@
-import { catalogText } from "../prompt-assembly/catalog/index.js";
 import { ANTHROPIC_DEFAULT_BASE_URL } from "./anthropic.js";
 export const FABLE_5_COMPAT = {
     thinkingMode: "adaptive",
     effortLevels: ["low", "medium", "high", "xhigh", "max"],
     supportsTemperature: false,
 };
-export const FABLE_5_PROMPT_GUIDANCE = [
-    catalogText("core/behavior.fable-classic.final-message"),
-    catalogText("core/behavior.fable-classic.autonomy"),
-    catalogText("core/behavior.fable-classic.tool-json"),
-];
 export function fable5Model(overrides = {}) {
     return {
         id: "claude-fable-5",
@@ -25,6 +19,7 @@ export function fable5Model(overrides = {}) {
         maxTokens: 64_000,
         charsPerToken: 3,
         compat: { ...FABLE_5_COMPAT },
+        promptTraits: ["lean_prompt", "fable_5_mitigations"],
         ...overrides,
     };
 }

package/dist/brain/open-responses.js

@@ -4,12 +4,12 @@ import { DEGENERATE_MESSAGE, trimDegenerateTail } from "./repetition.js";
 import { STREAM_TORN_WARNING, createRepetitionPoll, modelOutputInvalidOf, noteResponseModel, nameMissingCause, parseStreamedToolArgs, placeTurnNotes } from "./stream-shared.js";
 import { admitToolCallId, providerResultIds, providerToolCallId, responseToolCallIds } from "./tool-call-id.js";
 import { emitBrainTelemetry } from "./status-sink.js";
-import { errorResultMediaNote, IMAGE_OMITTED_NO_VISION, imagesOmittedNoVisionNote, modelSupportsVision, sendableImages } from "./media-degrade.js";
-import { OUTPUT_CAP_KEYS, RESPONSES_RESERVED, applyExtraBody, effectiveOutputCap, headerBagOnce, lockHeader, mergeHeaders } from "./request-params.js";
+import { errorResultMediaNote, IMAGE_OMITTED_NO_VISION, imageWithholdOf, imagesOmittedNoVisionNote, reportImagesWithheld, sendableImages } from "./media-degrade.js";
+import { OUTPUT_CAP_KEYS, RESPONSES_RESERVED, applyExtraBody, declaredRequestValues, effectiveOutputCap, headerBagOnce, lockHeader, mergeHeaders } from "./request-params.js";
 import { admitRouteRequest, applyRouteCredentialHeaders, assertServableRequestRoot, brainConfigSnapshot, createBrainRouteJudge, joinRequestUrl, resolveRequestRootOf, resolveRouteCredential } from "./route-adjudicator.js";
 import { requestRouteOf } from "./request-route.js";
 import { NAMES_AS_WRITTEN, resolveProviderDialect, endpointToolNames } from "./provider-dialect.js";
-import { declaredOffSpelling, mintEffortWireValue, reasoningRequestCarried } from "./reasoning.js";
+import { applyReasoningToRequest } from "./reasoning-request.js";
 import { runStreamingBrain } from "./stream-engine.js";
 import { refuseRetiredTimeoutKnobs } from "./timeout.js";
 import { resolveFetch } from "./transport.js";
@@ -18,9 +18,6 @@ const DEGENERATE_POLL_CHARS = 64;
 const MALFORMED_SAMPLE_CHARS = 160;
 const MALFORMED_ARGS_CHARS = 200;
 const CAPABILITY_DIAGNOSTIC_TYPE = "responses_capability";
-function responsesCompat(model) {
-    return (model.compat ?? {});
-}
 const NO_CONTENT = "(no content)";
 const DOCUMENT_OMITTED = "[PDF document omitted: PDF direct read requires an Anthropic-family model; re-Read the file (the engine will extract text/render pages when possible) or extract the text via Bash instead (e.g. `pdftotext`).]";
 function textOf(content) {
@@ -38,16 +35,17 @@ function functionCallOutputText(text, hasCarriedImages, original) {
         return "(image attached below)";
     return Array.isArray(original) && original.length > 0 ? "(non-text tool result omitted)" : "";
 }
-function toUserParts(content, supportsVision) {
+function toUserParts(content, withhold) {
     if (typeof content === "string") {
         return content === "" ? [] : [{ type: "input_text", text: content }];
     }
+    const supportsVision = withhold === undefined;
     const nDocs = content.filter((c) => c.type === "document").length;
     if (nDocs > 0)
         emitBrainTelemetry({ kind: "document_placeholder", count: nDocs });
     const images = content.filter((c) => c.type === "image" && c.data !== undefined && c.mimeType !== undefined);
-    if (!supportsVision && images.length > 0)
-        emitBrainTelemetry({ kind: "vision_placeholder", count: images.length });
+    if (withhold !== undefined)
+        reportImagesWithheld(withhold, images.length);
     const parts = [];
     for (const c of content) {
         if (c.type === "text" && typeof c.text === "string" && c.text.length > 0) {
@@ -66,7 +64,8 @@ function toUserParts(content, supportsVision) {
     return parts;
 }
 function toResponsesInput(ctx, model, replayReasoning, toolNames) {
-    const supportsVision = modelSupportsVision(model);
+    const imageWithhold = imageWithholdOf(model);
+    const supportsVision = imageWithhold === undefined;
     const out = [];
     let pendingImages = [];
     const flushImages = () => {
@@ -88,7 +87,7 @@ function toResponsesInput(ctx, model, replayReasoning, toolNames) {
         if (m.role !== "toolResult")
             flushImages();
         if (m.role === "user") {
-            const parts = toUserParts(m.content, supportsVision);
+            const parts = toUserParts(m.content, imageWithhold);
             out.push({
                 type: "message",
                 role: "user",
@@ -124,8 +123,8 @@ function toResponsesInput(ctx, model, replayReasoning, toolNames) {
             const mediaImages = sendableImages(Array.isArray(m.content) ? m.content : []);
             const rawImages = m.isError ? [] : mediaImages;
             const images = supportsVision ? rawImages : [];
-            if (!supportsVision && rawImages.length > 0)
-                emitBrainTelemetry({ kind: "vision_placeholder", count: rawImages.length });
+            if (imageWithhold !== undefined)
+                reportImagesWithheld(imageWithhold, rawImages.length);
             const nDocs = Array.isArray(m.content) ? m.content.filter((c) => c.type === "document").length : 0;
             if (nDocs > 0)
                 emitBrainTelemetry({ kind: "document_placeholder", count: nDocs });
@@ -157,16 +156,6 @@ function toResponsesTools(ctx, toolNames) {
         strict: false,
     }));
 }
-function resolveWireEffort(model, reasoning) {
-    if (model.reasoning && reasoning === "off")
-        return declaredOffSpelling(model);
-    const compat = responsesCompat(model);
-    if (compat.supportsReasoningEffort === false)
-        return undefined;
-    if (!reasoningRequestCarried(model, reasoning))
-        return undefined;
-    return mintEffortWireValue(reasoning, model, compat.reasoningEffortLevels).wireValue;
-}
 function computeUsage(model, raw) {
     const input = raw?.input_tokens ?? 0;
     const output = raw?.output_tokens ?? 0;
@@ -266,7 +255,6 @@ export function createOpenResponsesBrain(given = {}) {
                         "remove it, or serve this model through the chat-completions lane, which does support it");
                 }
                 const requestedMaxTokens = overrides?.maxOutputTokens ?? options?.maxTokens ?? model.maxTokens;
-                const effort = resolveWireEffort(model, options?.reasoning);
                 const body = {
                     model: model.id,
                     input: toResponsesInput(context, model, config.replayReasoning !== false, builtToolNames),
@@ -290,17 +278,18 @@ export function createOpenResponsesBrain(given = {}) {
                     builtMaxTokens = undefined;
                     builtMaxTokensLane = "unset";
                 }
-                if (effort !== undefined)
-                    body.reasoning = { effort };
+                const { body: reasoningBody, effort } = applyReasoningToRequest({ api: "openai-responses", model, level: options?.reasoning, body });
                 const headers = mergeHeaders(modelHeaders, config.headers, optionsHeaders);
                 applyRouteCredentialHeaders(headers, routeCredential);
+                const declared = declaredRequestValues([modelHeaders, config.headers, optionsHeaders, headers], [], apiKey);
                 lockHeader(headers, "content-type", "application/json");
                 if (apiKey)
                     lockHeader(headers, OPEN_RESPONSES_KEY_HEADER, `Bearer ${apiKey}`);
-                const { body: wire, dropped: extraBodyDropped } = applyExtraBody(body, model, RESPONSES_RESERVED);
+                const { body: wire, dropped: extraBodyDropped } = applyExtraBody(reasoningBody, model, RESPONSES_RESERVED);
                 return {
                     url,
                     headers,
+                    declared,
                     body: JSON.stringify(wire),
                     extraBodyDropped,
                     route: requestRouteOf(routeCredential, rootOrigin),
@@ -576,10 +565,10 @@ export function createOpenResponsesBrain(given = {}) {
                         case "response.failed": {
                             noteResponseModel(partial, frame.response?.model, model.id);
                             const err = frame.response?.error;
-                            throw new BrainError(responsesErrorCode(err?.code), `responses stream failed (${err?.code ?? "unknown"}): ${err?.message ?? ""}`, undefined, { apiError: true });
+                            throw new BrainError(responsesErrorCode(err?.code), `responses stream failed ${ctrl.providerWords(`(${err?.code ?? "unknown"}): ${err?.message ?? ""}`)}`, undefined, { apiError: true });
                         }
                         case "error": {
-                            throw new BrainError(responsesErrorCode(frame.code), `responses stream error (${frame.code ?? "unknown"}): ${frame.message ?? ""}`, undefined, { apiError: true });
+                            throw new BrainError(responsesErrorCode(frame.code), `responses stream error ${ctrl.providerWords(`(${frame.code ?? "unknown"}): ${frame.message ?? ""}`)}`, undefined, { apiError: true });
                         }
                         default:
                             return;
@@ -620,7 +609,7 @@ export function createOpenResponsesBrain(given = {}) {
                         }
                         catch {
                             malformedFrames++;
-                            malformedSample ??= data.slice(0, MALFORMED_SAMPLE_CHARS);
+                            malformedSample ??= ctrl.providerWords(data).slice(0, MALFORMED_SAMPLE_CHARS);
                             return;
                         }
                         handleFrame(frame);
@@ -673,10 +662,10 @@ export function createOpenResponsesBrain(given = {}) {
                                     finalContent.push(tc);
                                 }
                                 else if (acc.name) {
-                                    malformed.push(`${acc.name}(${acc.args.slice(0, MALFORMED_ARGS_CHARS)})`);
+                                    malformed.push(`${ctrl.providerWords(acc.name)}(${ctrl.providerWords(acc.args).slice(0, MALFORMED_ARGS_CHARS)})`);
                                 }
                                 else {
-                                    (nameMissingCause(closed) === "truncated" ? malformed : unnamed).push(`call_id="${acc.callId || "?"}"(${acc.args.slice(0, MALFORMED_ARGS_CHARS)})`);
+                                    (nameMissingCause(closed) === "truncated" ? malformed : unnamed).push(`call_id="${ctrl.providerWords(acc.callId || "?")}"(${ctrl.providerWords(acc.args).slice(0, MALFORMED_ARGS_CHARS)})`);
                                 }
                             }
                         }
@@ -721,14 +710,14 @@ export function createOpenResponsesBrain(given = {}) {
                             : safetyCut
                                 ? `[refusal] response cut by the provider content filter (incomplete_details.reason="${INCOMPLETE_CONTENT_FILTER}") — the output was censored/truncated for policy and is unreliable`
                                 : refused
-                                    ? `[refusal] response refused by the model for policy reasons: ${accumRefusal.trim()}`
+                                    ? `[refusal] response refused by the model for policy reasons: ${ctrl.providerWords(accumRefusal.trim())}`
                                     : (toolError ??
                                         (truncatedEmpty && !dynamicCut && !staticReasoningCut
                                             ? reasoningSeen
                                                 ? `[length_empty] response truncated at max_output_tokens (${maxTokensNote}) with no answer text — the model spent the whole budget on reasoning; raise the cap, or lower the reasoning effort for this task.`
                                                 : `[length_empty] response truncated at max_output_tokens (${maxTokensNote}) with no answer text — raise the cap`
                                             : emptyNoFinish
-                                                ? `[stream_torn] model stream ended with no content and ${terminalStatus === undefined ? "no terminal response event" : `a terminal status "${terminalStatus}" with no reason this client recognises (incomplete_details.reason=${incompleteReason ?? "absent"})`} — the response was lost (a torn stream or an in-band provider error frame)${malformedFrames > 0 ? ` — ${malformedFrames} unparseable data frame(s) were dropped on this stream (first sample: ${JSON.stringify(malformedSample)})` : ""}`
+                                                ? `[stream_torn] model stream ended with no content and ${terminalStatus === undefined ? "no terminal response event" : `a terminal status "${ctrl.providerWords(terminalStatus)}" with no reason this client recognises (incomplete_details.reason=${incompleteReason === undefined ? "absent" : ctrl.providerWords(String(incompleteReason))})`} — the response was lost (a torn stream or an in-band provider error frame)${malformedFrames > 0 ? ` — ${malformedFrames} unparseable data frame(s) were dropped on this stream (first sample: ${JSON.stringify(malformedSample)})` : ""}`
                                                 : undefined));
                         const errored = degenerate ||
                             safetyCut ||