@oai404iao/pi-codex-minimal-tools 1.4.0 → 2.0.0

package/src/capabilities.ts

@@ -1,146 +1 @@
-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)),
-	};
-}
+export * from "@oai404iao/pi-codex-runtime/internal/capabilities";

package/src/codex-http.ts

@@ -1,133 +1 @@
-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;
-}
+export * from "@oai404iao/pi-codex-runtime/internal/codex-http";

package/src/codex-identity-extension.ts

@@ -1,339 +1 @@
-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;
-	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);
-		},
-	};
-}
+export * from "@oai404iao/pi-codex-runtime/internal/codex-identity-extension";

package/src/codex-request-profile.ts

@@ -1,45 +1 @@
-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,
-	};
-}
+export * from "@oai404iao/pi-codex-runtime/internal/codex-request-profile";