@oh-my-pi/pi-ai 5.4.2 → 5.6.7

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-ai",
-	"version": "5.4.2",
+	"version": "5.6.7",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"type": "module",
 	"main": "./src/index.ts",

package/src/cli.ts

@@ -1,5 +1,5 @@
-#!/usr/bin/env node
-
+#!/usr/bin/env bun
+import "./utils/migrate-env";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { createInterface } from "readline";
 import { loginAnthropic } from "./utils/oauth/anthropic";

package/src/index.ts

@@ -1,3 +1,5 @@
+import "./utils/migrate-env";
+
 export * from "./models";
 export * from "./providers/anthropic";
 export * from "./providers/cursor";

package/src/models.generated.ts

@@ -1335,23 +1335,6 @@ export const MODELS = {
 			contextWindow: 131000,
 			maxTokens: 32000,
 		} satisfies Model<"openai-completions">,
-		"zai-glm-4.6": {
-			id: "zai-glm-4.6",
-			name: "Z.AI GLM-4.6",
-			api: "openai-completions",
-			provider: "cerebras",
-			baseUrl: "https://api.cerebras.ai/v1",
-			reasoning: false,
-			input: ["text"],
-			cost: {
-				input: 0,
-				output: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-			},
-			contextWindow: 131072,
-			maxTokens: 40960,
-		} satisfies Model<"openai-completions">,
 		"zai-glm-4.7": {
 			id: "zai-glm-4.7",
 			name: "Z.AI GLM-4.7",
@@ -1946,24 +1929,6 @@ export const MODELS = {
 			contextWindow: 128000,
 			maxTokens: 64000,
 		} satisfies Model<"openai-completions">,
-		"oswe-vscode-prime": {
-			id: "oswe-vscode-prime",
-			name: "Raptor Mini (Preview)",
-			api: "openai-responses",
-			provider: "github-copilot",
-			baseUrl: "https://api.individual.githubcopilot.com",
-			headers: {"User-Agent":"GitHubCopilotChat/0.35.0","Editor-Version":"vscode/1.107.0","Editor-Plugin-Version":"copilot-chat/0.35.0","Copilot-Integration-Id":"vscode-chat"},
-			reasoning: true,
-			input: ["text", "image"],
-			cost: {
-				input: 0,
-				output: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-			},
-			contextWindow: 200000,
-			maxTokens: 64000,
-		} satisfies Model<"openai-responses">,
 	},
 	"google": {
 		"gemini-1.5-flash": {
@@ -4657,23 +4622,6 @@ export const MODELS = {
 			contextWindow: 131072,
 			maxTokens: 131072,
 		} satisfies Model<"openai-completions">,
-		"allenai/olmo-3-7b-instruct": {
-			id: "allenai/olmo-3-7b-instruct",
-			name: "AllenAI: Olmo 3 7B Instruct",
-			api: "openai-completions",
-			provider: "openrouter",
-			baseUrl: "https://openrouter.ai/api/v1",
-			reasoning: false,
-			input: ["text"],
-			cost: {
-				input: 0.09999999999999999,
-				output: 0.19999999999999998,
-				cacheRead: 0,
-				cacheWrite: 0,
-			},
-			contextWindow: 65536,
-			maxTokens: 65536,
-		} satisfies Model<"openai-completions">,
 		"allenai/olmo-3.1-32b-instruct": {
 			id: "allenai/olmo-3.1-32b-instruct",
 			name: "AllenAI: Olmo 3.1 32B Instruct",
@@ -5228,12 +5176,12 @@ export const MODELS = {
 			input: ["text"],
 			cost: {
 				input: 0.7,
-				output: 2.4,
+				output: 2.5,
 				cacheRead: 0,
 				cacheWrite: 0,
 			},
-			contextWindow: 163840,
-			maxTokens: 163840,
+			contextWindow: 64000,
+			maxTokens: 16000,
 		} satisfies Model<"openai-completions">,
 		"deepseek/deepseek-r1-0528": {
 			id: "deepseek/deepseek-r1-0528",
@@ -5244,13 +5192,13 @@ export const MODELS = {
 			reasoning: true,
 			input: ["text"],
 			cost: {
-				input: 0.44999999999999996,
-				output: 2.1500000000000004,
+				input: 0.39999999999999997,
+				output: 1.75,
 				cacheRead: 0,
 				cacheWrite: 0,
 			},
-			contextWindow: 131072,
-			maxTokens: 32768,
+			contextWindow: 163840,
+			maxTokens: 65536,
 		} satisfies Model<"openai-completions">,
 		"deepseek/deepseek-r1-distill-llama-70b": {
 			id: "deepseek/deepseek-r1-distill-llama-70b",
@@ -5349,7 +5297,7 @@ export const MODELS = {
 				input: 0.09999999999999999,
 				output: 0.39999999999999997,
 				cacheRead: 0.024999999999999998,
-				cacheWrite: 0.18330000000000002,
+				cacheWrite: 0.0833,
 			},
 			contextWindow: 1048576,
 			maxTokens: 8192,
@@ -5400,7 +5348,7 @@ export const MODELS = {
 				input: 0.3,
 				output: 2.5,
 				cacheRead: 0.03,
-				cacheWrite: 0.3833,
+				cacheWrite: 0.08333333333333334,
 			},
 			contextWindow: 1048576,
 			maxTokens: 65535,
@@ -5417,7 +5365,7 @@ export const MODELS = {
 				input: 0.09999999999999999,
 				output: 0.39999999999999997,
 				cacheRead: 0.01,
-				cacheWrite: 0.18330000000000002,
+				cacheWrite: 0.0833,
 			},
 			contextWindow: 1048576,
 			maxTokens: 65535,
@@ -5433,12 +5381,29 @@ export const MODELS = {
 			cost: {
 				input: 0.09999999999999999,
 				output: 0.39999999999999997,
-				cacheRead: 0,
-				cacheWrite: 0,
+				cacheRead: 0.01,
+				cacheWrite: 0.0833,
 			},
 			contextWindow: 1048576,
 			maxTokens: 65536,
 		} satisfies Model<"openai-completions">,
+		"google/gemini-2.5-flash-preview-09-2025": {
+			id: "google/gemini-2.5-flash-preview-09-2025",
+			name: "Google: Gemini 2.5 Flash Preview 09-2025",
+			api: "openai-completions",
+			provider: "openrouter",
+			baseUrl: "https://openrouter.ai/api/v1",
+			reasoning: true,
+			input: ["text", "image"],
+			cost: {
+				input: 0.3,
+				output: 2.5,
+				cacheRead: 0.075,
+				cacheWrite: 0.0833,
+			},
+			contextWindow: 1048576,
+			maxTokens: 65535,
+		} satisfies Model<"openai-completions">,
 		"google/gemini-2.5-pro": {
 			id: "google/gemini-2.5-pro",
 			name: "Google: Gemini 2.5 Pro",
@@ -5451,7 +5416,7 @@ export const MODELS = {
 				input: 1.25,
 				output: 10,
 				cacheRead: 0.125,
-				cacheWrite: 1.625,
+				cacheWrite: 0.375,
 			},
 			contextWindow: 1048576,
 			maxTokens: 65536,
@@ -5468,7 +5433,7 @@ export const MODELS = {
 				input: 1.25,
 				output: 10,
 				cacheRead: 0.31,
-				cacheWrite: 1.625,
+				cacheWrite: 0.375,
 			},
 			contextWindow: 1048576,
 			maxTokens: 65536,
@@ -5485,7 +5450,7 @@ export const MODELS = {
 				input: 1.25,
 				output: 10,
 				cacheRead: 0.31,
-				cacheWrite: 1.625,
+				cacheWrite: 0.375,
 			},
 			contextWindow: 1048576,
 			maxTokens: 65535,
@@ -5519,7 +5484,7 @@ export const MODELS = {
 				input: 2,
 				output: 12,
 				cacheRead: 0.19999999999999998,
-				cacheWrite: 2.375,
+				cacheWrite: 0.375,
 			},
 			contextWindow: 1048576,
 			maxTokens: 65536,
@@ -5609,23 +5574,6 @@ export const MODELS = {
 			contextWindow: 256000,
 			maxTokens: 128000,
 		} satisfies Model<"openai-completions">,
-		"meta-llama/llama-3-70b-instruct": {
-			id: "meta-llama/llama-3-70b-instruct",
-			name: "Meta: Llama 3 70B Instruct",
-			api: "openai-completions",
-			provider: "openrouter",
-			baseUrl: "https://openrouter.ai/api/v1",
-			reasoning: false,
-			input: ["text"],
-			cost: {
-				input: 0.3,
-				output: 0.39999999999999997,
-				cacheRead: 0,
-				cacheWrite: 0,
-			},
-			contextWindow: 8192,
-			maxTokens: 16384,
-		} satisfies Model<"openai-completions">,
 		"meta-llama/llama-3-8b-instruct": {
 			id: "meta-llama/llama-3-8b-instruct",
 			name: "Meta: Llama 3 8B Instruct",
@@ -5890,12 +5838,12 @@ export const MODELS = {
 			reasoning: false,
 			input: ["text"],
 			cost: {
-				input: 0.07,
-				output: 0.28,
+				input: 0.09999999999999999,
+				output: 0.3,
 				cacheRead: 0,
 				cacheWrite: 0,
 			},
-			contextWindow: 128000,
+			contextWindow: 131072,
 			maxTokens: 4096,
 		} satisfies Model<"openai-completions">,
 		"mistralai/ministral-14b-2512": {
@@ -5983,40 +5931,6 @@ export const MODELS = {
 			contextWindow: 262144,
 			maxTokens: 4096,
 		} satisfies Model<"openai-completions">,
-		"mistralai/mistral-7b-instruct": {
-			id: "mistralai/mistral-7b-instruct",
-			name: "Mistral: Mistral 7B Instruct",
-			api: "openai-completions",
-			provider: "openrouter",
-			baseUrl: "https://openrouter.ai/api/v1",
-			reasoning: false,
-			input: ["text"],
-			cost: {
-				input: 0.028,
-				output: 0.054,
-				cacheRead: 0,
-				cacheWrite: 0,
-			},
-			contextWindow: 32768,
-			maxTokens: 16384,
-		} satisfies Model<"openai-completions">,
-		"mistralai/mistral-7b-instruct:free": {
-			id: "mistralai/mistral-7b-instruct:free",
-			name: "Mistral: Mistral 7B Instruct (free)",
-			api: "openai-completions",
-			provider: "openrouter",
-			baseUrl: "https://openrouter.ai/api/v1",
-			reasoning: false,
-			input: ["text"],
-			cost: {
-				input: 0,
-				output: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-			},
-			contextWindow: 32768,
-			maxTokens: 16384,
-		} satisfies Model<"openai-completions">,
 		"mistralai/mistral-large": {
 			id: "mistralai/mistral-large",
 			name: "Mistral Large",
@@ -6134,7 +6048,7 @@ export const MODELS = {
 				cacheWrite: 0,
 			},
 			contextWindow: 131072,
-			maxTokens: 16384,
+			maxTokens: 131072,
 		} satisfies Model<"openai-completions">,
 		"mistralai/mistral-saba": {
 			id: "mistralai/mistral-saba",
@@ -6578,23 +6492,6 @@ export const MODELS = {
 			contextWindow: 128000,
 			maxTokens: 4096,
 		} satisfies Model<"openai-completions">,
-		"openai/codex-mini": {
-			id: "openai/codex-mini",
-			name: "OpenAI: Codex Mini",
-			api: "openai-completions",
-			provider: "openrouter",
-			baseUrl: "https://openrouter.ai/api/v1",
-			reasoning: true,
-			input: ["text", "image"],
-			cost: {
-				input: 1.5,
-				output: 6,
-				cacheRead: 0.375,
-				cacheWrite: 0,
-			},
-			contextWindow: 200000,
-			maxTokens: 100000,
-		} satisfies Model<"openai-completions">,
 		"openai/gpt-3.5-turbo": {
 			id: "openai/gpt-3.5-turbo",
 			name: "OpenAI: GPT-3.5 Turbo",
@@ -7641,13 +7538,13 @@ export const MODELS = {
 			reasoning: true,
 			input: ["text"],
 			cost: {
-				input: 0.18,
-				output: 0.54,
+				input: 0.19999999999999998,
+				output: 0.6,
 				cacheRead: 0,
 				cacheWrite: 0,
 			},
 			contextWindow: 40960,
-			maxTokens: 40960,
+			maxTokens: 4096,
 		} satisfies Model<"openai-completions">,
 		"qwen/qwen3-235b-a22b-2507": {
 			id: "qwen/qwen3-235b-a22b-2507",
@@ -7921,6 +7818,23 @@ export const MODELS = {
 			contextWindow: 262144,
 			maxTokens: 4096,
 		} satisfies Model<"openai-completions">,
+		"qwen/qwen3-next-80b-a3b-instruct:free": {
+			id: "qwen/qwen3-next-80b-a3b-instruct:free",
+			name: "Qwen: Qwen3 Next 80B A3B Instruct (free)",
+			api: "openai-completions",
+			provider: "openrouter",
+			baseUrl: "https://openrouter.ai/api/v1",
+			reasoning: false,
+			input: ["text"],
+			cost: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+			},
+			contextWindow: 262144,
+			maxTokens: 4096,
+		} satisfies Model<"openai-completions">,
 		"qwen/qwen3-next-80b-a3b-thinking": {
 			id: "qwen/qwen3-next-80b-a3b-thinking",
 			name: "Qwen: Qwen3 Next 80B A3B Thinking",
@@ -7935,8 +7849,8 @@ export const MODELS = {
 				cacheRead: 0,
 				cacheWrite: 0,
 			},
-			contextWindow: 262144,
-			maxTokens: 262144,
+			contextWindow: 128000,
+			maxTokens: 4096,
 		} satisfies Model<"openai-completions">,
 		"qwen/qwen3-vl-235b-a22b-instruct": {
 			id: "qwen/qwen3-vl-235b-a22b-instruct",
@@ -7955,23 +7869,6 @@ export const MODELS = {
 			contextWindow: 262144,
 			maxTokens: 4096,
 		} satisfies Model<"openai-completions">,
-		"qwen/qwen3-vl-235b-a22b-thinking": {
-			id: "qwen/qwen3-vl-235b-a22b-thinking",
-			name: "Qwen: Qwen3 VL 235B A22B Thinking",
-			api: "openai-completions",
-			provider: "openrouter",
-			baseUrl: "https://openrouter.ai/api/v1",
-			reasoning: true,
-			input: ["text", "image"],
-			cost: {
-				input: 0.44999999999999996,
-				output: 3.5,
-				cacheRead: 0,
-				cacheWrite: 0,
-			},
-			contextWindow: 262144,
-			maxTokens: 262144,
-		} satisfies Model<"openai-completions">,
 		"qwen/qwen3-vl-30b-a3b-instruct": {
 			id: "qwen/qwen3-vl-30b-a3b-instruct",
 			name: "Qwen: Qwen3 VL 30B A3B Instruct",
@@ -8355,13 +8252,13 @@ export const MODELS = {
 			reasoning: true,
 			input: ["text"],
 			cost: {
-				input: 0.09999999999999999,
-				output: 0.3,
-				cacheRead: 0.02,
+				input: 0.09,
+				output: 0.29,
+				cacheRead: 0,
 				cacheWrite: 0,
 			},
 			contextWindow: 262144,
-			maxTokens: 32000,
+			maxTokens: 4096,
 		} satisfies Model<"openai-completions">,
 		"xiaomi/mimo-v2-flash:free": {
 			id: "xiaomi/mimo-v2-flash:free",
@@ -10516,8 +10413,8 @@ export const MODELS = {
 			reasoning: true,
 			input: ["text"],
 			cost: {
-				input: 0.098,
-				output: 0.293,
+				input: 0.09,
+				output: 0.29,
 				cacheRead: 0,
 				cacheWrite: 0,
 			},

package/src/providers/amazon-bedrock.ts

@@ -54,6 +54,11 @@ export interface BedrockOptions extends StreamOptions {
 
 type Block = (TextContent | ThinkingContent | ToolCall) & { index?: number; partialJson?: string };
 
+function sanitizeToolCallId(id: string): string {
+	const sanitized = id.replace(/[^a-zA-Z0-9_-]/g, "_");
+	return sanitized.length > 64 ? sanitized.slice(0, 64) : sanitized;
+}
+
 export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 	model: Model<"bedrock-converse-stream">,
 	context: Context,
@@ -165,7 +170,7 @@ function handleContentBlockStart(
 	if (start?.toolUse) {
 		const block: Block = {
 			type: "toolCall",
-			id: start.toolUse.toolUseId || "",
+			id: sanitizeToolCallId(start.toolUse.toolUseId || ""),
 			name: start.toolUse.name || "",
 			arguments: {},
 			partialJson: "",
@@ -290,6 +295,17 @@ function supportsPromptCaching(model: Model<"bedrock-converse-stream">): boolean
 	return false;
 }
 
+/**
+ * Check if the model supports thinking signatures in reasoningContent.
+ * Only Anthropic Claude models support the signature field.
+ * Other models (Nova, Titan, Mistral, Llama, etc.) reject it with:
+ * "This model doesn't support the reasoningContent.reasoningText.signature field"
+ */
+function supportsThinkingSignature(model: Model<"bedrock-converse-stream">): boolean {
+	const id = model.id.toLowerCase();
+	return id.includes("anthropic.claude") || id.includes("anthropic/claude");
+}
+
 function buildSystemPrompt(
 	systemPrompt: string | undefined,
 	model: Model<"bedrock-converse-stream">,
@@ -348,17 +364,32 @@ function convertMessages(context: Context, model: Model<"bedrock-converse-stream
 							break;
 						case "toolCall":
 							contentBlocks.push({
-								toolUse: { toolUseId: c.id, name: c.name, input: c.arguments },
+								toolUse: {
+									toolUseId: sanitizeToolCallId(c.id),
+									name: c.name,
+									input: c.arguments,
+								},
 							});
 							break;
 						case "thinking":
 							// Skip empty thinking blocks
 							if (c.thinking.trim().length === 0) continue;
-							contentBlocks.push({
-								reasoningContent: {
-									reasoningText: { text: sanitizeSurrogates(c.thinking), signature: c.thinkingSignature },
-								},
-							});
+							// Only Anthropic models support the signature field in reasoningText.
+							// For other models, we omit the signature to avoid errors like:
+							// "This model doesn't support the reasoningContent.reasoningText.signature field"
+							if (supportsThinkingSignature(model)) {
+								contentBlocks.push({
+									reasoningContent: {
+										reasoningText: { text: sanitizeSurrogates(c.thinking), signature: c.thinkingSignature },
+									},
+								});
+							} else {
+								contentBlocks.push({
+									reasoningContent: {
+										reasoningText: { text: sanitizeSurrogates(c.thinking) },
+									},
+								});
+							}
 							break;
 						default:
 							throw new Error("Unknown assistant content type");
@@ -382,7 +413,7 @@ function convertMessages(context: Context, model: Model<"bedrock-converse-stream
 				// Add current tool result with all content blocks combined
 				toolResults.push({
 					toolResult: {
-						toolUseId: m.toolCallId,
+						toolUseId: sanitizeToolCallId(m.toolCallId),
 						content: m.content.map((c) =>
 							c.type === "image"
 								? { image: createImageBlock(c.mimeType, c.data) }
@@ -398,7 +429,7 @@ function convertMessages(context: Context, model: Model<"bedrock-converse-stream
 					const nextMsg = transformedMessages[j] as ToolResultMessage;
 					toolResults.push({
 						toolResult: {
-							toolUseId: nextMsg.toolCallId,
+							toolUseId: sanitizeToolCallId(nextMsg.toolCallId),
 							content: nextMsg.content.map((c) =>
 								c.type === "image"
 									? { image: createImageBlock(c.mimeType, c.data) }

package/src/providers/anthropic.ts

@@ -47,15 +47,59 @@ export const claudeCodeHeaders = {
 } as const;
 
 export const applyClaudeToolPrefix = (name: string) => {
-	if (!claudeToolPrefix || name.startsWith(claudeToolPrefix)) return name;
+	if (!claudeToolPrefix) return name;
+	const prefix = claudeToolPrefix.toLowerCase();
+	if (name.toLowerCase().startsWith(prefix)) return name;
 	return `${claudeToolPrefix}${name}`;
 };
 
 export const stripClaudeToolPrefix = (name: string) => {
-	if (!claudeToolPrefix || !name.startsWith(claudeToolPrefix)) return name;
+	if (!claudeToolPrefix) return name;
+	const prefix = claudeToolPrefix.toLowerCase();
+	if (!name.toLowerCase().startsWith(prefix)) return name;
 	return name.slice(claudeToolPrefix.length);
 };
 
+// Claude Code 2.x tool names (canonical casing)
+// Source: https://cchistory.mariozechner.at/data/prompts-2.1.11.md
+// To update: https://github.com/badlogic/cchistory
+const claudeCodeTools = [
+	"Read",
+	"Write",
+	"Edit",
+	"Bash",
+	"Grep",
+	"Glob",
+	"AskUserQuestion",
+	"EnterPlanMode",
+	"ExitPlanMode",
+	"KillShell",
+	"NotebookEdit",
+	"Skill",
+	"Task",
+	"TaskOutput",
+	"TodoWrite",
+	"WebFetch",
+	"WebSearch",
+];
+
+const ccToolLookup = new Map(claudeCodeTools.map((t) => [t.toLowerCase(), t]));
+
+// Convert tool name to CC canonical casing if it matches (case-insensitive), fallback to prefix
+const toClaudeCodeName = (name: string) => ccToolLookup.get(name.toLowerCase()) ?? applyClaudeToolPrefix(name);
+
+// Convert CC tool name back to original, checking provided tools for case-insensitive match
+const fromClaudeCodeName = (name: string, tools?: Tool[]) => {
+	// First try to find by case-insensitive match in provided tools
+	if (tools && tools.length > 0) {
+		const lowerName = name.toLowerCase();
+		const matchedTool = tools.find((tool) => tool.name.toLowerCase() === lowerName);
+		if (matchedTool) return matchedTool.name;
+	}
+	// Fall back to stripping prefix if no match found
+	return stripClaudeToolPrefix(name);
+};
+
 /**
  * Convert content blocks to Anthropic API format
  */
@@ -187,7 +231,9 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 						const block: Block = {
 							type: "toolCall",
 							id: event.content_block.id,
-							name: isOAuthToken ? stripClaudeToolPrefix(event.content_block.name) : event.content_block.name,
+							name: isOAuthToken
+								? fromClaudeCodeName(event.content_block.name, context.tools)
+								: event.content_block.name,
 							arguments: event.content_block.input as Record<string, any>,
 							partialJson: "",
 							index: event.index,
@@ -631,7 +677,7 @@ function convertMessages(
 					blocks.push({
 						type: "tool_use",
 						id: sanitizeToolCallId(block.id),
-						name: isOAuthToken ? applyClaudeToolPrefix(block.name) : block.name,
+						name: isOAuthToken ? toClaudeCodeName(block.name) : block.name,
 						input: block.arguments,
 					});
 				}
@@ -704,7 +750,7 @@ function convertTools(tools: Tool[], isOAuthToken: boolean): Anthropic.Messages.
 		const jsonSchema = tool.parameters as any; // TypeBox already generates JSON Schema
 
 		return {
-			name: isOAuthToken ? applyClaudeToolPrefix(tool.name) : tool.name,
+			name: isOAuthToken ? toClaudeCodeName(tool.name) : tool.name,
 			description: tool.description,
 			input_schema: {
 				type: "object" as const,

package/src/providers/google-shared.ts

@@ -65,6 +65,10 @@ export function requiresToolCallId(modelId: string): boolean {
 	return modelId.startsWith("claude-");
 }
 
+function isGemini3Model(modelId: string): boolean {
+	return modelId.includes("gemini-3");
+}
+
 /**
  * Convert internal messages to Gemini Content[] format.
  */
@@ -131,6 +135,17 @@ export function convertMessages<T extends GoogleApiType>(model: Model<T>, contex
 						});
 					}
 				} else if (block.type === "toolCall") {
+					const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.thoughtSignature);
+					if (isGemini3Model(model.id) && !thoughtSignature) {
+						const argsStr = JSON.stringify(block.arguments, null, 2);
+						parts.push({
+							text: sanitizeSurrogates(
+								`[Historical context: a different model called tool "${block.name}" with arguments: ${argsStr}. Do not mimic this format - use proper function calling.]`,
+							),
+						});
+						continue;
+					}
+
 					const part: Part = {
 						functionCall: {
 							name: block.name,
@@ -141,7 +156,6 @@ export function convertMessages<T extends GoogleApiType>(model: Model<T>, contex
 					if (model.provider === "google-vertex" && part?.functionCall?.id) {
 						delete part.functionCall.id; // Vertex AI does not support 'id' in functionCall
 					}
-					const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.thoughtSignature);
 					if (thoughtSignature) {
 						part.thoughtSignature = thoughtSignature;
 					}

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

@@ -14,7 +14,7 @@ export const OPENAI_HEADERS = {
 
 export const OPENAI_HEADER_VALUES = {
 	BETA_RESPONSES: "responses=experimental",
-	ORIGINATOR_CODEX: "opencode",
+	ORIGINATOR_CODEX: "pi",
 } as const;
 
 export const URL_PATHS = {

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

@@ -1,12 +1,4 @@
-export const CODEX_INSTRUCTIONS = `You are pi, an expert coding assistant. You help users with coding tasks by reading files, executing commands, editing code, and writing new files.
-
-Pi specific Documentation:
-- Main documentation: pi-internal://README.md
-- Additional docs: pi-internal://docs
-- Examples: pi-internal://examples (extensions, custom tools, SDK)
-- When asked to create: custom models/providers (README.md), extensions (docs/extensions.md, examples/extensions/), themes (docs/theme.md), skills (docs/skills.md), TUI components (docs/tui.md - has copy-paste patterns)
-- Always read the doc, examples, AND follow .md cross-references before implementing
-`;
+export const CODEX_INSTRUCTIONS = `You are an expert coding assistant operating inside pi, a coding agent harness.`;
 
 export function getCodexInstructions(): string {
 	return CODEX_INSTRUCTIONS.trim();

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

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

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

@@ -49,15 +49,10 @@ export interface OpenAICodexResponsesOptions extends StreamOptions {
 	codexMode?: boolean;
 }
 
-const CODEX_DEBUG = process.env.PI_CODEX_DEBUG === "1" || process.env.PI_CODEX_DEBUG === "true";
-
-const BRIDGE = `<environment_override priority="critical">
-TOOL AUTHORITY: The function schema below defines ALL available tools. Tools mentioned elsewhere (todowrite, shell) DO NOT EXIST. Use ONLY schema-defined tools.
-
-EXECUTION BIAS: Execute simple tasks directly. Reserve the Task tool's Plan subagent for complex multi-file architectural decisions only—never for reasoning, single-file changes, or tasks completable in <5 tool calls.
-
-These instructions override all prior context. This is critical.
-</environment_override>`;
+const CODEX_DEBUG = process.env.OMP_CODEX_DEBUG === "1" || process.env.OMP_CODEX_DEBUG === "true";
+const CODEX_MAX_RETRIES = 2;
+const CODEX_RETRYABLE_STATUS = new Set([408, 429, 500, 502, 503, 504]);
+const CODEX_RETRY_DELAY_MS = 500;
 
 export const streamOpenAICodexResponses: StreamFunction<"openai-codex-responses"> = (
 	model: Model<"openai-codex-responses">,
@@ -119,7 +114,6 @@ export const streamOpenAICodexResponses: StreamFunction<"openai-codex-responses"
 			const codexInstructions = getCodexInstructions();
 			const systemPrompt = buildCodexSystemPrompt({
 				codexInstructions,
-				bridgeText: BRIDGE,
 				userSystemPrompt: context.systemPrompt,
 			});
 
@@ -143,12 +137,15 @@ export const streamOpenAICodexResponses: StreamFunction<"openai-codex-responses"
 				headers: redactHeaders(headers),
 			});
 
-			const response = await fetch(url, {
-				method: "POST",
-				headers,
-				body: JSON.stringify(transformedBody),
-				signal: options?.signal,
-			});
+			const response = await fetchWithRetry(
+				url,
+				{
+					method: "POST",
+					headers,
+					body: JSON.stringify(transformedBody),
+				},
+				options?.signal,
+			);
 
 			logCodexDebug("codex response", {
 				url: response.url,
@@ -394,7 +391,7 @@ function createCodexHeaders(
 	headers.set(OPENAI_HEADERS.ACCOUNT_ID, accountId);
 	headers.set(OPENAI_HEADERS.BETA, OPENAI_HEADER_VALUES.BETA_RESPONSES);
 	headers.set(OPENAI_HEADERS.ORIGINATOR, OPENAI_HEADER_VALUES.ORIGINATOR_CODEX);
-	headers.set("User-Agent", `opencode/${packageJson.version} (${os.platform()} ${os.release()}; ${os.arch()})`);
+	headers.set("User-Agent", `pi/${packageJson.version} (${os.platform()} ${os.release()}; ${os.arch()})`);
 
 	if (promptCacheKey) {
 		headers.set(OPENAI_HEADERS.CONVERSATION_ID, promptCacheKey);
@@ -418,6 +415,43 @@ function logCodexDebug(message: string, details?: Record<string, unknown>): void
 	console.error(`[codex] ${message}`);
 }
 
+function getRetryDelayMs(response: Response | null, attempt: number): number {
+	const retryAfter = response?.headers?.get("retry-after") || null;
+	if (retryAfter) {
+		const seconds = Number(retryAfter);
+		if (Number.isFinite(seconds)) {
+			return Math.max(0, seconds * 1000);
+		}
+		const parsedDate = Date.parse(retryAfter);
+		if (!Number.isNaN(parsedDate)) {
+			return Math.max(0, parsedDate - Date.now());
+		}
+	}
+	return CODEX_RETRY_DELAY_MS * (attempt + 1);
+}
+
+async function fetchWithRetry(url: string, init: RequestInit, signal?: AbortSignal): Promise<Response> {
+	let attempt = 0;
+	while (true) {
+		try {
+			const response = await fetch(url, { ...init, signal: signal ?? init.signal });
+			if (!CODEX_RETRYABLE_STATUS.has(response.status) || attempt >= CODEX_MAX_RETRIES) {
+				return response;
+			}
+			if (signal?.aborted) return response;
+			const delay = getRetryDelayMs(response, attempt);
+			await new Promise((resolve) => setTimeout(resolve, delay));
+		} catch (error) {
+			if (attempt >= CODEX_MAX_RETRIES || signal?.aborted) {
+				throw error;
+			}
+			const delay = CODEX_RETRY_DELAY_MS * (attempt + 1);
+			await new Promise((resolve) => setTimeout(resolve, delay));
+		}
+		attempt += 1;
+	}
+}
+
 function redactHeaders(headers: Headers): Record<string, string> {
 	const redacted: Record<string, string> = {};
 	for (const [key, value] of headers.entries()) {

package/src/providers/openai-completions.ts

@@ -680,24 +680,33 @@ function mapStopReason(reason: ChatCompletionChunk.Choice["finish_reason"]): Sto
 }
 
 /**
- * Detect compatibility settings from baseUrl for known providers.
+ * Detect compatibility settings from provider and baseUrl for known providers.
+ * Provider takes precedence over URL-based detection since it's explicitly configured.
  * Returns a fully resolved OpenAICompat object with all fields set.
  */
-function detectCompatFromUrl(baseUrl: string): Required<OpenAICompat> {
-	const isZai = baseUrl.includes("api.z.ai");
+function detectCompat(model: Model<"openai-completions">): Required<OpenAICompat> {
+	const provider = model.provider;
+	const baseUrl = model.baseUrl;
+
+	const isZai = provider === "zai" || baseUrl.includes("api.z.ai");
 
 	const isNonStandard =
+		provider === "cerebras" ||
 		baseUrl.includes("cerebras.ai") ||
+		provider === "xai" ||
 		baseUrl.includes("api.x.ai") ||
+		provider === "mistral" ||
 		baseUrl.includes("mistral.ai") ||
 		baseUrl.includes("chutes.ai") ||
-		isZai;
+		isZai ||
+		provider === "opencode" ||
+		baseUrl.includes("opencode.ai");
 
-	const useMaxTokens = baseUrl.includes("mistral.ai") || baseUrl.includes("chutes.ai");
+	const useMaxTokens = provider === "mistral" || baseUrl.includes("mistral.ai") || baseUrl.includes("chutes.ai");
 
-	const isGrok = baseUrl.includes("api.x.ai");
+	const isGrok = provider === "xai" || baseUrl.includes("api.x.ai");
 
-	const isMistral = baseUrl.includes("mistral.ai");
+	const isMistral = provider === "mistral" || baseUrl.includes("mistral.ai");
 
 	return {
 		supportsStore: !isNonStandard,
@@ -715,10 +724,10 @@ function detectCompatFromUrl(baseUrl: string): Required<OpenAICompat> {
 
 /**
  * Get resolved compatibility settings for a model.
- * Uses explicit model.compat if provided, otherwise auto-detects from URL.
+ * Uses explicit model.compat if provided, otherwise auto-detects from provider/URL.
  */
 function getCompat(model: Model<"openai-completions">): Required<OpenAICompat> {
-	const detected = detectCompatFromUrl(model.baseUrl);
+	const detected = detectCompat(model);
 	if (!model.compat) return detected;
 
 	return {

package/src/providers/transform-messages.ts

@@ -14,19 +14,19 @@ export function transformMessages<TApi extends Api>(messages: Message[], model:
 	const toolCallIdMap = new Map<string, string>();
 
 	// First pass: transform messages (thinking blocks, tool call ID normalization)
-	const transformed = messages.map((msg) => {
+	const transformed = messages.flatMap<Message>((msg): Message[] => {
 		// User messages pass through unchanged
 		if (msg.role === "user") {
-			return msg;
+			return [msg];
 		}
 
 		// Handle toolResult messages - normalize toolCallId if we have a mapping
 		if (msg.role === "toolResult") {
 			const normalizedId = toolCallIdMap.get(msg.toolCallId);
 			if (normalizedId && normalizedId !== msg.toolCallId) {
-				return { ...msg, toolCallId: normalizedId };
+				return [{ ...msg, toolCallId: normalizedId }];
 			}
-			return msg;
+			return [msg];
 		}
 
 		// Assistant messages need transformation check
@@ -35,7 +35,10 @@ export function transformMessages<TApi extends Api>(messages: Message[], model:
 
 			// If message is from the same provider and API, keep as is
 			if (assistantMsg.provider === model.provider && assistantMsg.api === model.api) {
-				return msg;
+				if (assistantMsg.stopReason === "error" && assistantMsg.content.length === 0) {
+					return [];
+				}
+				return [msg];
 			}
 
 			// Check if we need to normalize tool call IDs
@@ -73,13 +76,19 @@ export function transformMessages<TApi extends Api>(messages: Message[], model:
 				return block;
 			});
 
+			if (assistantMsg.stopReason === "error" && transformedContent.length === 0) {
+				return [];
+			}
+
 			// Return transformed assistant message
-			return {
-				...assistantMsg,
-				content: transformedContent,
-			};
+			return [
+				{
+					...assistantMsg,
+					content: transformedContent,
+				},
+			];
 		}
-		return msg;
+		return [msg];
 	});
 
 	// Second pass: insert synthetic empty tool results for orphaned tool calls
@@ -110,15 +119,30 @@ export function transformMessages<TApi extends Api>(messages: Message[], model:
 				existingToolResultIds = new Set();
 			}
 
-			// Track tool calls from this assistant message
 			const assistantMsg = msg as AssistantMessage;
+			const isErroredAssistant = assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted";
 			const toolCalls = assistantMsg.content.filter((b) => b.type === "toolCall") as ToolCall[];
-			if (toolCalls.length > 0) {
+
+			result.push(msg);
+
+			// For errored/aborted messages with tool calls, insert synthetic results immediately
+			// to maintain tool_use/tool_result pairing required by the API
+			if (isErroredAssistant && toolCalls.length > 0) {
+				for (const tc of toolCalls) {
+					result.push({
+						role: "toolResult",
+						toolCallId: tc.id,
+						toolName: tc.name,
+						content: [{ type: "text", text: "Tool execution was aborted" }],
+						isError: true,
+						timestamp: Date.now(),
+					} as ToolResultMessage);
+				}
+			} else if (!isErroredAssistant && toolCalls.length > 0) {
+				// Track tool calls to check for orphaned calls later
 				pendingToolCalls = toolCalls;
 				existingToolResultIds = new Set();
 			}
-
-			result.push(msg);
 		} else if (msg.role === "toolResult") {
 			existingToolResultIds.add(msg.toolCallId);
 			result.push(msg);
@@ -146,5 +170,22 @@ export function transformMessages<TApi extends Api>(messages: Message[], model:
 		}
 	}
 
+	// Handle orphaned tool calls at the end of the message array
+	// This can happen if the last message is an assistant with tool calls that never got results
+	if (pendingToolCalls.length > 0) {
+		for (const tc of pendingToolCalls) {
+			if (!existingToolResultIds.has(tc.id)) {
+				result.push({
+					role: "toolResult",
+					toolCallId: tc.id,
+					toolName: tc.name,
+					content: [{ type: "text", text: "No result provided" }],
+					isError: true,
+					timestamp: Date.now(),
+				} as ToolResultMessage);
+			}
+		}
+	}
+
 	return result;
 }

package/src/stream.ts

@@ -223,6 +223,25 @@ const GOOGLE_THINKING: Record<ThinkingLevel, number> = {
 	xhigh: 24575,
 };
 
+const BEDROCK_CLAUDE_THINKING: Record<ThinkingLevel, number> = {
+	minimal: 1024,
+	low: 2048,
+	medium: 8192,
+	high: 16384,
+	xhigh: 16384,
+};
+
+function resolveBedrockThinkingBudget(
+	model: Model<"bedrock-converse-stream">,
+	options?: SimpleStreamOptions,
+): { budget: number; level: ThinkingLevel } | null {
+	if (!options?.reasoning || !model.reasoning) return null;
+	if (!model.id.includes("anthropic.claude")) return null;
+	const level = options.reasoning === "xhigh" ? "high" : options.reasoning;
+	const budget = options.thinkingBudgets?.[level] ?? BEDROCK_CLAUDE_THINKING[level];
+	return { budget, level };
+}
+
 function mapOptionsForApi<TApi extends Api>(
 	model: Model<TApi>,
 	options?: SimpleStreamOptions,
@@ -282,12 +301,28 @@ function mapOptionsForApi<TApi extends Api>(
 			}
 		}
 
-		case "bedrock-converse-stream":
-			return {
+		case "bedrock-converse-stream": {
+			const bedrockBase: BedrockOptions = {
 				...base,
 				reasoning: options?.reasoning,
 				thinkingBudgets: options?.thinkingBudgets,
-			} satisfies BedrockOptions;
+			};
+			const budgetInfo = resolveBedrockThinkingBudget(model as Model<"bedrock-converse-stream">, options);
+			if (!budgetInfo) return bedrockBase as OptionsForApi<TApi>;
+			let maxTokens = bedrockBase.maxTokens ?? model.maxTokens;
+			let thinkingBudgets = bedrockBase.thinkingBudgets;
+			if (maxTokens <= budgetInfo.budget) {
+				const desiredMaxTokens = Math.min(model.maxTokens, budgetInfo.budget + MIN_OUTPUT_TOKENS);
+				if (desiredMaxTokens > maxTokens) {
+					maxTokens = desiredMaxTokens;
+				}
+			}
+			if (maxTokens <= budgetInfo.budget) {
+				const adjustedBudget = Math.max(0, maxTokens - MIN_OUTPUT_TOKENS);
+				thinkingBudgets = { ...(thinkingBudgets ?? {}), [budgetInfo.level]: adjustedBudget };
+			}
+			return { ...bedrockBase, maxTokens, thinkingBudgets } as OptionsForApi<TApi>;
+		}
 
 		case "openai-completions":
 			return {

package/src/utils/migrate-env.ts

@@ -0,0 +1,8 @@
+for (const [key, value] of Object.entries(process.env)) {
+	if (key.startsWith("PI_") && value !== undefined) {
+		const ompKey = `OMP_${key.slice(3)}`; // PI_FOO -> OMP_FOO
+		if (process.env[ompKey] === undefined) {
+			process.env[ompKey] = value;
+		}
+	}
+}

package/src/utils/validation.ts

@@ -29,6 +29,9 @@ import type { Tool, ToolCall } from "../types";
 /** Regex matching valid JSON number literals (integers, decimals, scientific notation) */
 const JSON_NUMBER_PATTERN = /^[+-]?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
 
+/** Regex matching numeric strings (allows leading zeros) */
+const NUMERIC_STRING_PATTERN = /^[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+
 /**
  * Normalizes AJV's `params.type` into a consistent string array.
  * AJV may report the expected type as a single string or an array of strings
@@ -69,6 +72,28 @@ function matchesExpectedType(value: unknown, expectedTypes: string[]): boolean {
 	});
 }
 
+function tryParseNumberString(value: string, expectedTypes: string[]): { value: unknown; changed: boolean } {
+	if (!expectedTypes.includes("number") && !expectedTypes.includes("integer")) {
+		return { value, changed: false };
+	}
+
+	const trimmed = value.trim();
+	if (!trimmed || !NUMERIC_STRING_PATTERN.test(trimmed)) {
+		return { value, changed: false };
+	}
+
+	const parsed = Number(trimmed);
+	if (!Number.isFinite(parsed)) {
+		return { value, changed: false };
+	}
+
+	if (!matchesExpectedType(parsed, expectedTypes)) {
+		return { value, changed: false };
+	}
+
+	return { value: parsed, changed: true };
+}
+
 /**
  * Attempts to parse a string as JSON if it looks like a JSON literal and
  * the parsed result matches one of the expected types.
@@ -86,6 +111,11 @@ function tryParseJsonForTypes(value: string, expectedTypes: string[]): { value:
 	const trimmed = value.trim();
 	if (!trimmed) return { value, changed: false };
 
+	const numberCoercion = tryParseNumberString(trimmed, expectedTypes);
+	if (numberCoercion.changed) {
+		return numberCoercion;
+	}
+
 	// Quick syntactic checks to avoid unnecessary parse attempts
 	const looksJsonObject = trimmed.startsWith("{") && trimmed.endsWith("}");
 	const looksJsonArray = trimmed.startsWith("[") && trimmed.endsWith("]");