@oh-my-pi/pi-coding-agent 16.0.4 → 16.0.6

package/src/config/config-file.ts

@@ -1,8 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { getAgentDir, isEnoent, logger } from "@oh-my-pi/pi-utils";
+import type { Type } from "arktype";
 import { JSONC, YAML } from "bun";
-import type { ZodType } from "zod/v4";
 
 /** Minimal subset of the AJV ConfigSchemaError shape this module actually relies on. */
 interface ConfigSchemaError {
@@ -55,7 +55,7 @@ function migrateJsonToYml(jsonPath: string, ymlPath: string) {
 
 export interface IConfigFile<T> {
 	readonly id: string;
-	readonly schema: ZodType<T>;
+	readonly schema: Type;
 	path?(): string;
 	load(): T | null;
 	invalidate?(): void;
@@ -129,7 +129,7 @@ export class ConfigFile<T> implements IConfigFile<T> {
 
 	constructor(
 		readonly id: string,
-		readonly schema: ZodType<T>,
+		readonly schema: Type,
 		configPath: string = path.join(getAgentDir(), `${id}.yml`),
 	) {
 		this.#basePath = configPath;
@@ -193,10 +193,10 @@ export class ConfigFile<T> implements IConfigFile<T> {
 	}
 
 	createDefault(): T {
-		const parsed = this.schema.safeParse({});
-		if (parsed.success) return parsed.data;
-		const fallback = this.schema.safeParse(undefined);
-		if (fallback.success) return fallback.data;
+		const parsed = this.schema({});
+		if (!(parsed instanceof Error)) return parsed as T;
+		const fallback = this.schema(undefined);
+		if (!(fallback instanceof Error)) return fallback as T;
 		throw new ConfigError(this.id, undefined, {
 			err: new Error("Schema produced no default value"),
 			stage: "createDefault",
@@ -219,19 +219,17 @@ export class ConfigFile<T> implements IConfigFile<T> {
 				throw new Error(`Invalid config file path: ${this.#basePath}`);
 			}
 
-			const checked = this.schema.safeParse(parsed);
-			if (!checked.success) {
+			const checked = this.schema(parsed);
+			if (checked instanceof Error) {
 				const schemaErrors: ConfigSchemaError[] = [];
-				for (const issue of checked.error.issues) {
-					const instancePath = issue.path.length === 0 ? "" : `/${issue.path.map(String).join("/")}`;
-					schemaErrors.push({ instancePath, message: issue.message });
-					if (schemaErrors.length >= 50) break;
-				}
+				// arktype errors are Error instances with a message property
+				// Extract the error message as a single schema error
+				schemaErrors.push({ instancePath: "root", message: checked.message });
 				const error = new ConfigError(this.id, schemaErrors);
 				logger.warn("Failed to parse config file", { path: this.path(), error });
 				return this.#storeCache({ error, status: "error" });
 			}
-			const value = checked.data;
+			const value = checked as T;
 			try {
 				this.#auxValidate?.(value);
 			} catch (error) {

package/src/config/keybindings.ts

@@ -31,6 +31,7 @@ interface AppKeybindings {
 	"app.tools.expand": true;
 	"app.editor.external": true;
 	"app.message.followUp": true;
+	"app.retry": true;
 	"app.message.dequeue": true;
 	"app.clipboard.pasteImage": true;
 	"app.clipboard.pasteTextRaw": true;
@@ -131,6 +132,10 @@ export const KEYBINDINGS = {
 		defaultKeys: ["ctrl+q", "ctrl+enter"],
 		description: "Send follow-up message",
 	},
+	"app.retry": {
+		defaultKeys: "alt+r",
+		description: "Retry last failed assistant turn",
+	},
 	"app.message.dequeue": {
 		defaultKeys: "alt+up",
 		description: "Dequeue message",
@@ -238,6 +243,7 @@ const KEYBINDING_NAME_MIGRATIONS = {
 	toggleThinking: "app.thinking.toggle",
 	externalEditor: "app.editor.external",
 	followUp: "app.message.followUp",
+	retry: "app.retry",
 	dequeue: "app.message.dequeue",
 	pasteImage: "app.clipboard.pasteImage",
 	pasteTextRaw: "app.clipboard.pasteTextRaw",

package/src/config/models-config-schema.ts

@@ -1,73 +1,72 @@
-import { z } from "zod/v4";
+import { type } from "arktype";
 
-const OpenRouterRoutingSchema = z.object({
-	only: z.array(z.string()).optional(),
-	order: z.array(z.string()).optional(),
+const OpenRouterRoutingSchema = type({
+	"only?": "string[]",
+	"order?": "string[]",
 });
 
-const VercelGatewayRoutingSchema = z.object({
-	only: z.array(z.string()).optional(),
-	order: z.array(z.string()).optional(),
+const VercelGatewayRoutingSchema = type({
+	"only?": "string[]",
+	"order?": "string[]",
 });
 
-const ReasoningEffortMapSchema = z.object({
-	minimal: z.string().optional(),
-	low: z.string().optional(),
-	medium: z.string().optional(),
-	high: z.string().optional(),
-	xhigh: z.string().optional(),
+const ReasoningEffortMapSchema = type({
+	"minimal?": "string",
+	"low?": "string",
+	"medium?": "string",
+	"high?": "string",
+	"xhigh?": "string",
 });
 
-const OpenAICompatFieldsSchema = z.object({
-	supportsStore: z.boolean().optional(),
-	supportsDeveloperRole: z.boolean().optional(),
-	supportsMultipleSystemMessages: z.boolean().optional(),
-	supportsReasoningEffort: z.boolean().optional(),
-	reasoningEffortMap: ReasoningEffortMapSchema.optional(),
-	maxTokensField: z.enum(["max_completion_tokens", "max_tokens"]).optional(),
-	supportsUsageInStreaming: z.boolean().optional(),
-	requiresToolResultName: z.boolean().optional(),
-	requiresMistralToolIds: z.boolean().optional(),
-	requiresAssistantAfterToolResult: z.boolean().optional(),
-	requiresThinkingAsText: z.boolean().optional(),
-	reasoningContentField: z.enum(["reasoning_content", "reasoning", "reasoning_text"]).optional(),
-	requiresReasoningContentForToolCalls: z.boolean().optional(),
-	allowsSyntheticReasoningContentForToolCalls: z.boolean().optional(),
-	requiresAssistantContentForToolCalls: z.boolean().optional(),
-	supportsToolChoice: z.boolean().optional(),
-	supportsForcedToolChoice: z.boolean().optional(),
-	disableReasoningOnForcedToolChoice: z.boolean().optional(),
-	disableReasoningOnToolChoice: z.boolean().optional(),
-	thinkingFormat: z.enum(["openai", "openrouter", "zai", "qwen", "qwen-chat-template"]).optional(),
-	openRouterRouting: OpenRouterRoutingSchema.optional(),
-	vercelGatewayRouting: VercelGatewayRoutingSchema.optional(),
-	extraBody: z.record(z.string(), z.unknown()).optional(),
-	cacheControlFormat: z.enum(["anthropic"]).optional(),
-	supportsStrictMode: z.boolean().optional(),
-	toolStrictMode: z.enum(["all_strict", "none"]).optional(),
-	streamIdleTimeoutMs: z.number().nonnegative().optional(),
-	supportsLongPromptCacheRetention: z.boolean().optional(),
-	supportsReasoningParams: z.boolean().optional(),
-	alwaysSendMaxTokens: z.boolean().optional(),
-	strictResponsesPairing: z.boolean().optional(),
+const OpenAICompatFields = {
+	"supportsStore?": "boolean",
+	"supportsDeveloperRole?": "boolean",
+	"supportsMultipleSystemMessages?": "boolean",
+	"supportsReasoningEffort?": "boolean",
+	"reasoningEffortMap?": ReasoningEffortMapSchema,
+	"maxTokensField?": '"max_completion_tokens" | "max_tokens"',
+	"supportsUsageInStreaming?": "boolean",
+	"requiresToolResultName?": "boolean",
+	"requiresMistralToolIds?": "boolean",
+	"requiresAssistantAfterToolResult?": "boolean",
+	"requiresThinkingAsText?": "boolean",
+	"reasoningContentField?": '"reasoning_content" | "reasoning" | "reasoning_text"',
+	"requiresReasoningContentForToolCalls?": "boolean",
+	"allowsSyntheticReasoningContentForToolCalls?": "boolean",
+	"requiresAssistantContentForToolCalls?": "boolean",
+	"supportsToolChoice?": "boolean",
+	"supportsForcedToolChoice?": "boolean",
+	"disableReasoningOnForcedToolChoice?": "boolean",
+	"disableReasoningOnToolChoice?": "boolean",
+	"thinkingFormat?": '"openai" | "openrouter" | "zai" | "qwen" | "qwen-chat-template"',
+	"openRouterRouting?": OpenRouterRoutingSchema,
+	"vercelGatewayRouting?": VercelGatewayRoutingSchema,
+	"extraBody?": { "[string]": "unknown" },
+	"cacheControlFormat?": '"anthropic"',
+	"supportsStrictMode?": "boolean",
+	"toolStrictMode?": '"all_strict" | "none"',
+	"streamIdleTimeoutMs?": "number >= 0",
+	"supportsLongPromptCacheRetention?": "boolean",
+	"supportsReasoningParams?": "boolean",
+	"alwaysSendMaxTokens?": "boolean",
+	"strictResponsesPairing?": "boolean",
 	// anthropic-messages compat flags (same `compat` slot, per-api interpretation)
-	requiresToolResultId: z.boolean().optional(),
-	replayUnsignedThinking: z.boolean().optional(),
-});
+	"requiresToolResultId?": "boolean",
+	"replayUnsignedThinking?": "boolean",
+} as const;
+
+const OpenAICompatFieldsSchema = type(OpenAICompatFields);
 
-export const OpenAICompatSchema = OpenAICompatFieldsSchema.extend({
-	whenThinking: OpenAICompatFieldsSchema.optional(),
+export const OpenAICompatSchema = type({
+	...OpenAICompatFields,
+	"whenThinking?": OpenAICompatFieldsSchema,
 });
 
-const EffortSchema = z.enum(["minimal", "low", "medium", "high", "xhigh"]);
+const EffortSchema = type('"minimal" | "low" | "medium" | "high" | "xhigh"');
 
-const ThinkingControlModeSchema = z.enum([
-	"effort",
-	"budget",
-	"google-level",
-	"anthropic-adaptive",
-	"anthropic-budget-effort",
-]);
+const ThinkingControlModeSchema = type(
+	'"effort" | "budget" | "google-level" | "anthropic-adaptive" | "anthropic-budget-effort"',
+);
 
 const EFFORT_ORDER = ["minimal", "low", "medium", "high", "xhigh"] as const;
 
@@ -77,137 +76,141 @@ const EFFORT_ORDER = ["minimal", "low", "medium", "high", "xhigh"] as const;
  * `ThinkingConfig` (ordered `efforts`, never empty). Precedence mirrors the
  * old runtime: explicit `levels` beat the min..max range; `efforts` beats both.
  */
-const ModelThinkingSchema = z
-	.object({
-		mode: ThinkingControlModeSchema,
-		efforts: z.array(EffortSchema).min(1).optional(),
-		defaultLevel: EffortSchema.optional(),
-		effortMap: ReasoningEffortMapSchema.optional(),
-		supportsDisplay: z.boolean().optional(),
-		// Legacy range vocabulary (pre-efforts configs).
-		minLevel: EffortSchema.optional(),
-		maxLevel: EffortSchema.optional(),
-		levels: z.array(EffortSchema).min(1).optional(),
-	})
-	.refine(
-		value =>
+const ModelThinkingSchema = type({
+	mode: ThinkingControlModeSchema,
+	"efforts?": EffortSchema.array(),
+	"defaultLevel?": EffortSchema,
+	"effortMap?": ReasoningEffortMapSchema,
+	"supportsDisplay?": "boolean",
+	// Legacy range vocabulary (pre-efforts configs).
+	"minLevel?": EffortSchema,
+	"maxLevel?": EffortSchema,
+	"levels?": EffortSchema.array(),
+})
+	.narrow(
+		(value, ctx) =>
 			value.efforts !== undefined ||
 			value.levels !== undefined ||
-			(value.minLevel !== undefined && value.maxLevel !== undefined),
-		{
-			message: "thinking requires `efforts` (or legacy `levels`/`minLevel`+`maxLevel`)",
-		},
+			(value.minLevel !== undefined && value.maxLevel !== undefined) ||
+			ctx.mustBe("thinking with `efforts` (or legacy `levels`/`minLevel`+`maxLevel`)"),
 	)
-	.transform(({ efforts, levels, minLevel, maxLevel, mode, defaultLevel, effortMap, supportsDisplay }) => {
-		let resolved = efforts ?? levels;
+	.pipe((value: any) => {
+		let resolved = value.efforts ?? value.levels;
 		if (!resolved) {
-			const minIndex = EFFORT_ORDER.indexOf(minLevel!);
-			const maxIndex = EFFORT_ORDER.indexOf(maxLevel!);
+			const minIndex = EFFORT_ORDER.indexOf(value.minLevel!);
+			const maxIndex = EFFORT_ORDER.indexOf(value.maxLevel!);
 			resolved = EFFORT_ORDER.slice(minIndex, Math.max(minIndex, maxIndex) + 1);
 		}
 		return {
-			mode,
+			mode: value.mode,
 			efforts: resolved,
-			...(defaultLevel !== undefined && { defaultLevel }),
-			...(effortMap !== undefined && { effortMap }),
-			...(supportsDisplay !== undefined && { supportsDisplay }),
+			...(value.defaultLevel !== undefined && { defaultLevel: value.defaultLevel }),
+			...(value.effortMap !== undefined && { effortMap: value.effortMap }),
+			...(value.supportsDisplay !== undefined && { supportsDisplay: value.supportsDisplay }),
 		};
 	});
 
-const ModelDefinitionSchema = z.object({
-	id: z.string().min(1),
-	name: z.string().min(1).optional(),
-	api: z
-		.enum([
-			"openai-completions",
-			"openai-responses",
-			"openai-codex-responses",
-			"azure-openai-responses",
-			"anthropic-messages",
-			"google-generative-ai",
-			"google-gemini-cli",
-			"google-vertex",
-		])
-		.optional(),
-	baseUrl: z.string().min(1).optional(),
-	reasoning: z.boolean().optional(),
-	thinking: ModelThinkingSchema.optional(),
-	input: z.array(z.enum(["text", "image"])).optional(),
-	supportsTools: z.boolean().optional(),
-	cost: z
-		.object({
-			input: z.number(),
-			output: z.number(),
-			cacheRead: z.number(),
-			cacheWrite: z.number(),
-		})
-		.optional(),
-	premiumMultiplier: z.number().optional(),
-	contextWindow: z.number().optional(),
-	maxTokens: z.number().optional(),
-	omitMaxOutputTokens: z.boolean().optional(),
-	headers: z.record(z.string(), z.string()).optional(),
-	compat: OpenAICompatSchema.optional(),
-	contextPromotionTarget: z.string().min(1).optional(),
+const ModelDefinitionSchema = type({
+	id: "string",
+	"name?": "string",
+	"api?":
+		'"openai-completions" | "openai-responses" | "openai-codex-responses" | "azure-openai-responses" | "anthropic-messages" | "google-generative-ai" | "google-gemini-cli" | "google-vertex"',
+	"baseUrl?": "string",
+	"reasoning?": "boolean",
+	"thinking?": ModelThinkingSchema,
+	"input?": '("text" | "image")[]',
+	"supportsTools?": "boolean",
+	"cost?": {
+		input: "number",
+		output: "number",
+		cacheRead: "number",
+		cacheWrite: "number",
+	},
+	"premiumMultiplier?": "number",
+	"contextWindow?": "number",
+	"maxTokens?": "number",
+	"omitMaxOutputTokens?": "boolean",
+	"headers?": { "[string]": "string" },
+	"compat?": OpenAICompatSchema,
+	"contextPromotionTarget?": "string",
+}).narrow((value, ctx) => {
+	// Enforce id non-empty
+	if (typeof value.id === "string" && value.id.length === 0) {
+		return ctx.mustBe("id a non-empty string");
+	}
+	if (value.name !== undefined && typeof value.name === "string" && value.name.length === 0) {
+		return ctx.mustBe("name a non-empty string");
+	}
+	if (value.baseUrl !== undefined && typeof value.baseUrl === "string" && value.baseUrl.length === 0) {
+		return ctx.mustBe("baseUrl a non-empty string");
+	}
+	if (
+		value.contextPromotionTarget !== undefined &&
+		typeof value.contextPromotionTarget === "string" &&
+		value.contextPromotionTarget.length === 0
+	) {
+		return ctx.mustBe("contextPromotionTarget a non-empty string");
+	}
+	return true;
 });
 
-export const ModelOverrideSchema = z.object({
-	name: z.string().min(1).optional(),
-	reasoning: z.boolean().optional(),
-	thinking: ModelThinkingSchema.optional(),
-	input: z.array(z.enum(["text", "image"])).optional(),
-	supportsTools: z.boolean().optional(),
-	cost: z
-		.object({
-			input: z.number().optional(),
-			output: z.number().optional(),
-			cacheRead: z.number().optional(),
-			cacheWrite: z.number().optional(),
-		})
-		.optional(),
-	premiumMultiplier: z.number().optional(),
-	contextWindow: z.number().optional(),
-	maxTokens: z.number().optional(),
-	omitMaxOutputTokens: z.boolean().optional(),
-	headers: z.record(z.string(), z.string()).optional(),
-	compat: OpenAICompatSchema.optional(),
-	contextPromotionTarget: z.string().min(1).optional(),
+export const ModelOverrideSchema = type({
+	"name?": "string",
+	"reasoning?": "boolean",
+	"thinking?": ModelThinkingSchema,
+	"input?": '("text" | "image")[]',
+	"supportsTools?": "boolean",
+	"cost?": {
+		"input?": "number",
+		"output?": "number",
+		"cacheRead?": "number",
+		"cacheWrite?": "number",
+	},
+	"premiumMultiplier?": "number",
+	"contextWindow?": "number",
+	"maxTokens?": "number",
+	"omitMaxOutputTokens?": "boolean",
+	"headers?": { "[string]": "string" },
+	"compat?": OpenAICompatSchema,
+	"contextPromotionTarget?": "string",
+}).narrow((value, ctx) => {
+	if (value.name !== undefined && typeof value.name === "string" && value.name.length === 0) {
+		return ctx.mustBe("name a non-empty string");
+	}
+	if (
+		value.contextPromotionTarget !== undefined &&
+		typeof value.contextPromotionTarget === "string" &&
+		value.contextPromotionTarget.length === 0
+	) {
+		return ctx.mustBe("contextPromotionTarget a non-empty string");
+	}
+	return true;
 });
 
-export type ModelOverride = z.infer<typeof ModelOverrideSchema>;
+export type ModelOverride = typeof ModelOverrideSchema.infer;
 
-export const ProviderDiscoverySchema = z.object({
-	type: z.enum(["ollama", "llama.cpp", "lm-studio", "openai-models-list", "proxy"]),
+export const ProviderDiscoverySchema = type({
+	type: '"ollama" | "llama.cpp" | "lm-studio" | "openai-models-list" | "proxy"',
 });
 
-export const ProviderAuthSchema = z.enum(["apiKey", "none", "oauth"]);
-
-export type ProviderAuthMode = z.infer<typeof ProviderAuthSchema>;
-export type ProviderDiscovery = z.infer<typeof ProviderDiscoverySchema>;
-
-const ProviderConfigSchema = z.object({
-	baseUrl: z.string().min(1).optional(),
-	apiKey: z.string().min(1).optional(),
-	api: z
-		.enum([
-			"openai-completions",
-			"openai-responses",
-			"openai-codex-responses",
-			"azure-openai-responses",
-			"anthropic-messages",
-			"google-generative-ai",
-			"google-gemini-cli",
-			"google-vertex",
-		])
-		.optional(),
-	headers: z.record(z.string(), z.string()).optional(),
-	compat: OpenAICompatSchema.optional(),
-	authHeader: z.boolean().optional(),
-	auth: ProviderAuthSchema.optional(),
-	discovery: ProviderDiscoverySchema.optional(),
-	models: z.array(ModelDefinitionSchema).optional(),
-	modelOverrides: z.record(z.string(), ModelOverrideSchema).optional(),
-	disableStrictTools: z.boolean().optional(),
+export const ProviderAuthSchema = type('"apiKey" | "none" | "oauth"');
+
+export type ProviderAuthMode = typeof ProviderAuthSchema.infer;
+export type ProviderDiscovery = typeof ProviderDiscoverySchema.infer;
+
+const ProviderConfigSchema = type({
+	"baseUrl?": "string",
+	"apiKey?": "string",
+	"api?":
+		'"openai-completions" | "openai-responses" | "openai-codex-responses" | "azure-openai-responses" | "anthropic-messages" | "google-generative-ai" | "google-gemini-cli" | "google-vertex"',
+	"headers?": { "[string]": "string" },
+	"compat?": OpenAICompatSchema,
+	"authHeader?": "boolean",
+	"auth?": ProviderAuthSchema,
+	"discovery?": ProviderDiscoverySchema,
+	"models?": ModelDefinitionSchema.array(),
+	"modelOverrides?": { "[string]": ModelOverrideSchema },
+	"disableStrictTools?": "boolean",
 	/**
 	 * Streaming transport override. When set to `"pi-native"`, omp dispatches
 	 * every model under this provider via the auth-gateway's
@@ -215,17 +218,41 @@ const ProviderConfigSchema = z.object({
 	 * provider's `baseUrl` must point at a compatible `omp auth-gateway`
 	 * and `apiKey` must carry the gateway bearer.
 	 */
-	transport: z.literal("pi-native").optional(),
+	"transport?": '"pi-native"',
+}).narrow((value, ctx) => {
+	if (value.baseUrl !== undefined && typeof value.baseUrl === "string" && value.baseUrl.length === 0) {
+		return ctx.mustBe("baseUrl a non-empty string");
+	}
+	if (value.apiKey !== undefined && typeof value.apiKey === "string" && value.apiKey.length === 0) {
+		return ctx.mustBe("apiKey a non-empty string");
+	}
+	return true;
 });
 
-const EquivalenceConfigSchema = z.object({
-	overrides: z.record(z.string(), z.string().min(1)).optional(),
-	exclude: z.array(z.string().min(1)).optional(),
+const EquivalenceConfigSchema = type({
+	"overrides?": { "[string]": "string" },
+	"exclude?": "string[]",
+}).narrow((value, ctx) => {
+	if (value.overrides !== undefined) {
+		for (const [, v] of Object.entries(value.overrides)) {
+			if (typeof v === "string" && v.length === 0) {
+				return ctx.mustBe("overrides values non-empty strings");
+			}
+		}
+	}
+	if (value.exclude !== undefined && Array.isArray(value.exclude)) {
+		for (const item of value.exclude) {
+			if (typeof item === "string" && item.length === 0) {
+				return ctx.mustBe("exclude items non-empty strings");
+			}
+		}
+	}
+	return true;
 });
 
-export const ModelsConfigSchema = z.object({
-	providers: z.record(z.string(), ProviderConfigSchema).optional(),
-	equivalence: EquivalenceConfigSchema.optional(),
+export const ModelsConfigSchema = type({
+	"providers?": { "[string]": ProviderConfigSchema },
+	"equivalence?": EquivalenceConfigSchema,
 });
 
-export type ModelsConfig = z.infer<typeof ModelsConfigSchema>;
+export type ModelsConfig = typeof ModelsConfigSchema.infer;