@oh-my-pi/pi-ai 3.20.0 → 3.34.0

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

@@ -0,0 +1,7 @@
+/**
+ * OpenAI Codex utilities - exported for use by coding-agent export
+ */
+
+export { type CacheMetadata, getCodexInstructions, getModelFamily, type ModelFamily } from "./prompts/codex";
+export { buildCodexPiBridge } from "./prompts/pi-codex-bridge";
+export { buildCodexSystemPrompt, type CodexSystemPrompt } from "./prompts/system-prompt";

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

@@ -1,6 +1,8 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+
+// Bun text embed for fallback instructions
 import FALLBACK_INSTRUCTIONS from "./codex-instructions.md" with { type: "text" };
 
 const GITHUB_API_RELEASES = "https://api.github.com/repos/openai/codex/releases/latest";
@@ -41,17 +43,17 @@ export type CacheMetadata = {
 	url: string;
 };
 
-export function getModelFamily(normalizedModel: string): ModelFamily {
-	if (normalizedModel.includes("gpt-5.2-codex") || normalizedModel.includes("gpt 5.2 codex")) {
+export function getModelFamily(model: string): ModelFamily {
+	if (model.includes("gpt-5.2-codex") || model.includes("gpt 5.2 codex")) {
 		return "gpt-5.2-codex";
 	}
-	if (normalizedModel.includes("codex-max")) {
+	if (model.includes("codex-max")) {
 		return "codex-max";
 	}
-	if (normalizedModel.includes("codex") || normalizedModel.startsWith("codex-")) {
+	if (model.includes("codex") || model.startsWith("codex-")) {
 		return "codex";
 	}
-	if (normalizedModel.includes("gpt-5.2")) {
+	if (model.includes("gpt-5.2")) {
 		return "gpt-5.2";
 	}
 	return "gpt-5.1";
@@ -93,8 +95,8 @@ async function getLatestReleaseTag(): Promise<string> {
 	throw new Error("Failed to determine latest release tag from GitHub");
 }
 
-export async function getCodexInstructions(normalizedModel = "gpt-5.1-codex"): Promise<string> {
-	const modelFamily = getModelFamily(normalizedModel);
+export async function getCodexInstructions(model = "gpt-5.1-codex"): Promise<string> {
+	const modelFamily = getModelFamily(model);
 	const promptFile = PROMPT_FILES[modelFamily];
 	const cacheDir = getCacheDir();
 	const cacheFile = join(cacheDir, CACHE_FILES[modelFamily]);
@@ -106,15 +108,15 @@ export async function getCodexInstructions(normalizedModel = "gpt-5.1-codex"): P
 		let cachedTimestamp: number | null = null;
 
 		if (existsSync(cacheMetaFile)) {
-			const metadata = JSON.parse(readFileSync(cacheMetaFile, "utf-8")) as CacheMetadata;
+			const metadata = JSON.parse(readFileSync(cacheMetaFile, "utf8")) as CacheMetadata;
 			cachedETag = metadata.etag;
 			cachedTag = metadata.tag;
 			cachedTimestamp = metadata.lastChecked;
 		}
 
-		const CACHE_TTL_MS = 15 * 60 * 1000;
+		const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
 		if (cachedTimestamp && Date.now() - cachedTimestamp < CACHE_TTL_MS && existsSync(cacheFile)) {
-			return readFileSync(cacheFile, "utf-8");
+			return readFileSync(cacheFile, "utf8");
 		}
 
 		const latestTag = await getLatestReleaseTag();
@@ -133,7 +135,7 @@ export async function getCodexInstructions(normalizedModel = "gpt-5.1-codex"): P
 
 		if (response.status === 304) {
 			if (existsSync(cacheFile)) {
-				return readFileSync(cacheFile, "utf-8");
+				return readFileSync(cacheFile, "utf8");
 			}
 		}
 
@@ -141,8 +143,11 @@ export async function getCodexInstructions(normalizedModel = "gpt-5.1-codex"): P
 			const instructions = await response.text();
 			const newETag = response.headers.get("etag");
 
-			mkdirSync(cacheDir, { recursive: true });
-			writeFileSync(cacheFile, instructions, "utf-8");
+			if (!existsSync(cacheDir)) {
+				mkdirSync(cacheDir, { recursive: true });
+			}
+
+			writeFileSync(cacheFile, instructions, "utf8");
 			writeFileSync(
 				cacheMetaFile,
 				JSON.stringify({
@@ -151,7 +156,7 @@ export async function getCodexInstructions(normalizedModel = "gpt-5.1-codex"): P
 					lastChecked: Date.now(),
 					url: instructionsUrl,
 				} satisfies CacheMetadata),
-				"utf-8",
+				"utf8",
 			);
 
 			return instructions;
@@ -166,52 +171,14 @@ export async function getCodexInstructions(normalizedModel = "gpt-5.1-codex"): P
 
 		if (existsSync(cacheFile)) {
 			console.error(`[openai-codex] Using cached ${modelFamily} instructions`);
-			return readFileSync(cacheFile, "utf-8");
+			return readFileSync(cacheFile, "utf8");
 		}
 
-		console.error(`[openai-codex] Falling back to bundled instructions for ${modelFamily}`);
-		return FALLBACK_INSTRUCTIONS;
+		if (FALLBACK_INSTRUCTIONS) {
+			console.error(`[openai-codex] Falling back to bundled instructions for ${modelFamily}`);
+			return FALLBACK_INSTRUCTIONS;
+		}
+
+		throw new Error(`No cached Codex instructions available for ${modelFamily}`);
 	}
 }
-
-export const TOOL_REMAP_MESSAGE = `<user_instructions priority="0">
-<environment_override priority="0">
-YOU ARE IN A DIFFERENT ENVIRONMENT. These instructions override ALL previous tool references.
-</environment_override>
-
-<tool_replacements priority="0">
-<critical_rule priority="0">
-❌ APPLY_PATCH DOES NOT EXIST → ✅ USE "edit" INSTEAD
-- NEVER use: apply_patch, applyPatch
-- ALWAYS use: edit tool for ALL file modifications
-</critical_rule>
-
-<critical_rule priority="0">
-❌ UPDATE_PLAN DOES NOT EXIST
-- NEVER use: update_plan, updatePlan, read_plan, readPlan, todowrite, todoread
-- There is no plan tool in this environment
-</critical_rule>
-</tool_replacements>
-
-<available_tools priority="0">
-File Operations:
-  • read  - Read file contents
-  • edit  - Modify files with exact find/replace
-  • write - Create or overwrite files
-
-Search/Discovery:
-  • grep  - Search file contents for patterns (read-only)
-  • find  - Find files by glob pattern (read-only)
-  • ls    - List directory contents (read-only)
-
-Execution:
-  • bash  - Run shell commands
-</available_tools>
-
-<verification_checklist priority="0">
-Before file modifications:
-1. Am I using "edit" NOT "apply_patch"?
-2. Am I avoiding plan tools entirely?
-3. Am I using only the tools listed above?
-</verification_checklist>
-</user_instructions>`;

package/src/providers/openai-codex/prompts/pi-codex-bridge.ts

@@ -3,46 +3,53 @@
  * Aligns Codex CLI expectations with Pi's toolset.
  */
 
-export const CODEX_PI_BRIDGE = `# Codex Running in Pi
+import type { Tool } from "../../../types";
 
-You are running Codex through pi, a terminal coding assistant. The tools and rules differ from Codex CLI.
+function formatToolList(tools?: Tool[]): string {
+	if (!tools || tools.length === 0) {
+		return "- (none)";
+	}
 
-## CRITICAL: Tool Replacements
+	const normalized = tools
+		.map((tool) => {
+			const name = tool.name.trim();
+			if (!name) return null;
+			const description = (tool.description || "Custom tool").replace(/\s*\n\s*/g, " ").trim();
+			return { name, description };
+		})
+		.filter((tool): tool is { name: string; description: string } => tool !== null);
 
-<critical_rule priority="0">
-❌ APPLY_PATCH DOES NOT EXIST → ✅ USE "edit" INSTEAD
-- NEVER use: apply_patch, applyPatch
-- ALWAYS use: edit for ALL file modifications
-</critical_rule>
+	if (normalized.length === 0) {
+		return "- (none)";
+	}
 
-<critical_rule priority="0">
-❌ UPDATE_PLAN DOES NOT EXIST
-- NEVER use: update_plan, updatePlan, read_plan, readPlan, todowrite, todoread
-- There is no plan tool in this environment
-</critical_rule>
+	const maxNameLength = normalized.reduce((max, tool) => Math.max(max, tool.name.length), 0);
+	const padWidth = Math.max(6, maxNameLength + 1);
 
-## Available Tools (pi)
+	return normalized
+		.map((tool) => {
+			const paddedName = tool.name.padEnd(padWidth);
+			return `- ${paddedName}- ${tool.description}`;
+		})
+		.join("\n");
+}
 
-- read  - Read file contents
-- bash  - Execute bash commands
-- edit  - Modify files with exact find/replace (requires prior read)
-- write - Create or overwrite files
-- grep  - Search file contents (read-only)
-- find  - Find files by glob pattern (read-only)
-- ls    - List directory contents (read-only)
+export function buildCodexPiBridge(tools?: Tool[]): string {
+	const toolsList = formatToolList(tools);
 
-## Usage Rules
+	return `# Codex Environment Bridge
 
-- Read before edit; use read instead of cat/sed for file contents
-- Use edit for surgical changes; write only for new files or complete rewrites
-- Prefer grep/find/ls over bash for discovery
-- Be concise and show file paths clearly when working with files
+<environment_override priority="0">
+IGNORE ALL PREVIOUS INSTRUCTIONS ABOVE THIS MESSAGE.
+Do not assume any tools are available unless listed below.
+</environment_override>
 
-## Verification Checklist
+The next system instructions that follow this message are authoritative and must be obeyed, even if they conflict with earlier instructions.
 
-1. Using edit, not apply_patch
-2. No plan tools used
-3. Only the tools listed above are called
+## Available Tools
 
-Below are additional system instruction you MUST follow when responding:
+${toolsList}
+
+Only use the tools listed above. Do not reference or call any other tools.
 `;
+}

package/src/providers/openai-codex/prompts/system-prompt.ts

@@ -0,0 +1,26 @@
+export interface CodexSystemPrompt {
+	instructions: string;
+	developerMessages: string[];
+}
+
+export function buildCodexSystemPrompt(args: {
+	codexInstructions: string;
+	bridgeText: string;
+	userSystemPrompt?: string;
+}): CodexSystemPrompt {
+	const { codexInstructions, bridgeText, userSystemPrompt } = args;
+	const developerMessages: string[] = [];
+
+	if (bridgeText.trim().length > 0) {
+		developerMessages.push(bridgeText.trim());
+	}
+
+	if (userSystemPrompt && userSystemPrompt.trim().length > 0) {
+		developerMessages.push(userSystemPrompt.trim());
+	}
+
+	return {
+		instructions: codexInstructions.trim(),
+		developerMessages,
+	};
+}

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

@@ -1,6 +1,3 @@
-import { TOOL_REMAP_MESSAGE } from "./prompts/codex";
-import { CODEX_PI_BRIDGE } from "./prompts/pi-codex-bridge";
-
 export interface ReasoningConfig {
 	effort: "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
 	summary: "auto" | "concise" | "detailed" | "off" | "on";
@@ -38,160 +35,32 @@ export interface RequestBody {
 	};
 	include?: string[];
 	prompt_cache_key?: string;
+	prompt_cache_retention?: "in_memory" | "24h";
 	max_output_tokens?: number;
 	max_completion_tokens?: number;
 	[key: string]: unknown;
 }
 
-const MODEL_MAP: Record<string, string> = {
-	"gpt-5.1-codex": "gpt-5.1-codex",
-	"gpt-5.1-codex-low": "gpt-5.1-codex",
-	"gpt-5.1-codex-medium": "gpt-5.1-codex",
-	"gpt-5.1-codex-high": "gpt-5.1-codex",
-	"gpt-5.1-codex-max": "gpt-5.1-codex-max",
-	"gpt-5.1-codex-max-low": "gpt-5.1-codex-max",
-	"gpt-5.1-codex-max-medium": "gpt-5.1-codex-max",
-	"gpt-5.1-codex-max-high": "gpt-5.1-codex-max",
-	"gpt-5.1-codex-max-xhigh": "gpt-5.1-codex-max",
-	"gpt-5.2": "gpt-5.2",
-	"gpt-5.2-none": "gpt-5.2",
-	"gpt-5.2-low": "gpt-5.2",
-	"gpt-5.2-medium": "gpt-5.2",
-	"gpt-5.2-high": "gpt-5.2",
-	"gpt-5.2-xhigh": "gpt-5.2",
-	"gpt-5.2-codex": "gpt-5.2-codex",
-	"gpt-5.2-codex-low": "gpt-5.2-codex",
-	"gpt-5.2-codex-medium": "gpt-5.2-codex",
-	"gpt-5.2-codex-high": "gpt-5.2-codex",
-	"gpt-5.2-codex-xhigh": "gpt-5.2-codex",
-	"gpt-5.1-codex-mini": "gpt-5.1-codex-mini",
-	"gpt-5.1-codex-mini-medium": "gpt-5.1-codex-mini",
-	"gpt-5.1-codex-mini-high": "gpt-5.1-codex-mini",
-	"gpt-5.1": "gpt-5.1",
-	"gpt-5.1-none": "gpt-5.1",
-	"gpt-5.1-low": "gpt-5.1",
-	"gpt-5.1-medium": "gpt-5.1",
-	"gpt-5.1-high": "gpt-5.1",
-	"gpt-5.1-chat-latest": "gpt-5.1",
-	"gpt-5-codex": "gpt-5.1-codex",
-	"codex-mini-latest": "gpt-5.1-codex-mini",
-	"gpt-5-codex-mini": "gpt-5.1-codex-mini",
-	"gpt-5-codex-mini-medium": "gpt-5.1-codex-mini",
-	"gpt-5-codex-mini-high": "gpt-5.1-codex-mini",
-	"gpt-5": "gpt-5.1",
-	"gpt-5-mini": "gpt-5.1",
-	"gpt-5-nano": "gpt-5.1",
-};
-
-function getNormalizedModel(modelId: string): string | undefined {
-	if (MODEL_MAP[modelId]) return MODEL_MAP[modelId];
-	const lowerModelId = modelId.toLowerCase();
-	const match = Object.keys(MODEL_MAP).find((key) => key.toLowerCase() === lowerModelId);
-	return match ? MODEL_MAP[match] : undefined;
-}
-
-export function normalizeModel(model: string | undefined): string {
-	if (!model) return "gpt-5.1";
-
+function clampReasoningEffort(model: string, effort: ReasoningConfig["effort"]): ReasoningConfig["effort"] {
+	// Codex backend expects exact model IDs. Do not normalize model names here.
 	const modelId = model.includes("/") ? model.split("/").pop()! : model;
-	const mappedModel = getNormalizedModel(modelId);
-	if (mappedModel) return mappedModel;
-
-	const normalized = modelId.toLowerCase();
-
-	if (normalized.includes("gpt-5.2-codex") || normalized.includes("gpt 5.2 codex")) {
-		return "gpt-5.2-codex";
-	}
-	if (normalized.includes("gpt-5.2") || normalized.includes("gpt 5.2")) {
-		return "gpt-5.2";
-	}
-	if (normalized.includes("gpt-5.1-codex-max") || normalized.includes("gpt 5.1 codex max")) {
-		return "gpt-5.1-codex-max";
-	}
-	if (normalized.includes("gpt-5.1-codex-mini") || normalized.includes("gpt 5.1 codex mini")) {
-		return "gpt-5.1-codex-mini";
-	}
-	if (
-		normalized.includes("codex-mini-latest") ||
-		normalized.includes("gpt-5-codex-mini") ||
-		normalized.includes("gpt 5 codex mini")
-	) {
-		return "codex-mini-latest";
-	}
-	if (normalized.includes("gpt-5.1-codex") || normalized.includes("gpt 5.1 codex")) {
-		return "gpt-5.1-codex";
-	}
-	if (normalized.includes("gpt-5.1") || normalized.includes("gpt 5.1")) {
-		return "gpt-5.1";
-	}
-	if (normalized.includes("codex")) {
-		return "gpt-5.1-codex";
-	}
-	if (normalized.includes("gpt-5") || normalized.includes("gpt 5")) {
-		return "gpt-5.1";
-	}
-
-	return "gpt-5.1";
-}
-
-function getReasoningConfig(modelName: string | undefined, options: CodexRequestOptions = {}): ReasoningConfig {
-	const normalizedName = modelName?.toLowerCase() ?? "";
-
-	const isGpt52Codex = normalizedName.includes("gpt-5.2-codex") || normalizedName.includes("gpt 5.2 codex");
-	const isGpt52General = (normalizedName.includes("gpt-5.2") || normalizedName.includes("gpt 5.2")) && !isGpt52Codex;
-	const isCodexMax = normalizedName.includes("codex-max") || normalizedName.includes("codex max");
-	const isCodexMini =
-		normalizedName.includes("codex-mini") ||
-		normalizedName.includes("codex mini") ||
-		normalizedName.includes("codex_mini") ||
-		normalizedName.includes("codex-mini-latest");
-	const isCodex = normalizedName.includes("codex") && !isCodexMini;
-	const isLightweight = !isCodexMini && (normalizedName.includes("nano") || normalizedName.includes("mini"));
-	const isGpt51General =
-		(normalizedName.includes("gpt-5.1") || normalizedName.includes("gpt 5.1")) &&
-		!isCodex &&
-		!isCodexMax &&
-		!isCodexMini;
-
-	const supportsXhigh = isGpt52General || isGpt52Codex || isCodexMax;
-	const supportsNone = isGpt52General || isGpt51General;
-
-	const defaultEffort: ReasoningConfig["effort"] = isCodexMini
-		? "medium"
-		: supportsXhigh
-			? "high"
-			: isLightweight
-				? "minimal"
-				: "medium";
-
-	let effort = options.reasoningEffort || defaultEffort;
-
-	if (isCodexMini) {
-		if (effort === "minimal" || effort === "low" || effort === "none") {
-			effort = "medium";
-		}
-		if (effort === "xhigh") {
-			effort = "high";
-		}
-		if (effort !== "high" && effort !== "medium") {
-			effort = "medium";
-		}
-	}
 
-	if (!supportsXhigh && effort === "xhigh") {
-		effort = "high";
+	// gpt-5.1 does not support xhigh.
+	if (modelId === "gpt-5.1" && effort === "xhigh") {
+		return "high";
 	}
 
-	if (!supportsNone && effort === "none") {
-		effort = "low";
+	// gpt-5.1-codex-mini only supports medium/high.
+	if (modelId === "gpt-5.1-codex-mini") {
+		return effort === "high" || effort === "xhigh" ? "high" : "medium";
 	}
 
-	if (isCodex && effort === "minimal") {
-		effort = "low";
-	}
+	return effort;
+}
 
+function getReasoningConfig(model: string, options: CodexRequestOptions): ReasoningConfig {
 	return {
-		effort,
+		effort: clampReasoningEffort(model, options.reasoningEffort as ReasoningConfig["effort"]),
 		summary: options.reasoningSummary ?? "auto",
 	};
 }
@@ -210,69 +79,17 @@ function filterInput(input: InputItem[] | undefined): InputItem[] | undefined {
 		});
 }
 
-function addCodexBridgeMessage(
-	input: InputItem[] | undefined,
-	hasTools: boolean,
-	systemPrompt?: string,
-): InputItem[] | undefined {
-	if (!hasTools || !Array.isArray(input)) return input;
-
-	const bridgeText = systemPrompt ? `${CODEX_PI_BRIDGE}\n\n${systemPrompt}` : CODEX_PI_BRIDGE;
-
-	const bridgeMessage: InputItem = {
-		type: "message",
-		role: "developer",
-		content: [
-			{
-				type: "input_text",
-				text: bridgeText,
-			},
-		],
-	};
-
-	return [bridgeMessage, ...input];
-}
-
-function addToolRemapMessage(input: InputItem[] | undefined, hasTools: boolean): InputItem[] | undefined {
-	if (!hasTools || !Array.isArray(input)) return input;
-
-	const toolRemapMessage: InputItem = {
-		type: "message",
-		role: "developer",
-		content: [
-			{
-				type: "input_text",
-				text: TOOL_REMAP_MESSAGE,
-			},
-		],
-	};
-
-	return [toolRemapMessage, ...input];
-}
-
 export async function transformRequestBody(
 	body: RequestBody,
-	codexInstructions: string,
 	options: CodexRequestOptions = {},
-	codexMode = true,
-	systemPrompt?: string,
+	prompt?: { instructions: string; developerMessages: string[] },
 ): Promise<RequestBody> {
-	const normalizedModel = normalizeModel(body.model);
-
-	body.model = normalizedModel;
 	body.store = false;
 	body.stream = true;
-	body.instructions = codexInstructions;
 
 	if (body.input && Array.isArray(body.input)) {
 		body.input = filterInput(body.input);
 
-		if (codexMode) {
-			body.input = addCodexBridgeMessage(body.input, !!body.tools, systemPrompt);
-		} else {
-			body.input = addToolRemapMessage(body.input, !!body.tools);
-		}
-
 		if (body.input) {
 			const functionCallIds = new Set(
 				body.input
@@ -308,18 +125,36 @@ export async function transformRequestBody(
 		}
 	}
 
-	const reasoningConfig = getReasoningConfig(normalizedModel, options);
-	body.reasoning = {
-		...body.reasoning,
-		...reasoningConfig,
-	};
+	if (prompt?.developerMessages && prompt.developerMessages.length > 0 && Array.isArray(body.input)) {
+		const developerMessages = prompt.developerMessages.map(
+			(text) =>
+				({
+					type: "message",
+					role: "developer",
+					content: [{ type: "input_text", text }],
+				}) as InputItem,
+		);
+		body.input = [...developerMessages, ...body.input];
+	}
+
+	if (options.reasoningEffort !== undefined) {
+		const reasoningConfig = getReasoningConfig(body.model, options);
+		body.reasoning = {
+			...body.reasoning,
+			...reasoningConfig,
+		};
+	} else {
+		delete body.reasoning;
+	}
 
 	body.text = {
 		...body.text,
 		verbosity: options.textVerbosity || "medium",
 	};
 
-	body.include = options.include || ["reasoning.encrypted_content"];
+	const include = Array.isArray(options.include) ? [...options.include] : [];
+	include.push("reasoning.encrypted_content");
+	body.include = Array.from(new Set(include));
 
 	delete body.max_output_tokens;
 	delete body.max_completion_tokens;