@oh-my-pi/pi-agent-core 16.3.14 → 16.4.0

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## [Unreleased]
 
+## [16.4.0] - 2026-07-10
+
+### Added
+
+- Added the `ThinkingLevel.Max` ("max") configuration option, mapping to the `Effort.Max` tier for supported models.
+
+### Fixed
+
+- Fixed remote compaction behavior for Codex Responses Lite (GPT-5.6 family) models across both V1 and V2 endpoints to ensure correct formatting and routing.
+- Fixed an issue where aborted tool-result hooks could trigger subsequent provider calls before the abort signal fully settled.
+
 ## [16.3.12] - 2026-07-08
 
 ### Added

package/README.md

@@ -134,7 +134,7 @@ const agent = new Agent({
   initialState: {
     systemPrompt: string[],
     model: Model,
-    thinkingLevel: "off" | "minimal" | "low" | "medium" | "high" | "xhigh",
+    thinkingLevel: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max",
     tools: AgentTool<any>[],
     messages: AgentMessage[],
   },

package/dist/types/agent-loop.d.ts

@@ -26,6 +26,12 @@ export interface ToolScopedAbortReason {
 }
 /** Creates an abort reason that labels matching tool calls separately from siblings. */
 export declare function createToolScopedAbortReason(message: string, toolCallMessages: Record<string, string>, defaultToolCallMessage: string): ToolScopedAbortReason;
+/**
+ * Marks an abort raised by a completed post-tool hook as terminal for the
+ * current run. External/user aborts still synthesize an aborted assistant
+ * boundary; this reason stops after persisting the completed tool batch.
+ */
+export declare const TERMINAL_TOOL_RESULT_ABORT_REASON: unique symbol;
 export declare function resolveOwnedDialectFromEnv(value: string | undefined): Dialect | undefined;
 /**
  * Start an agent loop with a new prompt message.

package/dist/types/compaction/compaction-v2-streaming.d.ts

@@ -6,7 +6,7 @@
  * compaction output item, then install retained real user messages plus that
  * compaction item as replacement history.
  */
-import type { FetchImpl, Model } from "@oh-my-pi/pi-ai";
+import type { CodexCompactionContext, FetchImpl, Model, ProviderSessionState } from "@oh-my-pi/pi-ai";
 /** Retained-message budget Codex uses after streamed V2 compaction. */
 export declare const V2_RETAINED_MESSAGE_TOKEN_BUDGET = 64000;
 /** Max retries for V2 streaming compaction on transient stream errors. */
@@ -66,6 +66,8 @@ export declare function requestCompactionV2Streaming(model: Model, apiKey: strin
     fetch?: FetchImpl;
     timeoutMs?: number;
     retryWait?: (delayMs: number, signal?: AbortSignal) => Promise<void>;
+    providerSessionState?: Map<string, ProviderSessionState>;
+    codexCompaction?: CodexCompactionContext;
 }): Promise<CompactionV2Response>;
 /** Build Codex-style V2 replacement history from prompt input plus compaction output. */
 export declare function buildCompactionV2ReplacementHistory(input: unknown[], compactionItem: Record<string, unknown>, retainedMessageBudget?: number): {

package/dist/types/compaction/compaction.d.ts

@@ -4,7 +4,7 @@
  * Pure functions for compaction logic. The session manager handles I/O,
  * and after compaction the session is reloaded.
  */
-import { type Api, type ApiKey, type AssistantMessage, type Context, type FetchImpl, type MessageAttribution, type Model, type SimpleStreamOptions, type Tool, type Usage } from "@oh-my-pi/pi-ai";
+import { type Api, type ApiKey, type AssistantMessage, type CodexCompactionContext, type Context, type FetchImpl, type MessageAttribution, type Model, type ProviderSessionState, type SimpleStreamOptions, type Tool, type Usage } from "@oh-my-pi/pi-ai";
 import { type AgentTelemetry } from "../telemetry.js";
 import { ThinkingLevel } from "../thinking.js";
 import type { AgentMessage } from "../types.js";
@@ -184,6 +184,10 @@ export interface SummaryOptions {
     sessionId?: string;
     /** Prompt-cache key for remote compaction transports that support provider prefix caching. */
     promptCacheKey?: string;
+    /** Mutable provider state used to keep Codex compaction on the live session identity. */
+    providerSessionState?: Map<string, ProviderSessionState>;
+    /** Classification shared by every provider request in this logical compaction. */
+    codexCompaction?: CodexCompactionContext;
     /** Provider-visible tools for remote compaction transports that replay native tool history. */
     tools?: Tool[];
     /** Optional fetch implementation threaded into remote compaction calls. */

package/dist/types/compaction/openai.d.ts

@@ -14,7 +14,7 @@
  *   summarization endpoints that accept `{ systemPrompt, prompt }` and reply
  *   with `{ summary, shortSummary? }`.
  */
-import type { FetchImpl, Message, Model } from "@oh-my-pi/pi-ai/types";
+import type { CodexCompactionContext, FetchImpl, Message, Model, ProviderSessionState } from "@oh-my-pi/pi-ai/types";
 export * from "./compaction-v2-streaming.js";
 export declare const OPENAI_REMOTE_COMPACTION_PRESERVE_KEY = "openaiRemoteCompaction";
 /**
@@ -70,6 +70,9 @@ export declare function buildOpenAiNativeHistory(messages: Message[], model: Mod
 export declare function requestOpenAiRemoteCompaction(model: Model, apiKey: string, compactInput: Array<Record<string, unknown>>, instructions: string, signal?: AbortSignal, opts?: {
     fetch?: FetchImpl;
     timeoutMs?: number;
+    sessionId?: string;
+    providerSessionState?: Map<string, ProviderSessionState>;
+    codexCompaction?: CodexCompactionContext;
 }): Promise<OpenAiRemoteCompactionResponse>;
 /**
  * Generic remote-compaction POST. Two wire shapes are auto-selected by

package/dist/types/thinking.d.ts

@@ -12,6 +12,7 @@ export declare const ThinkingLevel: {
     readonly Medium: Effort.Medium;
     readonly High: Effort.High;
     readonly XHigh: Effort.XHigh;
+    readonly Max: Effort.Max;
 };
 export type ThinkingLevel = (typeof ThinkingLevel)[keyof typeof ThinkingLevel];
 export type ResolvedThinkingLevel = Exclude<ThinkingLevel, "inherit">;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-agent-core",
-	"version": "16.3.14",
+	"version": "16.4.0",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -35,12 +35,12 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "16.3.14",
-		"@oh-my-pi/pi-catalog": "16.3.14",
-		"@oh-my-pi/pi-natives": "16.3.14",
-		"@oh-my-pi/pi-utils": "16.3.14",
-		"@oh-my-pi/pi-wire": "16.3.14",
-		"@oh-my-pi/snapcompact": "16.3.14",
+		"@oh-my-pi/pi-ai": "16.4.0",
+		"@oh-my-pi/pi-catalog": "16.4.0",
+		"@oh-my-pi/pi-natives": "16.4.0",
+		"@oh-my-pi/pi-utils": "16.4.0",
+		"@oh-my-pi/pi-wire": "16.4.0",
+		"@oh-my-pi/snapcompact": "16.4.0",
 		"@opentelemetry/api": "^1.9.1"
 	},
 	"devDependencies": {

package/src/agent-loop.ts

@@ -132,6 +132,13 @@ export function createToolScopedAbortReason(
 	return { kind: "tool-scoped-abort", message, toolCallMessages, defaultToolCallMessage };
 }
 
+/**
+ * Marks an abort raised by a completed post-tool hook as terminal for the
+ * current run. External/user aborts still synthesize an aborted assistant
+ * boundary; this reason stops after persisting the completed tool batch.
+ */
+export const TERMINAL_TOOL_RESULT_ABORT_REASON = Symbol.for("pi-agent-core.terminal-tool-result");
+
 const STEERING_INTERRUPT_POLL_MS = 250;
 
 class HarmonyLeakInterruption extends Error {
@@ -1084,6 +1091,12 @@ async function runLoopBody(
 					}
 				}
 
+				// A tool hook may mark its completed result as terminal (e.g. subagent yield).
+				// Stop before the next provider call without changing external/user abort semantics.
+				if (signal?.reason === TERMINAL_TOOL_RESULT_ABORT_REASON) {
+					hasMoreToolCalls = false;
+				}
+
 				if (toolCalls.length > 0) {
 					pausedTurnContinuations = 0;
 				} else if (

package/src/compaction/compaction-v2-streaming.ts

@@ -7,10 +7,16 @@
  * compaction item as replacement history.
  */
 
-import type { Api, FetchImpl, Model } from "@oh-my-pi/pi-ai";
+import type { Api, CodexCompactionContext, FetchImpl, Model, ProviderSessionState } from "@oh-my-pi/pi-ai";
 import { isTransientStatus, ProviderHttpError } from "@oh-my-pi/pi-ai/error";
+import { applyCodexResponsesLiteShape } from "@oh-my-pi/pi-ai/providers/openai-codex/request-transformer";
 import {
-	getOpenAIResponsesPromptCacheKey,
+	createOpenAICodexCompactionRequestContext,
+	createOpenAICodexCompatibilityMetadata,
+	type OpenAICodexCompatibilityMetadata,
+} from "@oh-my-pi/pi-ai/providers/openai-codex-responses";
+import {
+	getOpenAIPromptCacheKey,
 	getOpenAIResponsesRoutingSessionId,
 	parseAzureDeploymentNameMap,
 	resolveOpenAIRequestSetup,
@@ -219,6 +225,8 @@ export async function requestCompactionV2Streaming(
 		fetch?: FetchImpl;
 		timeoutMs?: number;
 		retryWait?: (delayMs: number, signal?: AbortSignal) => Promise<void>;
+		providerSessionState?: Map<string, ProviderSessionState>;
+		codexCompaction?: CodexCompactionContext;
 	},
 ): Promise<CompactionV2Response> {
 	const endpoint = getCompactionV2Endpoint(model);
@@ -228,12 +236,32 @@ export async function requestCompactionV2Streaming(
 
 	const fetchImpl = options?.fetch ?? globalThis.fetch;
 	const retryWait = options?.retryWait ?? ((delayMs: number) => Bun.sleep(delayMs));
+	const isCodexResponses = compactionV2Api(model) === "openai-codex-responses" || model.provider === "openai-codex";
+	const codexMetadata = isCodexResponses
+		? createOpenAICodexCompatibilityMetadata({
+				sessionId: request.sessionId,
+				providerSessionState: options?.providerSessionState,
+				requestKind: "compaction",
+				compaction: createOpenAICodexCompactionRequestContext({
+					context: options?.codexCompaction,
+					implementation: "responses_compaction_v2",
+				}),
+			})
+		: undefined;
 	let lastError: Error | undefined;
 
 	for (let attempt = 0; attempt <= V2_COMPACTION_MAX_RETRIES; attempt++) {
 		const timeoutSignal = withRequestTimeout(signal, options?.timeoutMs ?? V2_COMPACTION_TIMEOUT_MS);
 		try {
-			return await attemptCompactionV2Streaming(endpoint, apiKey, model, request, fetchImpl, timeoutSignal);
+			return await attemptCompactionV2Streaming(
+				endpoint,
+				apiKey,
+				model,
+				request,
+				fetchImpl,
+				timeoutSignal,
+				codexMetadata,
+			);
 		} catch (err) {
 			const error = err instanceof Error ? err : new Error(String(err));
 			if (signal?.aborted) throw error;
@@ -264,25 +292,41 @@ async function attemptCompactionV2Streaming(
 	request: CompactionV2Request,
 	fetchImpl: FetchImpl,
 	signal?: AbortSignal,
+	codexMetadata?: OpenAICodexCompatibilityMetadata,
 ): Promise<CompactionV2Response> {
 	// Faithful to Codex: append the compaction trigger as the final input item
 	// of an otherwise-normal Responses request, then stream the result. `store`
 	// stays false — compaction must never persist a server-side response object.
 	const cacheOptions = { sessionId: request.sessionId, promptCacheKey: request.promptCacheKey };
-	const promptCacheKey = getOpenAIResponsesPromptCacheKey(cacheOptions);
+	const promptCacheKey = getOpenAIPromptCacheKey(cacheOptions);
 	const body: Record<string, unknown> = {
 		model: request.model,
 		input: [...request.input, COMPACTION_TRIGGER_ITEM],
 		instructions: request.instructions,
 		stream: true,
 		store: false,
-		...(request.reasoning ? { reasoning: request.reasoning, include: ["reasoning.encrypted_content"] } : {}),
+		...(request.reasoning
+			? {
+					// Lite implies gpt-5.4+, where codex-rs sends `all_turns` replay.
+					reasoning: model.useResponsesLite ? { ...request.reasoning, context: "all_turns" } : request.reasoning,
+					include: ["reasoning.encrypted_content"],
+				}
+			: {}),
 		...(promptCacheKey ? { prompt_cache_key: promptCacheKey } : {}),
 		...(request.tools && request.tools.length > 0 ? { tools: request.tools, tool_choice: "auto" } : {}),
 	};
+	if (codexMetadata) {
+		body.client_metadata = codexMetadata.clientMetadata;
+	}
+	// Responses Lite models take the same rewrite on the compaction stream:
+	// instructions/tools ride as input items (codex-rs `compact_remote_v2`
+	// builds through `build_responses_request`).
+	if (model.useResponsesLite) {
+		applyCodexResponsesLiteShape(body);
+	}
 	const response = await fetchImpl(endpoint, {
 		method: "POST",
-		headers: buildCompactionV2Headers(model, apiKey, request),
+		headers: buildCompactionV2Headers(model, apiKey, request, codexMetadata),
 		body: JSON.stringify(body),
 		signal,
 	});
@@ -307,11 +351,16 @@ async function attemptCompactionV2Streaming(
 	return collectCompactionV2Output(response, request);
 }
 
-function buildCompactionV2Headers(model: Model, apiKey: string, request: CompactionV2Request): Record<string, string> {
+function buildCompactionV2Headers(
+	model: Model,
+	apiKey: string,
+	request: CompactionV2Request,
+	codexMetadata?: OpenAICodexCompatibilityMetadata,
+): Record<string, string> {
 	const api = compactionV2Api(model);
 	const cacheOptions = { sessionId: request.sessionId, promptCacheKey: request.promptCacheKey };
 	const routingSessionId = getOpenAIResponsesRoutingSessionId(cacheOptions);
-	const promptCacheSessionId = getOpenAIResponsesPromptCacheKey(cacheOptions);
+	const promptCacheSessionId = getOpenAIPromptCacheKey(cacheOptions);
 	const headers: Record<string, string> =
 		api === "azure-openai-responses"
 			? {
@@ -338,7 +387,11 @@ function buildCompactionV2Headers(model: Model, apiKey: string, request: Compact
 		}
 		headers[OPENAI_HEADERS.BETA] = OPENAI_HEADER_VALUES.BETA_RESPONSES;
 		headers[OPENAI_HEADERS.ORIGINATOR] = OPENAI_HEADER_VALUES.ORIGINATOR_CODEX;
+		if (model.useResponsesLite) {
+			headers[OPENAI_HEADERS.RESPONSES_LITE] = "true";
+		}
 	}
+	if (codexMetadata) Object.assign(headers, codexMetadata.headers);
 
 	return headers;
 }

package/src/compaction/compaction.ts

@@ -9,18 +9,21 @@ import {
 	type Api,
 	type ApiKey,
 	type AssistantMessage,
+	type CodexCompactionContext,
 	type Context,
 	Effort,
 	type FetchImpl,
 	type Message,
 	type MessageAttribution,
 	type Model,
+	type ProviderSessionState,
 	type SimpleStreamOptions,
 	type Tool,
 	type Usage,
 	withAuth,
 } from "@oh-my-pi/pi-ai";
 import { ProviderHttpError } from "@oh-my-pi/pi-ai/error";
+import { createOpenAICodexCompactionRequestContext } from "@oh-my-pi/pi-ai/providers/openai-codex-responses";
 import { convertTools } from "@oh-my-pi/pi-ai/providers/openai-responses";
 import { buildResponsesInput, resolveOpenAICompatPolicy } from "@oh-my-pi/pi-ai/providers/openai-shared";
 import { preferredDialect } from "@oh-my-pi/pi-catalog/identity";
@@ -656,6 +659,8 @@ function effortFromThinkingLevel(level: ThinkingLevel): Effort {
 			return Effort.High;
 		case ThinkingLevel.XHigh:
 			return Effort.XHigh;
+		case ThinkingLevel.Max:
+			return Effort.Max;
 		case ThinkingLevel.Off:
 		case ThinkingLevel.Inherit:
 			throw new Error(`effortFromThinkingLevel: ${level} must be handled by caller`);
@@ -736,6 +741,10 @@ export interface SummaryOptions {
 	sessionId?: string;
 	/** Prompt-cache key for remote compaction transports that support provider prefix caching. */
 	promptCacheKey?: string;
+	/** Mutable provider state used to keep Codex compaction on the live session identity. */
+	providerSessionState?: Map<string, ProviderSessionState>;
+	/** Classification shared by every provider request in this logical compaction. */
+	codexCompaction?: CodexCompactionContext;
 	/** Provider-visible tools for remote compaction transports that replay native tool history. */
 	tools?: Tool[];
 	/** Optional fetch implementation threaded into remote compaction calls. */
@@ -755,6 +764,13 @@ export interface SummaryOptions {
 	) => Promise<AssistantMessage>;
 }
 
+function localCodexCompaction(options: SummaryOptions | undefined) {
+	return createOpenAICodexCompactionRequestContext({
+		context: options?.codexCompaction,
+		implementation: "responses",
+	});
+}
+
 function formatPreviousSnapcompactArchive(archiveText: string): string {
 	return prompt.render(snapcompactArchiveContextPrompt, { archiveText });
 }
@@ -844,6 +860,11 @@ export async function generateSummary(
 			reasoning: resolveCompactionEffort(model, options?.thinkingLevel),
 			initiatorOverride: options?.initiatorOverride,
 			metadata: options?.metadata,
+			fetch: options?.fetch,
+			sessionId: options?.sessionId,
+			promptCacheKey: options?.promptCacheKey,
+			providerSessionState: options?.providerSessionState,
+			codexCompaction: localCodexCompaction(options),
 		},
 		{ telemetry: options?.telemetry, oneshotKind: "compaction_summary", completeImpl: options?.completeImpl },
 	);
@@ -1047,6 +1068,11 @@ async function generateShortSummary(
 			reasoning: resolveCompactionEffort(model, options?.thinkingLevel),
 			initiatorOverride: options?.initiatorOverride,
 			metadata: options?.metadata,
+			fetch: options?.fetch,
+			sessionId: options?.sessionId,
+			promptCacheKey: options?.promptCacheKey,
+			providerSessionState: options?.providerSessionState,
+			codexCompaction: localCodexCompaction(options),
 		},
 		{ telemetry: options?.telemetry, oneshotKind: "compaction_short_summary", completeImpl: options?.completeImpl },
 	);
@@ -1317,6 +1343,8 @@ export async function compact(
 		thinkingLevel: options?.thinkingLevel,
 		sessionId: options?.sessionId,
 		promptCacheKey: options?.promptCacheKey,
+		providerSessionState: options?.providerSessionState,
+		codexCompaction: options?.codexCompaction,
 		tools: options?.tools,
 		fetch: options?.fetch,
 		completeImpl: options?.completeImpl,
@@ -1375,7 +1403,12 @@ export async function compact(
 				);
 				const remote = await withAuth(
 					apiKey,
-					key => requestCompactionV2Streaming(model, key, request, signal, { fetch: summaryOptions.fetch }),
+					key =>
+						requestCompactionV2Streaming(model, key, request, signal, {
+							fetch: summaryOptions.fetch,
+							providerSessionState: summaryOptions.providerSessionState,
+							codexCompaction: summaryOptions.codexCompaction,
+						}),
 					{ signal },
 				);
 				preserveData = { ...(preserveData ?? {}), ...storeCompactionV2PreserveData(remote, model) };
@@ -1419,7 +1452,12 @@ export async function compact(
 							remoteHistory,
 							summaryOptions.remoteInstructions ?? SUMMARIZATION_SYSTEM_PROMPT,
 							signal,
-							{ fetch: summaryOptions.fetch },
+							{
+								fetch: summaryOptions.fetch,
+								sessionId: summaryOptions.sessionId,
+								providerSessionState: summaryOptions.providerSessionState,
+								codexCompaction: summaryOptions.codexCompaction,
+							},
 						),
 					{ signal },
 				);
@@ -1495,16 +1533,9 @@ export async function compact(
 	const shortSummary = usedRemoteCompaction
 		? "Remote compaction"
 		: await generateShortSummary(recentMessages, summary, model, reserveTokens, apiKey, signal, {
+				...summaryOptions,
 				extraContext: options?.extraContext,
-				remoteEndpoint: summaryOptions.remoteEndpoint,
-				initiatorOverride: summaryOptions.initiatorOverride,
-				metadata: summaryOptions.metadata,
-				telemetry: summaryOptions.telemetry,
-				// Same propagation as summaryOptions above — generateShortSummary
-				// resolves its own reasoning via resolveCompactionEffort.
 				thinkingLevel: options?.thinkingLevel,
-				fetch: summaryOptions.fetch,
-				completeImpl: summaryOptions.completeImpl,
 			});
 
 	// Compute file lists and append to summary
@@ -1567,6 +1598,11 @@ async function generateTurnPrefixSummary(
 			reasoning: resolveCompactionEffort(model, options?.thinkingLevel),
 			initiatorOverride: options?.initiatorOverride,
 			metadata: options?.metadata,
+			fetch: options?.fetch,
+			sessionId: options?.sessionId,
+			promptCacheKey: options?.promptCacheKey,
+			providerSessionState: options?.providerSessionState,
+			codexCompaction: localCodexCompaction(options),
 		},
 		{ telemetry: options?.telemetry, oneshotKind: "compaction_turn_prefix", completeImpl: options?.completeImpl },
 	);

package/src/compaction/openai.ts

@@ -16,9 +16,22 @@
  */
 
 import { ProviderHttpError } from "@oh-my-pi/pi-ai/error";
+import { applyCodexResponsesLiteShape } from "@oh-my-pi/pi-ai/providers/openai-codex/request-transformer";
+import {
+	createOpenAICodexCompactionRequestContext,
+	createOpenAICodexCompatibilityMetadata,
+} from "@oh-my-pi/pi-ai/providers/openai-codex-responses";
 import { parseAzureDeploymentNameMap, parseTextSignature } from "@oh-my-pi/pi-ai/providers/openai-shared";
 import { transformMessages } from "@oh-my-pi/pi-ai/providers/transform-messages";
-import type { Api, AssistantMessage, FetchImpl, Message, Model } from "@oh-my-pi/pi-ai/types";
+import type {
+	Api,
+	AssistantMessage,
+	CodexCompactionContext,
+	FetchImpl,
+	Message,
+	Model,
+	ProviderSessionState,
+} from "@oh-my-pi/pi-ai/types";
 import {
 	getOpenAIResponsesHistoryItems,
 	getOpenAIResponsesHistoryPayload,
@@ -460,7 +473,13 @@ export async function requestOpenAiRemoteCompaction(
 	compactInput: Array<Record<string, unknown>>,
 	instructions: string,
 	signal?: AbortSignal,
-	opts?: { fetch?: FetchImpl; timeoutMs?: number },
+	opts?: {
+		fetch?: FetchImpl;
+		timeoutMs?: number;
+		sessionId?: string;
+		providerSessionState?: Map<string, ProviderSessionState>;
+		codexCompaction?: CodexCompactionContext;
+	},
 ): Promise<OpenAiRemoteCompactionResponse> {
 	const endpoint = resolveOpenAiCompactEndpoint(model);
 	const requestModel = resolveOpenAiCompactModel(model);
@@ -473,6 +492,8 @@ export async function requestOpenAiRemoteCompaction(
 		instructions,
 	};
 	const isAzureOpenAiResponses = (model.remoteCompaction?.api ?? model.api) === "azure-openai-responses";
+	const isCodexResponses =
+		model.provider === "openai-codex" || (model.remoteCompaction?.api ?? model.api) === "openai-codex-responses";
 	const headers: Record<string, string> = isAzureOpenAiResponses
 		? {
 				"content-type": "application/json",
@@ -486,13 +507,33 @@ export async function requestOpenAiRemoteCompaction(
 			};
 
 	// Codex endpoints require additional auth headers
-	if (model.provider === "openai-codex") {
+	if (isCodexResponses) {
 		const accountId = getCodexAccountId(apiKey);
 		if (accountId) {
 			headers[OPENAI_HEADERS.ACCOUNT_ID] = accountId;
 		}
 		headers[OPENAI_HEADERS.BETA] = OPENAI_HEADER_VALUES.BETA_RESPONSES;
 		headers[OPENAI_HEADERS.ORIGINATOR] = OPENAI_HEADER_VALUES.ORIGINATOR_CODEX;
+		Object.assign(
+			headers,
+			createOpenAICodexCompatibilityMetadata({
+				sessionId: opts?.sessionId,
+				providerSessionState: opts?.providerSessionState,
+				requestKind: "compaction",
+				compaction: createOpenAICodexCompactionRequestContext({
+					context: opts?.codexCompaction,
+					implementation: "responses_compact",
+				}),
+				includeInstallationHeader: true,
+			}).headers,
+		);
+		// Responses Lite models take the same rewrite on `/responses/compact`:
+		// instructions ride as an input item and the lite marker header is set
+		// (codex-rs routes compaction through `build_responses_request`).
+		if (model.useResponsesLite) {
+			applyCodexResponsesLiteShape(request);
+			headers[OPENAI_HEADERS.RESPONSES_LITE] = "true";
+		}
 	}
 
 	const response = await (opts?.fetch ?? fetch)(endpoint, {

package/src/thinking.ts

@@ -13,6 +13,7 @@ export const ThinkingLevel = {
 	Medium: Effort.Medium,
 	High: Effort.High,
 	XHigh: Effort.XHigh,
+	Max: Effort.Max,
 } as const;
 
 export type ThinkingLevel = (typeof ThinkingLevel)[keyof typeof ThinkingLevel];