@oh-my-pi/pi-ai 17.2.13 → 17.2.14

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [17.2.14] - 2026-08-11
+
+### Added
+
+- Added `forceReasoningOff` and `disableReasoning` options to disable reasoning in OpenAI and Azure OpenAI models
+
 ## [17.2.13] - 2026-08-11
 
 ### Changed

package/dist/types/providers/azure-openai-responses.d.ts

@@ -9,6 +9,7 @@ export interface AzureOpenAIResponsesOptions extends StreamOptions {
     azureDeploymentName?: string;
     toolChoice?: ToolChoice;
     serviceTier?: ServiceTier;
+    disableReasoning?: boolean;
 }
 /**
  * Generate function for Azure OpenAI Responses API

package/dist/types/providers/openai-codex/request-transformer.d.ts

@@ -13,6 +13,8 @@ export interface ReasoningConfig {
 export interface CodexRequestOptions {
     /** User-facing effort; maps 1:1 onto the wire tier of the same name. */
     reasoningEffort?: CodexCallerEffort | "none";
+    /** Suppress native reasoning by sending `reasoning.effort: "none"`. */
+    reasoningOff?: boolean;
     reasoningSummary?: ReasoningConfig["summary"] | null;
     /** Explicit `reasoning.context` override. Omitted by default; Responses Lite forces `all_turns` as required by that transport. */
     reasoningContext?: CodexReasoningContext;

package/dist/types/providers/openai-responses.d.ts

@@ -114,6 +114,7 @@ type OpenAIResponsesSamplingParams = ResponseCreateParamsStreaming & {
 export declare const streamOpenAIResponses: StreamFunction<"openai-responses">;
 export declare function buildParams(model: Model<"openai-responses">, context: Context, options: OpenAIResponsesOptions | undefined, providerSessionState: OpenAIResponsesProviderSessionState | undefined, strictToolsScope?: OpenAIStrictToolsScope, disableStrictToolsOverride?: boolean, statefulCacheBaseline?: ResponseInput): {
     params: OpenAIResponsesSamplingParams;
+    trailingScaffoldingItems: number;
     strictToolsApplied: boolean;
 };
 /**

package/dist/types/providers/openai-shared.d.ts

@@ -505,6 +505,8 @@ export declare function appendMessageContentPart(item: ResponseOutputMessage, pa
 export declare function appendMessageTextDelta(item: ResponseOutputMessage, block: TextContent, delta: string, stream: AssistantMessageEventStream, output: AssistantMessage, contentIndex: number, partType: "output_text" | "refusal"): void;
 /** Chooses final message text while treating non-empty terminal content as authoritative. */
 export declare function finalizeMessageText(item: ResponseOutputMessage, streamedText: string): string;
+export declare const JUICE_EFFORT_MAP: Record<string, number>;
+export declare function getJuiceValue(effort?: string): number;
 export declare function accumulateToolCallArgumentsDelta(block: ResponsesToolCallBlock, delta: string, stream: AssistantMessageEventStream, output: AssistantMessage, contentIndex: number): void;
 /**
  * Finalize streamed function-call arguments from the authoritative `.done`
@@ -591,6 +593,14 @@ type ReasoningOptions = {
 export interface ApplyResponsesCompatPolicyOptions {
     reasoningSummary?: "auto" | "detailed" | "concise" | null;
     mapEffort?: (effort: string) => string;
+    /**
+     * Suppress native reasoning by sending `reasoning.effort: "none"` — the only
+     * disable level the Responses API defines (`"off"` is not a wire value and
+     * 400s everywhere). Gateways that reject `none` for a given model are
+     * handled by the reasoning-effort fallback retry, which clamps to the
+     * lowest level the error reports as allowed.
+     */
+    forceReasoningOff?: boolean;
 }
 export declare function applyResponsesCompatPolicy<P extends ResponseCreateParamsStreaming>(params: P, policy: OpenAICompatPolicy, options: ApplyResponsesCompatPolicyOptions | undefined): void;
 /**

package/dist/types/types.d.ts

@@ -294,6 +294,11 @@ export interface StreamOptions {
      * `false` so `previous_response_id` cannot explain a result.
      */
     statefulResponses?: boolean;
+    /**
+     * Emit `reasoning: { effort: "none" }` for OpenAI Responses and Codex requests.
+     * Used when a caller supplies an external reasoning scratchpad; other transports ignore it.
+     */
+    forceReasoningOff?: boolean;
     /**
      * Provider-scoped mutable state store for this agent session.
      * Providers can use this to persist transport/session state between turns.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "17.2.13",
+	"version": "17.2.14",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -38,10 +38,10 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.1",
-		"@oh-my-pi/omptype": "17.2.13",
-		"@oh-my-pi/pi-catalog": "17.2.13",
-		"@oh-my-pi/pi-utils": "17.2.13",
-		"@oh-my-pi/pi-wire": "17.2.13"
+		"@oh-my-pi/omptype": "17.2.14",
+		"@oh-my-pi/pi-catalog": "17.2.14",
+		"@oh-my-pi/pi-utils": "17.2.14",
+		"@oh-my-pi/pi-wire": "17.2.14"
 	},
 	"devDependencies": {
 		"@bufbuild/protoc-gen-es": "^2.12.1",

package/src/providers/azure-openai-responses.ts

@@ -65,6 +65,7 @@ export interface AzureOpenAIResponsesOptions extends StreamOptions {
 	azureDeploymentName?: string;
 	toolChoice?: ToolChoice;
 	serviceTier?: ServiceTier;
+	disableReasoning?: boolean;
 }
 
 type AzureOpenAIResponsesSamplingParams = ResponseCreateParamsStreaming & {

package/src/providers/openai-codex/request-transformer.ts

@@ -32,6 +32,8 @@ export interface ReasoningConfig {
 export interface CodexRequestOptions {
 	/** User-facing effort; maps 1:1 onto the wire tier of the same name. */
 	reasoningEffort?: CodexCallerEffort | "none";
+	/** Suppress native reasoning by sending `reasoning.effort: "none"`. */
+	reasoningOff?: boolean;
 	reasoningSummary?: ReasoningConfig["summary"] | null;
 	/** Explicit `reasoning.context` override. Omitted by default; Responses Lite forces `all_turns` as required by that transport. */
 	reasoningContext?: CodexReasoningContext;
@@ -454,9 +456,12 @@ export async function transformRequestBody(
 		applyCodexResponsesLiteShape(body);
 	}
 
-	if (options.reasoningEffort !== undefined || responsesLite) {
-		const reasoningConfig =
-			options.reasoningEffort !== undefined ? getReasoningConfig(model, options.reasoningEffort, options) : {};
+	if (options.reasoningOff || options.reasoningEffort !== undefined || responsesLite) {
+		const reasoningConfig: Partial<ReasoningConfig> = options.reasoningOff
+			? { effort: "none" }
+			: options.reasoningEffort !== undefined
+				? getReasoningConfig(model, options.reasoningEffort, options)
+				: {};
 		body.reasoning = {
 			...body.reasoning,
 			...reasoningConfig,
@@ -478,7 +483,7 @@ export async function transformRequestBody(
 	// Catalog pro aliases (`gpt-5.6-*-pro`): applied after the effort branch so
 	// the mode is sent even when no effort is set (the branch above deletes
 	// `body.reasoning` in that case) — mode and effort are independent fields.
-	if (model.reasoningMode) {
+	if (model.reasoningMode && !options.reasoningOff) {
 		body.reasoning = { ...body.reasoning, mode: model.reasoningMode };
 	}
 

package/src/providers/openai-codex-responses.ts

@@ -1529,6 +1529,7 @@ export async function buildTransformedCodexRequestBody(
 	}
 	const codexOptions: CodexRequestOptions = {
 		reasoningEffort: options?.reasoning,
+		reasoningOff: options?.forceReasoningOff,
 		reasoningSummary: options?.reasoningSummary,
 		reasoningContext: options?.reasoningContext,
 		textVerbosity: options?.textVerbosity,

package/src/providers/openai-reasoning-fallback.ts

@@ -132,7 +132,13 @@ function collectMessageParts(error: unknown, captured: CapturedHttpErrorResponse
 	return parts.join("\n");
 }
 
-const REASONING_EFFORT_FIELD_PATTERN = /reasoning[_. ]effort|reasoning value/i;
+/**
+ * Text that identifies a 400 as being about the reasoning-effort field.
+ * OpenAI-compatible gateways (cliproxy, …) never name the field — they reject
+ * the value alone with `level "none" not supported, valid levels: low, …` — so
+ * the allowed-level phrasing counts as a mention too.
+ */
+const REASONING_EFFORT_FIELD_PATTERN = /reasoning[_. ]effort|reasoning value|(?:valid|supported|allowed) levels?/i;
 
 function mentionsReasoningEffort(error: unknown, captured: CapturedHttpErrorResponse | undefined): boolean {
 	const param = capturedStringField(captured, "param");
@@ -168,10 +174,13 @@ function isInvalidReasoningEffortError(
 	if (/(?:unsupported|not supported)[^\n]*(?:reasoning[_. ]effort|reasoning value)/i.test(message)) {
 		return true;
 	}
-	return new RegExp(
-		`(?:invalid|unsupported|not supported)[^\\n]*["'\`]${escapeRegExp(currentEffort)}["'\`]`,
-		"i",
-	).test(message);
+	// Gateways put the rejected value first (`level "none" not supported`), the
+	// official API puts the verdict first (`Unsupported value: 'none'`).
+	const quoted = `["'\`]${escapeRegExp(currentEffort)}["'\`]`;
+	return (
+		new RegExp(`(?:invalid|unsupported|not supported)[^\\n]*${quoted}`, "i").test(message) ||
+		new RegExp(`${quoted}[^\\n]*(?:invalid|unsupported|not supported)`, "i").test(message)
+	);
 }
 
 function escapeRegExp(value: string): string {
@@ -186,9 +195,12 @@ function parseKnownReasoningValues(text: string): Set<string> {
 		values.add(quotedMatch[1]!.toLowerCase());
 		quotedMatch = quotedPattern.exec(text);
 	}
-	const allowedMatch = /(?:must be|one of|allowed values?|supported values?(?: are)?|expected)([^.\n]+)/i.exec(text);
+	const allowedMatch =
+		/(?:must be|one of|allowed values?|supported values?(?: are)?|expected|(?:valid|supported|allowed) levels?(?: are)?)[^.\n]+/i.exec(
+			text,
+		);
 	if (allowedMatch) {
-		const allowedText = allowedMatch[1]!;
+		const allowedText = allowedMatch[0]!;
 		const barePattern = /\b(none|minimal|low|medium|high|xhigh|max)\b/gi;
 		let bareMatch = barePattern.exec(allowedText);
 		while (bareMatch !== null) {
@@ -201,7 +213,8 @@ function parseKnownReasoningValues(text: string): Set<string> {
 
 function parseAllowedReasoningValues(message: string, currentEffort: string): Set<string> | undefined {
 	const values = parseKnownReasoningValues(message);
-	const hasAllowedCue = /must be|one of|allowed values?|supported values?|expected/i.test(message);
+	const hasAllowedCue =
+		/must be|one of|allowed values?|supported values?|expected|(?:valid|supported|allowed) levels?/i.test(message);
 	values.delete(currentEffort.toLowerCase());
 	if (!hasAllowedCue && values.size === 0) return undefined;
 	return values;

package/src/providers/openai-responses.ts

@@ -1,5 +1,6 @@
 import { scheduler } from "node:timers/promises";
 import { hostMatchesUrl } from "@oh-my-pi/pi-catalog/hosts";
+import { bareModelId, parseOpenAIModel, semverGte } from "@oh-my-pi/pi-catalog/identity";
 import { $flag, logger, structuredCloneJSON } from "@oh-my-pi/pi-utils";
 import * as AIError from "../error";
 import { getEnvApiKey } from "../stream";
@@ -80,6 +81,7 @@ import {
 	createInitialResponsesAssistantMessage,
 	createOpenAIStrictToolsState,
 	disableStrictToolsForScope,
+	getJuiceValue,
 	getOpenAIPromptCacheKey,
 	getOpenAIResponsesRoutingSessionId,
 	getOpenAIStrictToolsScope,
@@ -298,14 +300,23 @@ interface OpenAIResponsesChainedParams {
  */
 function buildOpenAIResponsesChainedParams(
 	params: OpenAIResponsesSamplingParams,
+	trailingScaffoldingItems: number,
 	chain: OpenAIResponsesChainState,
 ): OpenAIResponsesChainedParams {
+	const historyParams =
+		trailingScaffoldingItems > 0 && Array.isArray(params.input)
+			? { ...params, input: params.input.slice(0, params.input.length - trailingScaffoldingItems) }
+			: params;
 	const deltaInput = chain.canAppend
-		? buildResponsesDeltaInput(chain.lastParams, chain.lastResponseItems, params)
+		? buildResponsesDeltaInput(chain.lastParams, chain.lastResponseItems, historyParams)
 		: null;
 	if (deltaInput && deltaInput.length > 0 && chain.lastResponseId) {
+		const scaffolding =
+			historyParams !== params && Array.isArray(params.input)
+				? params.input.slice(params.input.length - trailingScaffoldingItems)
+				: [];
 		return {
-			params: { ...params, previous_response_id: chain.lastResponseId, input: deltaInput },
+			params: { ...params, previous_response_id: chain.lastResponseId, input: [...deltaInput, ...scaffolding] },
 			previousResponseId: chain.lastResponseId,
 		};
 	}
@@ -462,8 +473,9 @@ const streamOpenAIResponsesOnce = (
 				false,
 				chainState?.canAppend ? chainState.lastParams?.input : undefined,
 			);
-			const params = builtParams.params;
+			const { params, trailingScaffoldingItems } = builtParams;
 			let activeParams = params;
+			let activeTrailingScaffoldingItems = trailingScaffoldingItems;
 			const resolvedBaseUrl = (baseUrl ?? "https://api.openai.com/v1").replace(/\/+$/, "");
 			const requestReasoningEffortFallbacks = new Map<string, OpenAIReasoningEffortFallback>();
 			const attemptedReasoningEffortFallbacks = new Set<string>();
@@ -490,7 +502,9 @@ const streamOpenAIResponsesOnce = (
 			}
 			applyReasoningEffortFallbackForRequest(params);
 			let chained: OpenAIResponsesChainedParams =
-				chainState && !chainState.disabled ? buildOpenAIResponsesChainedParams(params, chainState) : { params };
+				chainState && !chainState.disabled
+					? buildOpenAIResponsesChainedParams(params, trailingScaffoldingItems, chainState)
+					: { params };
 			sentPreviousResponseId = chained.previousResponseId;
 			const idleTimeoutMs =
 				options?.streamIdleTimeoutMs ?? getOpenAIStreamIdleTimeoutMs(model.compat.streamIdleTimeoutMs);
@@ -586,7 +600,9 @@ const streamOpenAIResponsesOnce = (
 						const reasoningEffortFallback =
 							activeReasoningEffortFallbackKey && activeRequestParams && !requestSignal.aborted
 								? resolveOpenAIReasoningEffortFallback(error, capturedErrorResponse, activeRequestParams, {
-										explicitDisable: options?.disableReasoning === true && options.reasoning === undefined,
+										explicitDisable:
+											options?.forceReasoningOff === true ||
+											(options?.disableReasoning === true && options.reasoning === undefined),
 									})
 								: undefined;
 						if (reasoningEffortFallback !== undefined && activeReasoningEffortFallbackKey) {
@@ -632,7 +648,11 @@ const streamOpenAIResponsesOnce = (
 							if (chainState && !chainState.disabled) fallbackParams.store = true;
 							let fallbackChained: OpenAIResponsesChainedParams =
 								chainState && !chainState.disabled
-									? buildOpenAIResponsesChainedParams(fallbackParams, chainState)
+									? buildOpenAIResponsesChainedParams(
+											fallbackParams,
+											fallbackBuilt.trailingScaffoldingItems,
+											chainState,
+										)
 									: { params: fallbackParams };
 							sentPreviousResponseId = fallbackChained.previousResponseId;
 							fallbackChained = {
@@ -642,7 +662,7 @@ const streamOpenAIResponsesOnce = (
 							chained = fallbackChained;
 							activeRawRequestDump.body = chained.params;
 							activeParams = fallbackParams;
-							activeStrictToolsApplied = fallbackBuilt.strictToolsApplied;
+							activeTrailingScaffoldingItems = fallbackBuilt.trailingScaffoldingItems;
 							continue;
 						}
 						if (!chainState || !sentPreviousResponseId || requestSignal.aborted) {
@@ -688,6 +708,7 @@ const streamOpenAIResponsesOnce = (
 						chained = { params: retryParams };
 						activeRawRequestDump.body = retryParams;
 						activeParams = currentParams;
+						activeTrailingScaffoldingItems = currentBuilt.trailingScaffoldingItems;
 						activeStrictToolsApplied = currentBuilt.strictToolsApplied;
 					}
 				}
@@ -824,7 +845,17 @@ const streamOpenAIResponsesOnce = (
 			if (replayableResponseItems) {
 				if (providerSessionState) providerSessionState.nativeHistoryReplayWarmed = true;
 				if (chainState) {
-					chainState.lastParams = structuredCloneJSON(activeParams);
+					chainState.lastParams = structuredCloneJSON(
+						activeTrailingScaffoldingItems > 0 && Array.isArray(activeParams.input)
+							? {
+									...activeParams,
+									input: activeParams.input.slice(
+										0,
+										activeParams.input.length - activeTrailingScaffoldingItems,
+									),
+								}
+							: activeParams,
+					);
 					chainState.lastPromptCacheBreakpointPolicy = promptCacheBreakpointPolicy;
 					if (output.responseId) {
 						chainState.lastResponseId = output.responseId;
@@ -843,7 +874,14 @@ const streamOpenAIResponsesOnce = (
 				// baseline, but `lastParams` still records the successful wire controls
 				// without re-enabling `previous_response_id` chaining.
 				chainState.canAppend = false;
-				chainState.lastParams = structuredCloneJSON(activeParams);
+				chainState.lastParams = structuredCloneJSON(
+					activeTrailingScaffoldingItems > 0 && Array.isArray(activeParams.input)
+						? {
+								...activeParams,
+								input: activeParams.input.slice(0, activeParams.input.length - activeTrailingScaffoldingItems),
+							}
+						: activeParams,
+				);
 				chainState.lastPromptCacheBreakpointPolicy = promptCacheBreakpointPolicy;
 				chainState.lastResponseId = undefined;
 				chainState.lastResponseItems = undefined;
@@ -899,6 +937,17 @@ function isOfficialOpenAIResponsesEndpoint(model: Model<"openai-responses">): bo
 	}
 }
 
+/**
+ * GPT-5.6+ family check for Responses routes. The model id classifies the
+ * reasoning family regardless of the provider/host serving it — a cliproxy or
+ * other OpenAI-compatible gateway carrying `gpt-5.6-sol` gets the same
+ * scaffolding as the official endpoint.
+ */
+function isGpt56PlusResponsesModel(model: Model<"openai-responses">): boolean {
+	const parsed = parseOpenAIModel(bareModelId(model.requestModelId ?? model.id));
+	return parsed !== null && semverGte(parsed.version, "5.6");
+}
+
 function isResponsesPromptCacheableContentBlock(block: unknown): block is ResponseInputContent {
 	if (typeof block !== "object" || block === null || !("type" in block)) return false;
 	return block.type === "input_text" || block.type === "input_image" || block.type === "input_file";
@@ -1090,7 +1139,7 @@ export function buildParams(
 	strictToolsScope?: OpenAIStrictToolsScope,
 	disableStrictToolsOverride = false,
 	statefulCacheBaseline?: ResponseInput,
-): { params: OpenAIResponsesSamplingParams; strictToolsApplied: boolean } {
+): { params: OpenAIResponsesSamplingParams; trailingScaffoldingItems: number; strictToolsApplied: boolean } {
 	const policy = resolveOpenAICompatPolicy(model, {
 		endpoint: "responses",
 		reasoning: options?.reasoning,
@@ -1244,6 +1293,7 @@ export function buildParams(
 			: options?.reasoningSummary;
 	applyResponsesCompatPolicy(params, reasoningPolicy, {
 		reasoningSummary,
+		forceReasoningOff: options?.forceReasoningOff,
 		mapEffort: effort =>
 			model.compat.reasoningEffortMap?.[effort as NonNullable<OpenAIResponsesOptions["reasoning"]>] ??
 			model.thinking?.effortMap?.[effort as NonNullable<OpenAIResponsesOptions["reasoning"]>] ??
@@ -1253,7 +1303,7 @@ export function buildParams(
 	// mode survives every policy branch (disabled/omitted effort included) while
 	// keeping whatever effort/summary the policy produced — mode and effort are
 	// independent wire fields.
-	if (model.reasoningMode) {
+	if (model.reasoningMode && !options?.forceReasoningOff) {
 		params.reasoning = { ...params.reasoning, mode: model.reasoningMode };
 	}
 
@@ -1266,7 +1316,18 @@ export function buildParams(
 	applyOpenAIExtraBody(params, options?.extraBody);
 	applyOpenAIResponsesPromptCachePolicy(params, model, options, statefulCacheBaseline);
 
-	return { params, strictToolsApplied };
+	let trailingScaffoldingItems = 0;
+	if (options?.forceReasoningOff && isGpt56PlusResponsesModel(model)) {
+		const effort = options.reasoning ?? "medium";
+		const juice = getJuiceValue(effort);
+		messages.push({
+			role: "developer",
+			content: [{ type: "input_text", text: `# Juice: ${juice} !important` }],
+		});
+		trailingScaffoldingItems = 1;
+	}
+
+	return { params, trailingScaffoldingItems, strictToolsApplied };
 }
 
 /**

package/src/providers/openai-shared.ts

@@ -2428,6 +2428,20 @@ export function finalizeMessageText(item: ResponseOutputMessage, streamedText: s
 	if (!item.content?.length) return streamedText || "";
 	return item.content.map(part => (part.type === "output_text" ? (part.text ?? "") : (part.refusal ?? ""))).join("");
 }
+export const JUICE_EFFORT_MAP: Record<string, number> = {
+	none: 0,
+	minimal: 2,
+	low: 4,
+	medium: 8,
+	high: 48,
+	xhigh: 112,
+	max: 960,
+};
+
+export function getJuiceValue(effort?: string): number {
+	if (!effort) return 8;
+	return JUICE_EFFORT_MAP[effort] ?? 8;
+}
 
 export function accumulateToolCallArgumentsDelta(
 	block: ResponsesToolCallBlock,
@@ -3308,6 +3322,14 @@ type ReasoningOptions = {
 export interface ApplyResponsesCompatPolicyOptions {
 	reasoningSummary?: "auto" | "detailed" | "concise" | null;
 	mapEffort?: (effort: string) => string;
+	/**
+	 * Suppress native reasoning by sending `reasoning.effort: "none"` — the only
+	 * disable level the Responses API defines (`"off"` is not a wire value and
+	 * 400s everywhere). Gateways that reject `none` for a given model are
+	 * handled by the reasoning-effort fallback retry, which clamps to the
+	 * lowest level the error reports as allowed.
+	 */
+	forceReasoningOff?: boolean;
 }
 
 export function applyResponsesCompatPolicy<P extends ResponseCreateParamsStreaming>(
@@ -3316,6 +3338,10 @@ export function applyResponsesCompatPolicy<P extends ResponseCreateParamsStreami
 	options: ApplyResponsesCompatPolicyOptions | undefined,
 ): void {
 	const reasoning = policy.reasoning;
+	if (options?.forceReasoningOff) {
+		params.reasoning = { effort: "none" } as P["reasoning"];
+		return;
+	}
 	if (!reasoning.modelSupported) return;
 	if (reasoning.includeEncryptedReasoning) {
 		const include = params.include ?? [];

package/src/stream.ts

@@ -1692,6 +1692,7 @@ function mapOptionsForApi<TApi extends Api>(
 				openrouterVariant: options?.openrouterVariant,
 				maxTokensExplicit: rawOptions?.maxTokens !== undefined,
 				disableReasoning: options?.disableReasoning,
+				forceReasoningOff: options?.forceReasoningOff,
 				textVerbosity: options?.textVerbosity,
 				promptCache: options?.promptCache,
 				statefulResponses: options?.statefulResponses,
@@ -1706,6 +1707,8 @@ function mapOptionsForApi<TApi extends Api>(
 				reasoningSummary: options?.hideThinkingSummary ? null : undefined,
 				promptCache: options?.promptCache,
 				statefulResponses: options?.statefulResponses,
+				disableReasoning: options?.disableReasoning || options?.forceReasoningOff,
+				forceReasoningOff: options?.forceReasoningOff,
 			});
 
 		case "openai-codex-responses":
@@ -1718,6 +1721,7 @@ function mapOptionsForApi<TApi extends Api>(
 				codexCompaction: options?.codexCompaction,
 				reasoningSummary: options?.hideThinkingSummary ? null : undefined,
 				textVerbosity: options?.textVerbosity,
+				forceReasoningOff: options?.forceReasoningOff,
 			});
 
 		case "google-generative-ai": {

package/src/types.ts

@@ -478,6 +478,11 @@ export interface StreamOptions {
 	 * `false` so `previous_response_id` cannot explain a result.
 	 */
 	statefulResponses?: boolean;
+	/**
+	 * Emit `reasoning: { effort: "none" }` for OpenAI Responses and Codex requests.
+	 * Used when a caller supplies an external reasoning scratchpad; other transports ignore it.
+	 */
+	forceReasoningOff?: boolean;
 	/**
 	 * Provider-scoped mutable state store for this agent session.
 	 * Providers can use this to persist transport/session state between turns.