@oai404iao/pi-codex-runtime 0.1.0-alpha.1

package/src/capabilities.ts

@@ -0,0 +1,146 @@
+import type { CodexMinimalToolsSettings } from "./settings.js";
+import { loadModelSettings } from "./model-catalog/runtime.js";
+
+export const PACKAGE_TOOL_NAMES = ["image_generation", "view_image", "apply_patch", "web_search"] as const;
+export type PackageToolName = (typeof PACKAGE_TOOL_NAMES)[number];
+export const NATIVE_MUTATION_TOOL_NAMES = ["edit", "write"] as const;
+export type NativeMutationToolName = (typeof NATIVE_MUTATION_TOOL_NAMES)[number];
+
+export interface ModelLike {
+	provider?: string;
+	id?: string;
+	name?: string;
+	api?: string;
+	input?: string[];
+	capabilities?: {
+		input?: string[];
+		inputModalities?: string[];
+	};
+}
+
+export interface ToolCapability {
+	enabled: boolean;
+	reason: string;
+}
+
+export type ToolCapabilityMap = Record<PackageToolName, ToolCapability>;
+
+export function modelKey(model: ModelLike | undefined): string {
+	if (!model) return "no model";
+	return `${model.provider ?? "unknown"}/${model.id ?? model.name ?? "unknown"}`;
+}
+
+export function supportsImageInput(model: ModelLike | undefined): boolean {
+	const inputs = [
+		...(model?.input ?? []),
+		...(model?.capabilities?.input ?? []),
+		...(model?.capabilities?.inputModalities ?? []),
+	].map((value) => value.toLowerCase());
+	return inputs.includes("image") || inputs.includes("images") || inputs.includes("vision");
+}
+
+export function computeToolCapabilities(model: ModelLike | undefined, settings: CodexMinimalToolsSettings): ToolCapabilityMap {
+	if (!settings.enabled) {
+		return {
+			image_generation: { enabled: false, reason: "package disabled" },
+			view_image: { enabled: false, reason: "package disabled" },
+			apply_patch: { enabled: false, reason: "package disabled" },
+			web_search: { enabled: false, reason: "package disabled" },
+		};
+	}
+
+	const modelSettings = loadModelSettings(model, undefined, settings);
+	const profile = modelSettings.modelProfile?.effective;
+	if (!profile || !profile.enabled) {
+		return {
+			image_generation: { enabled: false, reason: "model has no enabled model catalog profile" },
+			view_image: { enabled: false, reason: "model has no enabled model catalog profile" },
+			apply_patch: { enabled: false, reason: "model has no enabled model catalog profile" },
+			web_search: { enabled: false, reason: "model has no enabled model catalog profile" },
+		};
+	}
+
+	const imageInput = supportsImageInput(model);
+	const imageGeneration = profile.tools.imageGeneration;
+	const webSearch = profile.tools.webSearch;
+	const providerShimActive = modelSettings.providerShimActive;
+
+	return {
+		image_generation: imageGeneration === "hosted" && providerShimActive && imageInput
+			? { enabled: true, reason: "model profile enables hosted image_generation" }
+			: imageGeneration === "standalone" && imageInput
+				? { enabled: true, reason: "model profile enables standalone image generation" }
+				: profile.tools.imageGeneration !== false && settings.directImageApiFallback
+				? { enabled: true, reason: "direct Images API fallback enabled" }
+				: { enabled: false, reason: imageGeneration === false ? "image_generation disabled by model profile" : "model does not advertise image input" },
+		view_image: profile.tools.viewImage && imageInput
+			? { enabled: true, reason: "model profile enables view_image and model accepts image input" }
+			: { enabled: false, reason: !profile.tools.viewImage ? "view_image disabled by model profile" : "model does not advertise image input" },
+		apply_patch: profile.tools.applyPatch === "custom" && !providerShimActive
+			? {
+				enabled: false,
+				reason: "custom apply_patch requires an OpenAI Responses provider shim API",
+			}
+			: profile.tools.applyPatch
+			? { enabled: true, reason: `model profile enables ${profile.tools.applyPatch} apply_patch` }
+			: {
+				enabled: false,
+				reason: "apply_patch disabled by model profile",
+			},
+		web_search: webSearch && (webSearch.implementation === "standalone" || providerShimActive)
+			? { enabled: true, reason: `model profile enables ${webSearch.implementation} web search` }
+			: {
+				enabled: false,
+				reason: webSearch !== false && webSearch.implementation === "hosted"
+					? "hosted web_search requires an OpenAI Responses provider shim API"
+					: "web_search disabled by model profile",
+			},
+	};
+}
+
+export function desiredPackageTools(model: ModelLike | undefined, settings: CodexMinimalToolsSettings): PackageToolName[] {
+	const capabilities = computeToolCapabilities(model, settings);
+	return PACKAGE_TOOL_NAMES.filter((name) => capabilities[name].enabled);
+}
+
+export interface ActiveToolSyncResult {
+	activeTools: string[];
+	added: string[];
+	removed: string[];
+	preserved: string[];
+}
+
+export function computeNextActiveTools(currentActive: readonly string[], model: ModelLike | undefined, settings: CodexMinimalToolsSettings): ActiveToolSyncResult {
+	const current = new Set(currentActive);
+	const desired = new Set(desiredPackageTools(model, settings));
+	const added: string[] = [];
+	const removed: string[] = [];
+
+	for (const tool of PACKAGE_TOOL_NAMES) {
+		if (!desired.has(tool) && current.delete(tool)) removed.push(tool);
+	}
+
+	if (settings.enabled && settings.autoEnable) {
+		for (const tool of desired) {
+			if (!current.has(tool)) {
+				current.add(tool);
+				added.push(tool);
+			}
+		}
+	}
+
+	if (current.has("apply_patch")) {
+		for (const nativeMutationTool of NATIVE_MUTATION_TOOL_NAMES) {
+			if (current.delete(nativeMutationTool)) removed.push(nativeMutationTool);
+		}
+	}
+
+	const activeTools = currentActive.filter((name) => current.has(name));
+	for (const name of current) if (!activeTools.includes(name)) activeTools.push(name);
+	return {
+		activeTools,
+		added,
+		removed,
+		preserved: currentActive.filter((name) => !PACKAGE_TOOL_NAMES.includes(name as PackageToolName) && activeTools.includes(name)),
+	};
+}

package/src/codex-http.ts

@@ -0,0 +1,133 @@
+import type { ProviderHeaders } from "@earendil-works/pi-ai";
+import {
+	isProviderHeaderSuppressed,
+	mergeProviderHeaders,
+	providerHeaderDirective,
+	setProviderDefaultHeader,
+	setProviderGeneratedHeader,
+} from "./provider-headers.js";
+
+const DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api";
+const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
+const JWT_CLAIM_PATH = "https://api.openai.com/auth";
+
+export interface CodexRequestAuth {
+	apiKey?: string;
+	headers?: ProviderHeaders;
+}
+
+function bearerToken(headers: Headers): string | undefined {
+	const authorization = headers.get("authorization");
+	const match = authorization ? /^Bearer\s+(.+)$/i.exec(authorization.trim()) : null;
+	return match?.[1]?.trim() || undefined;
+}
+
+function authHeaders(options: {
+	modelHeaders?: ProviderHeaders;
+	auth: CodexRequestAuth;
+}): Headers {
+	return mergeProviderHeaders(options.modelHeaders, options.auth.headers);
+}
+
+export function hasCodexRequestAuth(options: {
+	modelHeaders?: ProviderHeaders;
+	auth: CodexRequestAuth;
+}): boolean {
+	const headers = authHeaders(options);
+	if (
+		options.auth.apiKey
+		&& providerHeaderDirective(options.auth.headers, "authorization") === undefined
+		&& !isProviderHeaderSuppressed(headers, "authorization")
+	) {
+		return true;
+	}
+	return ["authorization", "api-key", "x-api-key", "x-openai-actor-authorization"]
+		.some((name) => Boolean(headers.get(name)?.trim()));
+}
+
+export function resolveCodexRequestAccountId(options: {
+	modelHeaders?: ProviderHeaders;
+	auth: CodexRequestAuth;
+	apiKeyMode: boolean;
+}): string | undefined {
+	if (options.apiKeyMode) return undefined;
+	const headers = authHeaders(options);
+	if (
+		headers.get("chatgpt-account-id")?.trim()
+		|| headers.get("x-openai-actor-authorization")?.trim()
+		|| isProviderHeaderSuppressed(headers, "chatgpt-account-id")
+	) {
+		return undefined;
+	}
+	const requestAuthorization = providerHeaderDirective(options.auth.headers, "authorization");
+	const token = requestAuthorization !== undefined
+		? typeof requestAuthorization === "string" && requestAuthorization.trim()
+			? bearerToken(new Headers({ authorization: requestAuthorization }))
+			: undefined
+		: isProviderHeaderSuppressed(headers, "authorization")
+			? undefined
+			: options.auth.apiKey ?? bearerToken(headers);
+	return token ? extractCodexAccountId(token) : undefined;
+}
+
+function responseEndpoint(baseUrl: string | undefined, apiKeyMode: boolean): string {
+	const raw = baseUrl?.trim() || (apiKeyMode ? DEFAULT_OPENAI_BASE_URL : DEFAULT_CODEX_BASE_URL);
+	const normalized = raw.replace(/\/+$/, "");
+	if (apiKeyMode) {
+		if (normalized.endsWith("/responses")) return normalized;
+		return `${normalized}/responses`;
+	}
+	if (normalized.endsWith("/codex/responses")) return normalized;
+	if (normalized.endsWith("/codex")) return `${normalized}/responses`;
+	return `${normalized}/codex/responses`;
+}
+
+export function resolveCodexApiEndpoint(
+	baseUrl: string | undefined,
+	apiKeyMode: boolean,
+	path: string,
+): string {
+	const root = responseEndpoint(baseUrl, apiKeyMode).replace(/\/responses$/, "");
+	return `${root}/${path.replace(/^\/+/, "")}`;
+}
+
+export function extractCodexAccountId(token: string): string {
+	try {
+		const parts = token.split(".");
+		if (parts.length !== 3) throw new Error("Invalid token");
+		const payload = JSON.parse(Buffer.from(parts[1] ?? "", "base64").toString("utf8"));
+		const accountId = payload?.[JWT_CLAIM_PATH]?.chatgpt_account_id;
+		if (typeof accountId !== "string" || !accountId) throw new Error("No account ID in token");
+		return accountId;
+	} catch {
+		throw new Error("Failed to extract accountId from Codex OAuth token");
+	}
+}
+
+export function buildCodexJsonHeaders(options: {
+	modelHeaders?: ProviderHeaders;
+	auth: CodexRequestAuth;
+	apiKeyMode: boolean;
+	extraHeaders?: Record<string, string>;
+}): Headers {
+	const headers = authHeaders(options);
+	for (const [name, value] of Object.entries(options.extraHeaders ?? {})) {
+		setProviderGeneratedHeader(headers, name, value);
+	}
+	const requestAuthorization = providerHeaderDirective(options.auth.headers, "authorization");
+	if (requestAuthorization === undefined && options.auth.apiKey) {
+		setProviderGeneratedHeader(headers, "Authorization", `Bearer ${options.auth.apiKey}`);
+	}
+	if (
+		!options.apiKeyMode
+		&& !headers.has("chatgpt-account-id")
+		&& !headers.has("x-openai-actor-authorization")
+	) {
+		const accountId = resolveCodexRequestAccountId(options);
+		if (accountId) setProviderDefaultHeader(headers, "chatgpt-account-id", accountId);
+	}
+	setProviderDefaultHeader(headers, "originator", "pi");
+	setProviderDefaultHeader(headers, "accept", "application/json");
+	setProviderDefaultHeader(headers, "content-type", "application/json");
+	return headers;
+}

package/src/codex-identity-extension.ts

@@ -0,0 +1,341 @@
+import { claimSessionFeature } from "./session-claims.js";
+import {
+	SessionManager,
+	type ExtensionAPI,
+	type InlineExtension,
+	type SessionEntry,
+} from "@earendil-works/pi-coding-agent";
+import {
+	advanceCodexWindow,
+	beginCodexTurn,
+	codexThreadIdentityFor,
+	createCodexChildIdentity,
+	createCodexRootIdentity,
+	endCodexTurn,
+	parseCodexThreadIdentity,
+	registerCodexThreadIdentity,
+	type CodexThreadIdentity,
+} from "./codex-wire-identity.js";
+
+export const CODEX_IDENTITY_CUSTOM_TYPE = "pi-codex/thread-identity";
+const SUBAGENT_DESCRIPTOR_CUSTOM_TYPE = "pi-subagent/descriptor";
+const SUBAGENT_LINEAGE_CUSTOM_TYPE = "pi-subagent/lineage";
+const IDENTITY_LIFECYCLE_SYMBOL = Symbol.for(
+	"@oai404iao/pi-codex/identity-lifecycle/v1",
+);
+
+export interface CodexIdentitySessionView {
+	getSessionId(): string;
+	getSessionFile(): string | undefined;
+	getSessionDir(): string;
+	getCwd(): string;
+	getEntries(): SessionEntry[];
+	getBranch?(): SessionEntry[];
+	appendCustomEntry?(customType: string, data?: unknown): string;
+}
+
+interface SubagentLineage {
+	agentId: string;
+	parentAgentId: string;
+	parentPiSessionId: string;
+	parentSessionFile?: string;
+	relation: "spawn" | "fork";
+	agentName?: string;
+}
+
+function record(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object" && !Array.isArray(value)
+		? value as Record<string, unknown>
+		: undefined;
+}
+
+function readIdentity(
+	entries: readonly SessionEntry[],
+	piSessionId?: string,
+): CodexThreadIdentity | undefined {
+	for (let index = entries.length - 1; index >= 0; index--) {
+		const entry = entries[index];
+		if (
+			entry?.type !== "custom"
+			|| entry.customType !== CODEX_IDENTITY_CUSTOM_TYPE
+		) {
+			continue;
+		}
+		try {
+			const identity = parseCodexThreadIdentity(entry.data);
+			if (!piSessionId || identity.piSessionId === piSessionId) {
+				return identity;
+			}
+		} catch {
+			// A newer valid entry can repair a corrupt historical checkpoint.
+		}
+	}
+	return undefined;
+}
+
+function readSubagentLineage(
+	entries: readonly SessionEntry[],
+): SubagentLineage | undefined {
+	for (let index = entries.length - 1; index >= 0; index--) {
+		const entry = entries[index];
+		if (
+			entry?.type === "custom"
+			&& entry.customType === SUBAGENT_LINEAGE_CUSTOM_TYPE
+		) {
+			const lineage = record(entry.data);
+			if (
+				lineage?.version !== 1
+				|| lineage.openAIIdentity !== true
+				|| (lineage.relation !== "spawn" && lineage.relation !== "fork")
+				|| typeof lineage.agentId !== "string"
+				|| typeof lineage.parentAgentId !== "string"
+				|| typeof lineage.parentPiSessionId !== "string"
+			) {
+				return undefined;
+			}
+			return {
+				agentId: lineage.agentId,
+				parentAgentId: lineage.parentAgentId,
+				parentPiSessionId: lineage.parentPiSessionId,
+				relation: lineage.relation,
+				...(typeof lineage.parentSessionFile === "string"
+					? { parentSessionFile: lineage.parentSessionFile }
+					: {}),
+				...(typeof lineage.agentName === "string"
+					? { agentName: lineage.agentName }
+					: {}),
+			};
+		}
+		if (
+			entry?.type !== "custom"
+			|| entry.customType !== SUBAGENT_DESCRIPTOR_CUSTOM_TYPE
+		) {
+			continue;
+		}
+		const descriptor = record(entry.data);
+		const runtime = record(descriptor?.runtime);
+		if (
+			descriptor?.version !== 2
+			|| runtime?.openAIIdentity !== true
+			|| (descriptor.provider !== "spawn" && descriptor.provider !== "fork")
+			|| typeof descriptor.agentId !== "string"
+			|| typeof descriptor.parentAgentId !== "string"
+			|| typeof descriptor.parentPiSessionId !== "string"
+		) {
+			return undefined;
+		}
+		const agent = record(descriptor.agent);
+		return {
+			agentId: descriptor.agentId,
+			parentAgentId: descriptor.parentAgentId,
+			parentPiSessionId: descriptor.parentPiSessionId,
+			relation: descriptor.provider,
+			...(typeof descriptor.parentSessionFile === "string"
+				? { parentSessionFile: descriptor.parentSessionFile }
+				: {}),
+			...(typeof agent?.name === "string" ? { agentName: agent.name } : {}),
+		};
+	}
+	return undefined;
+}
+
+function appendIdentity(
+	session: CodexIdentitySessionView,
+	identity: CodexThreadIdentity,
+	appendCurrent?: (identity: CodexThreadIdentity) => void,
+): void {
+	if (appendCurrent) {
+		appendCurrent(identity);
+		return;
+	}
+	session.appendCustomEntry?.(
+		CODEX_IDENTITY_CUSTOM_TYPE,
+		structuredClone(identity),
+	);
+}
+
+function openParentSession(
+	session: CodexIdentitySessionView,
+	lineage: SubagentLineage,
+): CodexIdentitySessionView | undefined {
+	if (!lineage.parentSessionFile) return undefined;
+	try {
+		return SessionManager.open(
+			lineage.parentSessionFile,
+			session.getSessionDir(),
+			session.getCwd(),
+		);
+	} catch {
+		return undefined;
+	}
+}
+
+function resolveParentIdentity(
+	session: CodexIdentitySessionView,
+	lineage: SubagentLineage,
+): CodexThreadIdentity {
+	const active = codexThreadIdentityFor(lineage.parentPiSessionId);
+	if (active) return active;
+
+	const parent = openParentSession(session, lineage);
+	if (parent) {
+		const persisted = readIdentity(
+			parent.getEntries(),
+			lineage.parentPiSessionId,
+		);
+		if (persisted) return registerCodexThreadIdentity(persisted);
+
+		// pi-codex-minimal-tools owns the Codex identity even when the parent
+		// happened to use a non-Codex model before creating this OpenAI child.
+		const root = createCodexRootIdentity(lineage.parentPiSessionId);
+		appendIdentity(parent, root);
+		return registerCodexThreadIdentity(root);
+	}
+
+	// Ephemeral parents have no file to reopen. They are still represented by a
+	// process-local root identity for the lifetime of the child tree.
+	const root = createCodexRootIdentity(lineage.parentPiSessionId);
+	return registerCodexThreadIdentity(root);
+}
+
+export function ensureCodexSessionIdentity(
+	session: CodexIdentitySessionView,
+	options: {
+		sessionStartReason?: string;
+		appendCurrent?: (identity: CodexThreadIdentity) => void;
+	} = {},
+): CodexThreadIdentity {
+	const piSessionId = session.getSessionId();
+	const persisted = readIdentity(session.getEntries(), piSessionId);
+	if (persisted) return registerCodexThreadIdentity(persisted);
+
+	const lineage = readSubagentLineage(session.getEntries());
+	let identity: CodexThreadIdentity;
+	if (lineage) {
+		identity = createCodexChildIdentity(
+			piSessionId,
+			resolveParentIdentity(session, lineage),
+			{
+				relation: lineage.relation,
+				agentName: lineage.agentName,
+			},
+		);
+	} else {
+		const copied = readIdentity(session.getEntries());
+		identity = createCodexRootIdentity(piSessionId, {
+			...(options.sessionStartReason === "fork" && copied
+				? { forkedFromThreadId: copied.threadId }
+				: {}),
+		});
+	}
+
+	appendIdentity(session, identity, options.appendCurrent);
+	return registerCodexThreadIdentity(identity);
+}
+
+/**
+ * Install only the session/turn/window lifecycle needed by the Codex provider.
+ * It deliberately does not register providers, tools, commands, or renderers.
+ */
+export function installCodexIdentityLifecycle(pi: ExtensionAPI): void {
+	const guard = pi as unknown as Record<PropertyKey, unknown>;
+	if (guard[IDENTITY_LIFECYCLE_SYMBOL]) return;
+	if (!claimSessionFeature(pi, "wire-identity")) return;
+	guard[IDENTITY_LIFECYCLE_SYMBOL] = true;
+
+	const ensure = (
+		ctx: {
+			sessionManager?: Partial<CodexIdentitySessionView>;
+		},
+		sessionStartReason?: string,
+	): CodexThreadIdentity | undefined => {
+		const session = ctx.sessionManager;
+		if (!session || typeof session.getSessionId !== "function") {
+			return undefined;
+		}
+		const piSessionId = session.getSessionId();
+		if (typeof session.getEntries !== "function") {
+			const existing = codexThreadIdentityFor(piSessionId);
+			if (existing) return existing;
+			return registerCodexThreadIdentity(
+				createCodexRootIdentity(piSessionId),
+			);
+		}
+		return ensureCodexSessionIdentity(session as CodexIdentitySessionView, {
+			sessionStartReason,
+			appendCurrent: (identity) => {
+				pi.appendEntry(
+					CODEX_IDENTITY_CUSTOM_TYPE,
+					structuredClone(identity),
+				);
+			},
+		});
+	};
+
+	pi.on("session_start", async (event, ctx) => {
+		ensure(ctx as unknown as { sessionManager: CodexIdentitySessionView }, event.reason);
+	});
+
+	pi.on("before_agent_start", async (_event, ctx) => {
+		const typed = ctx as unknown as { sessionManager: CodexIdentitySessionView };
+		const identity = ensure(typed);
+		if (!identity) return;
+		const lineage =
+			typeof typed.sessionManager.getEntries === "function"
+				? readSubagentLineage(typed.sessionManager.getEntries())
+				: undefined;
+		beginCodexTurn(identity.piSessionId, {
+			...(lineage?.parentPiSessionId
+				? { parentPiSessionId: lineage.parentPiSessionId }
+				: {}),
+		});
+	});
+
+	pi.on("agent_settled", async (_event, ctx) => {
+		const piSessionId = ctx.sessionManager?.getSessionId?.();
+		if (piSessionId) endCodexTurn(piSessionId);
+	});
+
+	pi.on("session_compact", async (event, ctx) => {
+		const typed = ctx as unknown as { sessionManager: CodexIdentitySessionView };
+		if (!ensure(typed)) return;
+		const identity = advanceCodexWindow(
+			typed.sessionManager.getSessionId(),
+			event.compactionEntry.id,
+		);
+		pi.appendEntry(
+			CODEX_IDENTITY_CUSTOM_TYPE,
+			structuredClone(identity),
+		);
+	});
+
+	pi.on("session_tree", async (_event, ctx) => {
+		const typed = ctx as unknown as { sessionManager: CodexIdentitySessionView };
+		const piSessionId = typed.sessionManager.getSessionId();
+		const branch = typed.sessionManager.getBranch?.()
+			?? typed.sessionManager.getEntries();
+		const identity = readIdentity(branch, piSessionId)
+			?? readIdentity(typed.sessionManager.getEntries(), piSessionId);
+		if (identity) registerCodexThreadIdentity(identity);
+	});
+
+	pi.on("session_shutdown", async (_event, ctx) => {
+		const piSessionId = ctx.sessionManager?.getSessionId?.();
+		if (piSessionId) endCodexTurn(piSessionId);
+	});
+}
+
+/** Named inline extension used by pi-subagent when normal inheritance is off. */
+export function createCodexSubagentInlineExtension(
+	options: { parentSessionManager?: CodexIdentitySessionView } = {},
+): InlineExtension {
+	if (options.parentSessionManager) {
+		ensureCodexSessionIdentity(options.parentSessionManager);
+	}
+	return {
+		name: "pi-codex-subagent-identity",
+		factory: (pi) => {
+			installCodexIdentityLifecycle(pi);
+		},
+	};
+}

package/src/codex-request-profile.ts

@@ -0,0 +1,45 @@
+import type { ReasoningSummary } from "./model-catalog/types.js";
+
+export interface CodexRequestProfile {
+	responsesMode: "standard" | "lite";
+	reasoningSummary: ReasoningSummary;
+	systemPromptPlacement: "instructions" | "developer";
+	patchTransport: "function" | "custom";
+	supportsHostedTools: boolean;
+	supportsParallelTools: boolean;
+}
+
+/**
+ * Only modes implemented by the current provider shim are configurable.
+ * Custom transport remains unavailable until its complete wire parser lands.
+ */
+export interface CodexRequestProfileOverride {
+	responsesMode?: "standard" | "lite";
+	reasoningSummary?: ReasoningSummary;
+	systemPromptPlacement?: "instructions" | "developer";
+	patchTransport?: "function" | "custom";
+	supportsHostedTools?: boolean;
+	supportsParallelTools?: boolean;
+}
+
+export const DEFAULT_CODEX_REQUEST_PROFILE: CodexRequestProfile = {
+	responsesMode: "standard",
+	reasoningSummary: "auto",
+	systemPromptPlacement: "instructions",
+	patchTransport: "function",
+	supportsHostedTools: true,
+	supportsParallelTools: true,
+};
+
+export function resolveCodexRequestProfile(override: CodexRequestProfileOverride = {}): CodexRequestProfile {
+	const responsesMode = override.responsesMode ?? DEFAULT_CODEX_REQUEST_PROFILE.responsesMode;
+	return {
+		responsesMode,
+		reasoningSummary: override.reasoningSummary
+			?? (responsesMode === "lite" ? "none" : DEFAULT_CODEX_REQUEST_PROFILE.reasoningSummary),
+		systemPromptPlacement: responsesMode === "lite" ? "developer" : override.systemPromptPlacement ?? DEFAULT_CODEX_REQUEST_PROFILE.systemPromptPlacement,
+		patchTransport: override.patchTransport ?? DEFAULT_CODEX_REQUEST_PROFILE.patchTransport,
+		supportsHostedTools: responsesMode === "lite" ? false : override.supportsHostedTools ?? DEFAULT_CODEX_REQUEST_PROFILE.supportsHostedTools,
+		supportsParallelTools: responsesMode === "lite" ? false : override.supportsParallelTools ?? DEFAULT_CODEX_REQUEST_PROFILE.supportsParallelTools,
+	};
+}

package/src/codex-reserved-tools.ts

@@ -0,0 +1,33 @@
+/*
+ * SPDX-FileCopyrightText: 2025 OpenAI
+ * SPDX-FileCopyrightText: 2026 oai404iao
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Modified TypeScript compatibility serialization derived from the namespace
+ * tool construction in OpenAI Codex at revision
+ * eb9dceba1a2e658142a456c5898836774835616b.
+ *
+ * This preserves the reviewed `web.run` and `image_gen.imagegen` declaration
+ * shapes for this package's internal Responses Lite compatibility path. It is
+ * not an OpenAI-supported public API contract. Immutable upstream blob IDs,
+ * source hashes, and local compatibility fingerprints are recorded in
+ * provenance/openai-codex-eb9dceba-reserved-tools.json.
+ *
+ * See THIRD_PARTY_NOTICES.md and LICENSES/Apache-2.0.txt.
+ */
+
+import { WEB_SEARCH_NAMESPACE } from "./reserved-tools/web-search.js";
+import { IMAGE_GENERATION_NAMESPACE } from "./reserved-tools/image-generation.js";
+import type { CodexReservedToolName, CodexReservedNamespaceTool } from "./reserved-tools/types.js";
+export type { CodexReservedToolName, CodexReservedNamespaceTool } from "./reserved-tools/types.js";
+
+const CODEX_RESERVED_NAMESPACE_TOOLS: Record<CodexReservedToolName, CodexReservedNamespaceTool> = {
+	web_search: WEB_SEARCH_NAMESPACE,
+	image_generation: IMAGE_GENERATION_NAMESPACE,
+};
+
+export function createCodexReservedNamespaceTool(
+	name: CodexReservedToolName,
+): CodexReservedNamespaceTool {
+	return structuredClone(CODEX_RESERVED_NAMESPACE_TOOLS[name]);
+}