@oh-my-pi/pi-ai 18.1.6 → 18.1.8

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## [Unreleased]
 
+## [18.1.8] - 2026-09-03
+
+### Added
+
+- Added GPT-6 Astra support for preserving prompt caching when changing the thinking level during a conversation across the OpenAI and OpenAI Codex providers.
+
+### Changed
+
+- Updated OpenAI Codex requests to improve routing by communicating the selected model and service tier across Responses, WebSocket, and remote-compaction requests.
+
+## [18.1.7] - 2026-09-03
+
+### Fixed
+
+- Fixed DeepSeek-family Responses replay (e.g. opencode-go) rejecting a resumed thinking-mode turn with `400 The reasoning_text in the thinking mode must be passed back to the API` when compaction dropped the turn's reasoning; a non-empty placeholder is now synthesized instead of an empty `reasoning_text` ([#10690](https://github.com/can1357/oh-my-pi/issues/10690)).
+
 ## [18.1.6] - 2026-09-03
 
 ### Breaking Changes

package/dist/types/providers/openai-configuration-update.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Mid-conversation reasoning effort via `configuration_update` input items
+ * (GPT-6 Astra; `model.compat.supportsConfigurationUpdate`).
+ *
+ * The request-level `reasoning.effort` is pinned to the value of the session's
+ * first request so the cached prompt prefix survives an effort change. Each
+ * later change is carried as a `configuration_update` item inserted at the
+ * tail of the transcript — before the user message it takes effect on, or
+ * after the latest tool result when the level changes inside a tool loop — and
+ * replayed at that position on every subsequent request until another update
+ * overrides it. Mirrors the Anthropic provider's stable `output_config.effort`
+ * planning.
+ *
+ * Used by both the platform Responses provider and the Codex provider; the
+ * state lives in each provider's session state, keyed per conversation.
+ *
+ * Wire constraints (verified against the Codex backend): only `gpt-6-astra`
+ * accepts the item type, consecutive updates are rejected, and
+ * `/responses/compact` rejects histories containing them — compaction
+ * requests are built outside this planner and never carry the items.
+ */
+/** `configuration_update` input item; only `reasoning.effort` is updatable. */
+export interface ConfigurationUpdateItem {
+    type: "configuration_update";
+    reasoning: {
+        effort: string;
+    };
+}
+interface EffortTransition<TEffort extends string> {
+    /** Input-array position the item is spliced into (before `input[index]`). */
+    index: number;
+    /** Fingerprint of `input[index - 1]` at record time; a mismatch means the history was rewritten. */
+    anchor: string;
+    effort: TEffort;
+}
+/** Per-conversation effort baseline and recorded transitions. */
+export interface OpenAIEffortControlState<TEffort extends string = string> {
+    baseEffort?: TEffort;
+    currentEffort?: TEffort;
+    transitions: EffortTransition<TEffort>[];
+}
+export declare function createOpenAIEffortControlState<TEffort extends string>(): OpenAIEffortControlState<TEffort>;
+/**
+ * Fetch (or create) the control state for one conversation from a provider's
+ * bounded per-session map, refreshing its LRU slot.
+ */
+export declare function getOpenAIEffortControlState<TEffort extends string>(states: Map<string, OpenAIEffortControlState<TEffort>>, key: string): OpenAIEffortControlState<TEffort>;
+interface AnchorableItem {
+    type?: string | null;
+    role?: string;
+    id?: string | null;
+    status?: string | null;
+}
+/**
+ * Pin the request-level effort to the session baseline and splice pending
+ * `configuration_update` items into `input` (mutated in place).
+ *
+ * `input` is the freshly built transcript for this request, without any
+ * `configuration_update` items. `requested` is the wire effort the caller
+ * would otherwise send at the request level. Returns the effort to send at the
+ * request level (`requested` on the first request, the baseline afterwards).
+ */
+export declare function planStableOpenAIEffort<TItem extends AnchorableItem, TEffort extends string>(state: OpenAIEffortControlState<TEffort>, input: Array<TItem | ConfigurationUpdateItem>, requested: TEffort): TEffort;
+export {};

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

@@ -2918,7 +2918,7 @@ export interface ResponseInputImageContent {
  * `assistant` role are presumed to have been generated by the model in previous
  * interactions.
  */
-export type ResponseInputItem = EasyInputMessage | ResponseInputItem.Message | ResponseOutputMessage | ResponseFileSearchToolCall | ResponseComputerToolCall | ResponseInputItem.ComputerCallOutput | ResponseFunctionWebSearch | ResponseFunctionToolCall | ResponseInputItem.FunctionCallOutput | ResponseInputItem.ToolSearchCall | ResponseToolSearchOutputItemParam | ResponseInputItem.AdditionalTools | ResponseReasoningItem | ResponseCompactionItemParam | ResponseInputItem.ImageGenerationCall | ResponseCodeInterpreterToolCall | ResponseInputItem.LocalShellCall | ResponseInputItem.LocalShellCallOutput | ResponseInputItem.ShellCall | ResponseInputItem.ShellCallOutput | ResponseInputItem.ApplyPatchCall | ResponseInputItem.ApplyPatchCallOutput | ResponseInputItem.McpListTools | ResponseInputItem.McpApprovalRequest | ResponseInputItem.McpApprovalResponse | ResponseInputItem.McpCall | ResponseCustomToolCallOutput | ResponseCustomToolCall | ResponseInputItem.CompactionTrigger | ResponseInputItem.ItemReference;
+export type ResponseInputItem = EasyInputMessage | ResponseInputItem.Message | ResponseOutputMessage | ResponseFileSearchToolCall | ResponseComputerToolCall | ResponseInputItem.ComputerCallOutput | ResponseFunctionWebSearch | ResponseFunctionToolCall | ResponseInputItem.FunctionCallOutput | ResponseInputItem.ToolSearchCall | ResponseToolSearchOutputItemParam | ResponseInputItem.AdditionalTools | ResponseReasoningItem | ResponseCompactionItemParam | ResponseInputItem.ImageGenerationCall | ResponseCodeInterpreterToolCall | ResponseInputItem.LocalShellCall | ResponseInputItem.LocalShellCallOutput | ResponseInputItem.ShellCall | ResponseInputItem.ShellCallOutput | ResponseInputItem.ApplyPatchCall | ResponseInputItem.ApplyPatchCallOutput | ResponseInputItem.McpListTools | ResponseInputItem.McpApprovalRequest | ResponseInputItem.McpApprovalResponse | ResponseInputItem.McpCall | ResponseCustomToolCallOutput | ResponseCustomToolCall | ResponseInputItem.CompactionTrigger | ResponseInputItem.ConfigurationUpdate | ResponseInputItem.ItemReference;
 export declare namespace ResponseInputItem {
     /**
      * A message input to the model with a role indicating instruction following
@@ -3504,6 +3504,20 @@ export declare namespace ResponseInputItem {
          */
         type: "compaction_trigger";
     }
+    /**
+     * Changes reasoning effort for subsequent responses without touching the
+     * request-level `reasoning.effort` (GPT-6 Astra). Must not be adjacent to
+     * another `configuration_update`.
+     */
+    interface ConfigurationUpdate {
+        /**
+         * The type of the item. Always `configuration_update`.
+         */
+        type: "configuration_update";
+        reasoning: {
+            effort: string;
+        };
+    }
     /**
      * An internal identifier for an item to reference.
      */

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

@@ -1,7 +1,8 @@
 import type { Context, Model, OpenAICompat, ProviderSessionState, ServiceTier, StreamFunction, StreamOptions, Tool, ToolChoice } from "../types.js";
 import { type OpenAIResponsesToolChoice } from "../utils/tool-choice.js";
+import { type OpenAIEffortControlState } from "./openai-configuration-update.js";
 import { type OpenAIReasoningEffortFallbackState } from "./openai-reasoning-fallback.js";
-import type { Tool as OpenAITool, ResponseCreateParamsStreaming, ResponseInput } from "./openai-responses-wire.js";
+import type { Tool as OpenAITool, ReasoningEffort, ResponseCreateParamsStreaming, ResponseInput } from "./openai-responses-wire.js";
 import { type OpenAIPromptCacheOptions, type OpenAIStrictToolsScope, type OpenAIStrictToolsState } from "./openai-shared.js";
 export interface OpenAIResponsesOptions extends StreamOptions {
     reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
@@ -63,7 +64,11 @@ interface OpenAIResponsesProviderSessionState extends ProviderSessionState, Open
     nativeHistoryReplayWarmed: boolean;
     /** Stateful `previous_response_id` chain baselines, keyed by baseUrl/model/session. */
     chains: Map<string, OpenAIResponsesChainState>;
+    /** `configuration_update` effort baselines, keyed by baseUrl/model/session. */
+    effortControls: Map<string, OpenAIEffortControlState<ResponsesStableEffort>>;
 }
+/** Wire efforts a `configuration_update` can carry: every real tier, never `none`/null. */
+type ResponsesStableEffort = Exclude<ReasoningEffort, "none" | null>;
 interface OpenAIResponsesChainState {
     /**
      * Wire params of the last successful turn; never carries

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

@@ -493,6 +493,18 @@ export interface BuildResponsesInputOptions<TApi extends Api> {
  */
 export declare function escapeReplayedControlTokens(items: ResponseInput): ResponseInput;
 export declare function buildResponsesInput<TApi extends Api>(options: BuildResponsesInputOptions<TApi>): ResponseInput;
+/**
+ * Non-empty `reasoning_text` shipped for a synthesized reasoning item when no
+ * thinking text survived history reconstruction. DeepSeek-family Responses
+ * targets (e.g. opencode-go) reject BOTH a missing reasoning item and one whose
+ * `reasoning_text` is empty — "The reasoning_text in the thinking mode must be
+ * passed back to the API" (#8248 covered the missing case, #10690 the empty
+ * one). The item's presence plus a non-empty payload is what satisfies the
+ * contract; the exact text is immaterial once the source turn's reasoning is
+ * gone. Kept out of `reasoning_content="."`-territory since DeepSeek rejects the
+ * bare-dot synthetic placeholder on the chat-completions path.
+ */
+export declare const SYNTHETIC_REASONING_REPLAY_PLACEHOLDER = "reasoning unavailable";
 export declare function convertResponsesAssistantMessage<TApi extends Api>(assistantMsg: AssistantMessage, model: Model<TApi>, msgIndex: number, knownCallIds: Set<string>, includeThinkingSignatures?: boolean, customCallIds?: Set<string>, preserveMessageIds?: boolean, supportsCustomToolCalls?: boolean, customToolWireNameMap?: ReadonlyMap<string, string>, computerCallIds?: Set<string>, requiresReasoningReplayForAllTurns?: boolean, requiresReasoningReplayForToolCalls?: boolean): ResponseInput;
 /**
  * Responses wire output for a tool result plus its text-only fallback.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "18.1.6",
+	"version": "18.1.8",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Stencil Labs, Inc.",
@@ -37,10 +37,10 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.1.6",
-		"@oh-my-pi/pi-catalog": "18.1.6",
-		"@oh-my-pi/pi-utils": "18.1.6",
-		"@oh-my-pi/pi-wire": "18.1.6"
+		"@oh-my-pi/omptype": "18.1.8",
+		"@oh-my-pi/pi-catalog": "18.1.8",
+		"@oh-my-pi/pi-utils": "18.1.8",
+		"@oh-my-pi/pi-wire": "18.1.8"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

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

@@ -5,6 +5,7 @@ import {
 	applyCodexResidencyHeader,
 	CODEX_BASE_URL,
 	CODEX_CLIENT_VERSION,
+	codexRoutingHint,
 	getCodexAccountId,
 	OPENAI_HEADER_VALUES,
 	OPENAI_HEADERS,
@@ -74,11 +75,17 @@ import {
 	type CodexReasoningContext,
 	type CodexRequestOptions,
 	type InputItem,
+	type ReasoningConfig,
 	type RequestBody,
 	resolveCodexResponsesLite,
 	transformRequestBody,
 } from "./openai-codex/request-transformer";
 import { CodexApiError } from "./openai-codex/response-handler";
+import {
+	getOpenAIEffortControlState,
+	type OpenAIEffortControlState,
+	planStableOpenAIEffort,
+} from "./openai-configuration-update";
 import type {
 	ResponseComputerToolCall,
 	ResponseCustomToolCall,
@@ -476,6 +483,8 @@ interface CodexProviderSessionState extends ProviderSessionState {
 	webSocketSessions: Map<string, CodexWebSocketSessionState>;
 	webSocketPublicToPrivate: Map<string, string>;
 	metadataSessions: Map<string, CodexMetadataSessionState>;
+	/** `configuration_update` effort baselines, keyed by model + session. */
+	effortControls: Map<string, OpenAIEffortControlState<ReasoningConfig["effort"]>>;
 }
 
 /** Request classification encoded in Codex turn metadata. */
@@ -1051,6 +1060,7 @@ function createCodexProviderSessionState(): CodexProviderSessionState {
 		webSocketSessions: new Map(),
 		webSocketPublicToPrivate: new Map(),
 		metadataSessions: new Map(),
+		effortControls: new Map(),
 		close: () => {
 			for (const session of state.webSocketSessions.values()) {
 				session.connection?.close("session_disposed");
@@ -1058,6 +1068,7 @@ function createCodexProviderSessionState(): CodexProviderSessionState {
 			state.webSocketSessions.clear();
 			state.webSocketPublicToPrivate.clear();
 			state.metadataSessions.clear();
+			state.effortControls.clear();
 		},
 	};
 	return state;
@@ -1071,7 +1082,9 @@ function isCodexProviderSessionState(state: ProviderSessionState | undefined): s
 		"webSocketPublicToPrivate" in state &&
 		state.webSocketPublicToPrivate instanceof Map &&
 		"metadataSessions" in state &&
-		state.metadataSessions instanceof Map
+		state.metadataSessions instanceof Map &&
+		"effortControls" in state &&
+		state.effortControls instanceof Map
 	);
 }
 
@@ -1573,7 +1586,30 @@ export async function buildTransformedCodexRequestBody(
 		responsesLite: options?.responsesLite,
 	};
 
-	return transformRequestBody(params, model, codexOptions, { developerMessages });
+	const body = await transformRequestBody(params, model, codexOptions, { developerMessages });
+	applyCodexStableEffort(model, body, options);
+	return body;
+}
+
+/**
+ * Keep the request-level effort byte-stable across a conversation and carry
+ * later changes as `configuration_update` items (GPT-6 Astra). Requires a
+ * session id and provider session state to remember the baseline; without
+ * them every request stands alone and sends its own effort.
+ */
+function applyCodexStableEffort(
+	model: Model<"openai-codex-responses">,
+	body: RequestBody,
+	options: OpenAICodexResponsesOptions | undefined,
+): void {
+	if (!model.compat.supportsConfigurationUpdate || options?.codexCompaction) return;
+	const effort = body.reasoning?.effort;
+	if (effort === undefined || effort === "none" || !body.input) return;
+	const providerState = getCodexProviderSessionState(options?.providerSessionState);
+	const sessionId = normalizeOpenAIPromptCacheKey(options?.sessionId);
+	if (!providerState || !sessionId) return;
+	const state = getOpenAIEffortControlState(providerState.effortControls, `${model.id}\u0000${sessionId}`);
+	body.reasoning = { ...body.reasoning, effort: planStableOpenAIEffort(state, body.input, effort) };
 }
 
 async function openInitialCodexEventStream(
@@ -1800,6 +1836,7 @@ async function openCodexWebSocketTransport(
 		requestContext.responsesLite,
 		requestContext.requestMetadata,
 		await getCodexAttestationHeader(requestContext.accountId),
+		requestContext.transformedBody,
 	);
 	const requestBodyForState = structuredCloneJSON(requestContext.transformedBody);
 	// `onPayload` may rewrite the outgoing frame (e.g. drop `stream_options`);
@@ -4273,6 +4310,7 @@ async function openCodexSseEventStream(
 		responsesLite,
 		requestMetadata,
 		await getCodexAttestationHeader(accountId),
+		body,
 	);
 	// `wrapCodexSseStream` arms the iterator-level idle watchdog only after this
 	// fetch resolves. Each transport attempt needs its own pre-response timer:
@@ -4367,11 +4405,19 @@ function createCodexHeaders(
 	responsesLite = false,
 	requestMetadata?: CodexCompatibilityIdentity,
 	attestation?: string,
+	routedRequest?: Pick<RequestBody, "model" | "service_tier">,
 ): Headers {
 	const headers = new Headers(initHeaders ?? {});
 	headers.delete("x-api-key");
 	headers.set("Authorization", `Bearer ${accessToken}`);
 	if (accountId) headers.set(OPENAI_HEADERS.ACCOUNT_ID, accountId);
+	// codex-rs sends the hint on every ChatGPT-OAuth request and WebSocket
+	// handshake; this provider only ever speaks to the Codex backend.
+	if (routedRequest) {
+		headers.set(OPENAI_HEADERS.ROUTING_HINT, codexRoutingHint(routedRequest.model, routedRequest.service_tier));
+	} else {
+		headers.delete(OPENAI_HEADERS.ROUTING_HINT);
+	}
 	// Region-pinned enterprise workspaces answer 401 `Workspace is not authorized
 	// in this region.` when the request's egress region does not match them and
 	// the client did not declare the workspace's residency. The access token

package/src/providers/openai-configuration-update.ts

@@ -0,0 +1,170 @@
+/**
+ * Mid-conversation reasoning effort via `configuration_update` input items
+ * (GPT-6 Astra; `model.compat.supportsConfigurationUpdate`).
+ *
+ * The request-level `reasoning.effort` is pinned to the value of the session's
+ * first request so the cached prompt prefix survives an effort change. Each
+ * later change is carried as a `configuration_update` item inserted at the
+ * tail of the transcript — before the user message it takes effect on, or
+ * after the latest tool result when the level changes inside a tool loop — and
+ * replayed at that position on every subsequent request until another update
+ * overrides it. Mirrors the Anthropic provider's stable `output_config.effort`
+ * planning.
+ *
+ * Used by both the platform Responses provider and the Codex provider; the
+ * state lives in each provider's session state, keyed per conversation.
+ *
+ * Wire constraints (verified against the Codex backend): only `gpt-6-astra`
+ * accepts the item type, consecutive updates are rejected, and
+ * `/responses/compact` rejects histories containing them — compaction
+ * requests are built outside this planner and never carry the items.
+ */
+
+/** `configuration_update` input item; only `reasoning.effort` is updatable. */
+export interface ConfigurationUpdateItem {
+	type: "configuration_update";
+	reasoning: { effort: string };
+}
+
+interface EffortTransition<TEffort extends string> {
+	/** Input-array position the item is spliced into (before `input[index]`). */
+	index: number;
+	/** Fingerprint of `input[index - 1]` at record time; a mismatch means the history was rewritten. */
+	anchor: string;
+	effort: TEffort;
+}
+
+/** Per-conversation effort baseline and recorded transitions. */
+export interface OpenAIEffortControlState<TEffort extends string = string> {
+	baseEffort?: TEffort;
+	currentEffort?: TEffort;
+	transitions: EffortTransition<TEffort>[];
+}
+
+export function createOpenAIEffortControlState<TEffort extends string>(): OpenAIEffortControlState<TEffort> {
+	return { transitions: [] };
+}
+
+const MAX_EFFORT_CONTROL_STATES = 16;
+
+/**
+ * Fetch (or create) the control state for one conversation from a provider's
+ * bounded per-session map, refreshing its LRU slot.
+ */
+export function getOpenAIEffortControlState<TEffort extends string>(
+	states: Map<string, OpenAIEffortControlState<TEffort>>,
+	key: string,
+): OpenAIEffortControlState<TEffort> {
+	const existing = states.get(key);
+	if (existing) {
+		states.delete(key);
+		states.set(key, existing);
+		return existing;
+	}
+	const created = createOpenAIEffortControlState<TEffort>();
+	states.set(key, created);
+	if (states.size > MAX_EFFORT_CONTROL_STATES) {
+		const oldest = states.keys().next().value;
+		if (oldest !== undefined) states.delete(oldest);
+	}
+	return created;
+}
+
+interface AnchorableItem {
+	type?: string | null;
+	role?: string;
+	id?: string | null;
+	status?: string | null;
+}
+
+/**
+ * Fingerprint of the item a transition sits after. Output-only lifecycle
+ * fields are excluded: a live response item carries `id`/`status` that the
+ * sanitized replay of the same item drops.
+ */
+function effortControlAnchor(input: readonly AnchorableItem[], index: number): string {
+	if (index === 0) return "";
+	const item = input[index - 1];
+	if (!item) return "";
+	const { id: _id, status: _status, ...stable } = item;
+	return String(Bun.hash(JSON.stringify(stable)));
+}
+
+function resetOpenAIEffortControlState(state: OpenAIEffortControlState<string>): void {
+	state.baseEffort = undefined;
+	state.currentEffort = undefined;
+	state.transitions = [];
+}
+
+/**
+ * Discard the baseline when the request no longer continues the conversation
+ * it was captured for: a wire history that shrank or was rewritten under a
+ * recorded transition (compaction, branch switch, `/clear`). The next request
+ * re-baselines from its own effort, which is what the API asks for after
+ * compaction anyway.
+ */
+function syncOpenAIEffortControlState(state: OpenAIEffortControlState<string>, input: readonly AnchorableItem[]): void {
+	for (const transition of state.transitions) {
+		if (transition.index > input.length || transition.anchor !== effortControlAnchor(input, transition.index)) {
+			resetOpenAIEffortControlState(state);
+			return;
+		}
+	}
+}
+
+/**
+ * Pin the request-level effort to the session baseline and splice pending
+ * `configuration_update` items into `input` (mutated in place).
+ *
+ * `input` is the freshly built transcript for this request, without any
+ * `configuration_update` items. `requested` is the wire effort the caller
+ * would otherwise send at the request level. Returns the effort to send at the
+ * request level (`requested` on the first request, the baseline afterwards).
+ */
+export function planStableOpenAIEffort<TItem extends AnchorableItem, TEffort extends string>(
+	state: OpenAIEffortControlState<TEffort>,
+	input: Array<TItem | ConfigurationUpdateItem>,
+	requested: TEffort,
+): TEffort {
+	syncOpenAIEffortControlState(state, input);
+	if (state.baseEffort === undefined) {
+		state.baseEffort = requested;
+		state.currentEffort = requested;
+		return requested;
+	}
+	if (state.currentEffort !== requested) {
+		const last = input[input.length - 1];
+		const index = last && "role" in last && last.role === "user" ? input.length - 1 : input.length;
+		const existing = state.transitions.find(transition => transition.index === index);
+		if (existing) {
+			existing.effort = requested;
+		} else {
+			state.transitions.push({ index, anchor: effortControlAnchor(input, index), effort: requested });
+		}
+		// A change back to the effort already in force at that position is a
+		// no-op on the wire; drop it rather than send a redundant item.
+		let preceding = state.baseEffort;
+		let precedingIndex = -1;
+		for (const transition of state.transitions) {
+			if (transition.index < index && transition.index > precedingIndex) {
+				preceding = transition.effort;
+				precedingIndex = transition.index;
+			}
+		}
+		if (requested === preceding) {
+			state.transitions = state.transitions.filter(transition => transition.index !== index);
+		}
+		state.currentEffort = requested;
+	}
+	// Splice in ascending order so each insertion offsets only the ones after it.
+	state.transitions.sort((a, b) => a.index - b.index);
+	let offset = 0;
+	for (const transition of state.transitions) {
+		input.splice(transition.index + offset, 0, {
+			type: "configuration_update",
+			reasoning: { effort: transition.effort },
+		});
+		offset++;
+	}
+	return state.baseEffort;
+}

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

@@ -3013,6 +3013,7 @@ export type ResponseInputItem =
 	| ResponseCustomToolCallOutput
 	| ResponseCustomToolCall
 	| ResponseInputItem.CompactionTrigger
+	| ResponseInputItem.ConfigurationUpdate
 	| ResponseInputItem.ItemReference;
 export declare namespace ResponseInputItem {
 	/**
@@ -3599,6 +3600,20 @@ export declare namespace ResponseInputItem {
 		 */
 		type: "compaction_trigger";
 	}
+	/**
+	 * Changes reasoning effort for subsequent responses without touching the
+	 * request-level `reasoning.effort` (GPT-6 Astra). Must not be adjacent to
+	 * another `configuration_update`.
+	 */
+	interface ConfigurationUpdate {
+		/**
+		 * The type of the item. Always `configuration_update`.
+		 */
+		type: "configuration_update";
+		reasoning: {
+			effort: string;
+		};
+	}
 	/**
 	 * An internal identifier for an item to reference.
 	 */

package/src/providers/openai-responses.ts

@@ -48,6 +48,11 @@ import {
 	type OpenAIResponsesToolChoice,
 } from "../utils/tool-choice";
 import { compactGrammarDefinition } from "./grammar";
+import {
+	getOpenAIEffortControlState,
+	type OpenAIEffortControlState,
+	planStableOpenAIEffort,
+} from "./openai-configuration-update";
 import {
 	applyOpenAIReasoningEffortFallback,
 	clearOpenAIReasoningEffortFallbackState,
@@ -61,6 +66,7 @@ import {
 } from "./openai-reasoning-fallback";
 import type {
 	Tool as OpenAITool,
+	ReasoningEffort,
 	ResponseCreateParamsStreaming,
 	ResponseInput,
 	ResponseInputContent,
@@ -197,8 +203,13 @@ interface OpenAIResponsesProviderSessionState
 	nativeHistoryReplayWarmed: boolean;
 	/** Stateful `previous_response_id` chain baselines, keyed by baseUrl/model/session. */
 	chains: Map<string, OpenAIResponsesChainState>;
+	/** `configuration_update` effort baselines, keyed by baseUrl/model/session. */
+	effortControls: Map<string, OpenAIEffortControlState<ResponsesStableEffort>>;
 }
 
+/** Wire efforts a `configuration_update` can carry: every real tier, never `none`/null. */
+type ResponsesStableEffort = Exclude<ReasoningEffort, "none" | null>;
+
 interface OpenAIResponsesChainState {
 	/**
 	 * Wire params of the last successful turn; never carries
@@ -224,9 +235,11 @@ function createOpenAIResponsesProviderSessionState(): OpenAIResponsesProviderSes
 		...reasoningEffortFallbackState,
 		nativeHistoryReplayWarmed: false,
 		chains: new Map(),
+		effortControls: new Map(),
 		close: () => {
 			state.nativeHistoryReplayWarmed = false;
 			state.chains.clear();
+			state.effortControls.clear();
 			clearOpenAIStrictToolsState(state);
 			clearOpenAIReasoningEffortFallbackState(state);
 		},
@@ -1275,6 +1288,7 @@ export function buildParams(
 	if (model.reasoningMode && !options?.forceReasoningOff) {
 		params.reasoning = { ...params.reasoning, mode: model.reasoningMode };
 	}
+	applyResponsesStableEffort(model, params, messages, options, providerSessionState);
 
 	if (model.compat.isVercelGatewayHost) {
 		applyVercelResponsesCacheControls(params, model.compat, cacheRetention);
@@ -1299,6 +1313,33 @@ export function buildParams(
 	return { params, trailingScaffoldingItems, strictToolsApplied };
 }
 
+/**
+ * Keep the request-level effort byte-stable across a conversation and carry
+ * later changes as `configuration_update` items (GPT-6 Astra). Requires a
+ * routing session id and provider session state to remember the baseline;
+ * without them every request stands alone and sends its own effort.
+ */
+function applyResponsesStableEffort(
+	model: Model<"openai-responses">,
+	params: OpenAIResponsesSamplingParams,
+	input: ResponseInput,
+	options: OpenAIResponsesOptions | undefined,
+	providerSessionState: OpenAIResponsesProviderSessionState | undefined,
+): void {
+	if (!model.compat.supportsConfigurationUpdate || !providerSessionState) return;
+	const reasoning = params.reasoning;
+	if (!reasoning || !("effort" in reasoning)) return;
+	const effort = reasoning.effort;
+	if (effort === undefined || effort === null || effort === "none") return;
+	const sessionId = getOpenAIResponsesRoutingSessionId(options);
+	if (!sessionId) return;
+	const state = getOpenAIEffortControlState(
+		providerSessionState.effortControls,
+		`${model.baseUrl ?? ""}\u0000${model.id}\u0000${sessionId}`,
+	);
+	params.reasoning = { ...reasoning, effort: planStableOpenAIEffort(state, input, effort) };
+}
+
 /**
  * Whether this model should get the OpenAI custom-tool grammar variant
  * for `apply_patch`. The generated model catalog sets

package/src/providers/openai-shared.ts

@@ -2111,6 +2111,19 @@ function parseResponseReasoningReplayItem(signature: string | undefined): Respon
 	}
 }
 
+/**
+ * Non-empty `reasoning_text` shipped for a synthesized reasoning item when no
+ * thinking text survived history reconstruction. DeepSeek-family Responses
+ * targets (e.g. opencode-go) reject BOTH a missing reasoning item and one whose
+ * `reasoning_text` is empty — "The reasoning_text in the thinking mode must be
+ * passed back to the API" (#8248 covered the missing case, #10690 the empty
+ * one). The item's presence plus a non-empty payload is what satisfies the
+ * contract; the exact text is immaterial once the source turn's reasoning is
+ * gone. Kept out of `reasoning_content="."`-territory since DeepSeek rejects the
+ * bare-dot synthetic placeholder on the chat-completions path.
+ */
+export const SYNTHETIC_REASONING_REPLAY_PLACEHOLDER = "reasoning unavailable";
+
 export function convertResponsesAssistantMessage<TApi extends Api>(
 	assistantMsg: AssistantMessage,
 	model: Model<TApi>,
@@ -2268,12 +2281,15 @@ export function convertResponsesAssistantMessage<TApi extends Api>(
 	if (requiresReasoningItem && !reasoningItemEmitted && outputItems.length > 0) {
 		// Replay the demoted reasoning (already present in `content` as visible
 		// text) as a structured reasoning item so the thinking-mode continuation
-		// carries the `reasoning_text` the provider requires. The text may be empty
-		// when the source turn was minted by another model and its reasoning is
-		// already folded into the message text; the item's presence is what
-		// satisfies the provider contract, mirroring the empty `reasoning_content`
-		// placeholder used on the chat-completions path.
-		const reasoningText = carriedReasoningTexts.join("\n");
+		// carries the `reasoning_text` the provider requires. When no thinking
+		// text survived reconstruction (source turn minted by another model, or
+		// reasoning dropped by compaction/archive budget) the carried text is
+		// empty — and DeepSeek-family targets reject an empty `reasoning_text`
+		// exactly like a missing item (#10690), so substitute a non-empty
+		// placeholder. The `id` still prefers a surviving upstream item id.
+		const carriedReasoningText = carriedReasoningTexts.join("\n");
+		const reasoningText =
+			carriedReasoningText.length > 0 ? carriedReasoningText : SYNTHETIC_REASONING_REPLAY_PLACEHOLDER;
 		const reasoningId =
 			synthesizedReasoningItemId ?? `rs_${Bun.hash(`${model.id}:${msgIndex}:${reasoningText}`).toString(36)}`;
 		const reasoningItem: ResponseReasoningItem = {