@oh-my-pi/pi-coding-agent 15.0.2 → 15.1.1

package/src/config/model-registry.ts

@@ -30,7 +30,6 @@ const DEFAULT_LOCAL_TOKEN = "lm-studio-local";
 import { registerOAuthProvider, unregisterOAuthProviders } from "@oh-my-pi/pi-ai/utils/oauth";
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/utils/oauth/types";
 import { isRecord, logger } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
 import { parseModelString, resolveProviderModelReference } from "../config/model-resolver";
 import { isValidThemeColor, type ThemeColor } from "../modes/theme/theme";
 import type { AuthStorage, OAuthCredential } from "../session/auth-storage";
@@ -43,6 +42,13 @@ import {
 	formatCanonicalVariantSelector,
 	type ModelEquivalenceConfig,
 } from "./model-equivalence";
+import {
+	type ModelOverride,
+	type ModelsConfig,
+	ModelsConfigSchema,
+	type ProviderAuthMode,
+	type ProviderDiscovery,
+} from "./models-config-schema";
 import { type Settings, settings } from "./settings";
 
 export type { CanonicalModelIndex, CanonicalModelRecord, CanonicalModelVariant, ModelEquivalenceConfig };
@@ -121,194 +127,6 @@ export function getRoleInfo(role: string, settings: Settings): RoleInfo {
 	return { name: role, color: "muted" };
 }
 
-const OpenRouterRoutingSchema = Type.Object({
-	only: Type.Optional(Type.Array(Type.String())),
-	order: Type.Optional(Type.Array(Type.String())),
-});
-
-// Schema for Vercel AI Gateway routing preferences
-const VercelGatewayRoutingSchema = Type.Object({
-	only: Type.Optional(Type.Array(Type.String())),
-	order: Type.Optional(Type.Array(Type.String())),
-});
-
-// Schema for OpenAI compatibility settings
-const ReasoningEffortMapSchema = Type.Object({
-	minimal: Type.Optional(Type.String()),
-	low: Type.Optional(Type.String()),
-	medium: Type.Optional(Type.String()),
-	high: Type.Optional(Type.String()),
-	xhigh: Type.Optional(Type.String()),
-});
-
-const OpenAICompatSchema = Type.Object({
-	supportsStore: Type.Optional(Type.Boolean()),
-	supportsDeveloperRole: Type.Optional(Type.Boolean()),
-	supportsReasoningEffort: Type.Optional(Type.Boolean()),
-	reasoningEffortMap: Type.Optional(ReasoningEffortMapSchema),
-	maxTokensField: Type.Optional(Type.Union([Type.Literal("max_completion_tokens"), Type.Literal("max_tokens")])),
-	supportsUsageInStreaming: Type.Optional(Type.Boolean()),
-	requiresToolResultName: Type.Optional(Type.Boolean()),
-	requiresMistralToolIds: Type.Optional(Type.Boolean()),
-	requiresAssistantAfterToolResult: Type.Optional(Type.Boolean()),
-	requiresThinkingAsText: Type.Optional(Type.Boolean()),
-	reasoningContentField: Type.Optional(
-		Type.Union([Type.Literal("reasoning_content"), Type.Literal("reasoning"), Type.Literal("reasoning_text")]),
-	),
-	requiresReasoningContentForToolCalls: Type.Optional(Type.Boolean()),
-	requiresAssistantContentForToolCalls: Type.Optional(Type.Boolean()),
-	supportsToolChoice: Type.Optional(Type.Boolean()),
-	disableReasoningOnForcedToolChoice: Type.Optional(Type.Boolean()),
-	thinkingFormat: Type.Optional(
-		Type.Union([
-			Type.Literal("openai"),
-			Type.Literal("openrouter"),
-			Type.Literal("zai"),
-			Type.Literal("qwen"),
-			Type.Literal("qwen-chat-template"),
-		]),
-	),
-	openRouterRouting: Type.Optional(OpenRouterRoutingSchema),
-	vercelGatewayRouting: Type.Optional(VercelGatewayRoutingSchema),
-	extraBody: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
-	supportsStrictMode: Type.Optional(Type.Boolean()),
-	toolStrictMode: Type.Optional(Type.Union([Type.Literal("all_strict"), Type.Literal("none")])),
-});
-
-const EffortSchema = Type.Union([
-	Type.Literal("minimal"),
-	Type.Literal("low"),
-	Type.Literal("medium"),
-	Type.Literal("high"),
-	Type.Literal("xhigh"),
-]);
-
-const ThinkingControlModeSchema = Type.Union([
-	Type.Literal("effort"),
-	Type.Literal("budget"),
-	Type.Literal("google-level"),
-	Type.Literal("anthropic-adaptive"),
-	Type.Literal("anthropic-budget-effort"),
-]);
-
-const ModelThinkingSchema = Type.Object({
-	minLevel: EffortSchema,
-	maxLevel: EffortSchema,
-	mode: ThinkingControlModeSchema,
-	defaultLevel: Type.Optional(EffortSchema),
-});
-
-// Schema for custom model definition
-// Most fields are optional with sensible defaults for local models (Ollama, LM Studio, etc.)
-const ModelDefinitionSchema = Type.Object({
-	id: Type.String({ minLength: 1 }),
-	name: Type.Optional(Type.String({ minLength: 1 })),
-	api: Type.Optional(
-		Type.Union([
-			Type.Literal("openai-completions"),
-			Type.Literal("openai-responses"),
-			Type.Literal("openai-codex-responses"),
-			Type.Literal("azure-openai-responses"),
-			Type.Literal("anthropic-messages"),
-			Type.Literal("google-generative-ai"),
-			Type.Literal("google-vertex"),
-		]),
-	),
-	baseUrl: Type.Optional(Type.String({ minLength: 1 })),
-	reasoning: Type.Optional(Type.Boolean()),
-	thinking: Type.Optional(ModelThinkingSchema),
-	input: Type.Optional(Type.Array(Type.Union([Type.Literal("text"), Type.Literal("image")]))),
-	cost: Type.Optional(
-		Type.Object({
-			input: Type.Number(),
-			output: Type.Number(),
-			cacheRead: Type.Number(),
-			cacheWrite: Type.Number(),
-		}),
-	),
-	premiumMultiplier: Type.Optional(Type.Number()),
-	contextWindow: Type.Optional(Type.Number()),
-	maxTokens: Type.Optional(Type.Number()),
-	headers: Type.Optional(Type.Record(Type.String(), Type.String())),
-	compat: Type.Optional(OpenAICompatSchema),
-	contextPromotionTarget: Type.Optional(Type.String({ minLength: 1 })),
-});
-
-// Schema for per-model overrides (all fields optional, merged with built-in model)
-const ModelOverrideSchema = Type.Object({
-	name: Type.Optional(Type.String({ minLength: 1 })),
-	reasoning: Type.Optional(Type.Boolean()),
-	thinking: Type.Optional(ModelThinkingSchema),
-	input: Type.Optional(Type.Array(Type.Union([Type.Literal("text"), Type.Literal("image")]))),
-	cost: Type.Optional(
-		Type.Object({
-			input: Type.Optional(Type.Number()),
-			output: Type.Optional(Type.Number()),
-			cacheRead: Type.Optional(Type.Number()),
-			cacheWrite: Type.Optional(Type.Number()),
-		}),
-	),
-	premiumMultiplier: Type.Optional(Type.Number()),
-	contextWindow: Type.Optional(Type.Number()),
-	maxTokens: Type.Optional(Type.Number()),
-	headers: Type.Optional(Type.Record(Type.String(), Type.String())),
-	compat: Type.Optional(OpenAICompatSchema),
-	contextPromotionTarget: Type.Optional(Type.String({ minLength: 1 })),
-});
-
-type ModelOverride = Static<typeof ModelOverrideSchema>;
-
-const ProviderDiscoverySchema = Type.Object({
-	type: Type.Union([
-		Type.Literal("ollama"),
-		Type.Literal("llama.cpp"),
-		Type.Literal("lm-studio"),
-		Type.Literal("openai-models-list"),
-	]),
-});
-
-const ProviderAuthSchema = Type.Union([Type.Literal("apiKey"), Type.Literal("none"), Type.Literal("oauth")]);
-
-const ProviderConfigSchema = Type.Object({
-	baseUrl: Type.Optional(Type.String({ minLength: 1 })),
-	apiKey: Type.Optional(Type.String({ minLength: 1 })),
-	api: Type.Optional(
-		Type.Union([
-			Type.Literal("openai-completions"),
-			Type.Literal("openai-responses"),
-			Type.Literal("openai-codex-responses"),
-			Type.Literal("azure-openai-responses"),
-			Type.Literal("anthropic-messages"),
-			Type.Literal("google-generative-ai"),
-			Type.Literal("google-vertex"),
-		]),
-	),
-	headers: Type.Optional(Type.Record(Type.String(), Type.String())),
-	compat: Type.Optional(OpenAICompatSchema),
-	authHeader: Type.Optional(Type.Boolean()),
-	auth: Type.Optional(ProviderAuthSchema),
-	discovery: Type.Optional(ProviderDiscoverySchema),
-	models: Type.Optional(Type.Array(ModelDefinitionSchema)),
-	modelOverrides: Type.Optional(Type.Record(Type.String(), ModelOverrideSchema)),
-	/** When true, disables strict tool schemas for this provider (for third-party Anthropic-compatible endpoints that reject the strict field). */
-	disableStrictTools: Type.Optional(Type.Boolean()),
-});
-
-const EquivalenceConfigSchema = Type.Object({
-	overrides: Type.Optional(Type.Record(Type.String(), Type.String({ minLength: 1 }))),
-	exclude: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
-});
-
-const ModelsConfigSchema = Type.Object({
-	providers: Type.Optional(Type.Record(Type.String(), ProviderConfigSchema)),
-	equivalence: Type.Optional(EquivalenceConfigSchema),
-});
-
-type ModelsConfig = Static<typeof ModelsConfigSchema>;
-
-type ProviderAuthMode = Static<typeof ProviderAuthSchema>;
-type ProviderDiscovery = Static<typeof ProviderDiscoverySchema>;
-
 type ProviderValidationMode = "models-config" | "runtime-register";
 
 interface ProviderValidationModel {
@@ -347,12 +165,13 @@ function validateProviderConfiguration(
 				!config.baseUrl &&
 				!config.headers &&
 				!config.compat &&
+				!config.apiKey &&
 				!config.disableStrictTools &&
 				!hasModelOverrides &&
 				!config.discovery
 			) {
 				throw new Error(
-					`Provider ${providerName}: must specify "baseUrl", "headers", "compat", "disableStrictTools", "modelOverrides", "discovery", or "models"`,
+					`Provider ${providerName}: must specify "baseUrl", "headers", "apiKey", "compat", "disableStrictTools", "modelOverrides", "discovery", or "models"`,
 				);
 			}
 		}

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

@@ -0,0 +1,166 @@
+import * as z from "zod/v4";
+
+const OpenRouterRoutingSchema = z.object({
+	only: z.array(z.string()).optional(),
+	order: z.array(z.string()).optional(),
+});
+
+const VercelGatewayRoutingSchema = z.object({
+	only: z.array(z.string()).optional(),
+	order: z.array(z.string()).optional(),
+});
+
+const ReasoningEffortMapSchema = z.object({
+	minimal: z.string().optional(),
+	low: z.string().optional(),
+	medium: z.string().optional(),
+	high: z.string().optional(),
+	xhigh: z.string().optional(),
+});
+
+export const OpenAICompatSchema = 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(),
+	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(),
+	supportsStrictMode: z.boolean().optional(),
+	toolStrictMode: z.enum(["all_strict", "none"]).optional(),
+});
+
+const EffortSchema = z.enum(["minimal", "low", "medium", "high", "xhigh"]);
+
+const ThinkingControlModeSchema = z.enum([
+	"effort",
+	"budget",
+	"google-level",
+	"anthropic-adaptive",
+	"anthropic-budget-effort",
+]);
+
+const ModelThinkingSchema = z.object({
+	minLevel: EffortSchema,
+	maxLevel: EffortSchema,
+	mode: ThinkingControlModeSchema,
+	defaultLevel: EffortSchema.optional(),
+	levels: z.array(EffortSchema).optional(),
+});
+
+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-vertex",
+		])
+		.optional(),
+	baseUrl: z.string().min(1).optional(),
+	reasoning: z.boolean().optional(),
+	thinking: ModelThinkingSchema.optional(),
+	input: z.array(z.enum(["text", "image"])).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(),
+	headers: z.record(z.string(), z.string()).optional(),
+	compat: OpenAICompatSchema.optional(),
+	contextPromotionTarget: z.string().min(1).optional(),
+});
+
+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(),
+	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(),
+	headers: z.record(z.string(), z.string()).optional(),
+	compat: OpenAICompatSchema.optional(),
+	contextPromotionTarget: z.string().min(1).optional(),
+});
+
+export type ModelOverride = z.infer<typeof ModelOverrideSchema>;
+
+export const ProviderDiscoverySchema = z.object({
+	type: z.enum(["ollama", "llama.cpp", "lm-studio", "openai-models-list"]),
+});
+
+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-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(),
+});
+
+const EquivalenceConfigSchema = z.object({
+	overrides: z.record(z.string(), z.string().min(1)).optional(),
+	exclude: z.array(z.string().min(1)).optional(),
+});
+
+export const ModelsConfigSchema = z.object({
+	providers: z.record(z.string(), ProviderConfigSchema).optional(),
+	equivalence: EquivalenceConfigSchema.optional(),
+});
+
+export type ModelsConfig = z.infer<typeof ModelsConfigSchema>;

package/src/config/settings-schema.ts

@@ -2329,6 +2329,24 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"task.maxRuntimeMs": {
+		type: "number",
+		default: 0,
+		ui: {
+			tab: "tasks",
+			label: "Max Subagent Runtime",
+			description:
+				"Hard wall-clock limit per subagent (ms). 0 disables it. Defense-in-depth against provider-side stream hangs that escape the inference-layer watchdog; triggers a normal subagent abort with a 'timed out' reason.",
+			options: [
+				{ value: "0", label: "Unlimited", description: "Default" },
+				{ value: "300000", label: "5 minutes" },
+				{ value: "900000", label: "15 minutes" },
+				{ value: "1800000", label: "30 minutes" },
+				{ value: "3600000", label: "1 hour" },
+			],
+		},
+	},
+
 	"task.disabledAgents": {
 		type: "array",
 		default: [] as string[],

package/src/edit/index.ts

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { prompt } from "@oh-my-pi/pi-utils";
-import type { Static } from "@sinclair/typebox";
+import type * as z from "zod/v4";
 import {
 	executeHashlineSingle,
 	HashlineMismatchError,
@@ -53,7 +53,7 @@ type TInput =
 	| typeof vimSchema
 	| typeof applyPatchSchema;
 
-type VimParams = Static<typeof vimSchema>;
+type VimParams = z.infer<typeof vimSchema>;
 type EditParams = ReplaceParams | PatchParams | HashlineParams | VimParams | ApplyPatchParams;
 type EditToolResultDetails = EditToolDetails | VimToolDetails;
 

package/src/edit/modes/apply-patch.ts

@@ -8,19 +8,20 @@
  * the `patch` mode.
  */
 
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import { parseApplyPatch, parseApplyPatchStreaming } from "../apply-patch/parser";
 import { ApplyPatchError } from "../diff";
 import type { PatchEditEntry } from "./patch";
 
-export const applyPatchSchema = Type.Object({
-	input: Type.String({
-		description:
+export const applyPatchSchema = z.object({
+	input: z
+		.string()
+		.describe(
 			"Full Codex apply_patch envelope, including '*** Begin Patch' and '*** End Patch'. Contains any mix of Add/Delete/Update (with optional Move to) file operations.",
-	}),
+		),
 });
 
-export type ApplyPatchParams = Static<typeof applyPatchSchema>;
+export type ApplyPatchParams = z.infer<typeof applyPatchSchema>;
 
 export type ApplyPatchEntry = PatchEditEntry & { path: string };
 

package/src/edit/modes/patch.ts

@@ -8,9 +8,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { StringEnum } from "@oh-my-pi/pi-ai";
 import { isEnoent } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import {
 	type FileDiagnosticsResult,
 	flushLspWritethroughBatch,
@@ -1577,29 +1576,23 @@ export async function computePatchDiff(
 	}
 }
 
-export const patchEditEntrySchema = Type.Object(
-	{
-		op: Type.Optional(
-			StringEnum(["create", "delete", "update"], {
-				description: "Operation (default: update)",
-			}),
-		),
-		rename: Type.Optional(Type.String({ description: "New path for move" })),
-		diff: Type.Optional(Type.String({ description: "Diff hunks (update) or full content (create)" })),
-	},
-	{ additionalProperties: false },
-);
-
-export const patchEditSchema = Type.Object(
-	{
-		path: Type.String({ description: "file path for edits" }),
-		edits: Type.Array(patchEditEntrySchema, { description: "Patch operations", minItems: 1 }),
-	},
-	{ additionalProperties: false },
-);
-
-export type PatchEditEntry = Static<typeof patchEditEntrySchema>;
-export type PatchParams = Static<typeof patchEditSchema>;
+export const patchEditEntrySchema = z
+	.object({
+		op: z.enum(["create", "delete", "update"]).optional().describe("Operation (default: update)"),
+		rename: z.string().describe("New path for move").optional(),
+		diff: z.string().describe("Diff hunks (update) or full content (create)").optional(),
+	})
+	.strict();
+
+export const patchEditSchema = z
+	.object({
+		path: z.string().describe("file path for edits"),
+		edits: z.array(patchEditEntrySchema).min(1).describe("Patch operations"),
+	})
+	.strict();
+
+export type PatchEditEntry = z.infer<typeof patchEditEntrySchema>;
+export type PatchParams = z.infer<typeof patchEditSchema>;
 
 export interface ExecutePatchSingleOptions {
 	session: ToolSession;

package/src/edit/modes/replace.ts

@@ -5,7 +5,7 @@
  * fallback strategies for finding text in files.
  */
 import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import type { WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
 import type { ToolSession } from "../../tools";
 import { invalidateFsScanAfterWrite } from "../../tools/fs-cache-invalidation";
@@ -976,25 +976,23 @@ export function findContextLine(
 	return { index: undefined, confidence: bestScore };
 }
 
-export const replaceEditEntrySchema = Type.Object(
-	{
-		old_text: Type.String({ description: "Text to find (fuzzy whitespace matching enabled)" }),
-		new_text: Type.String({ description: "Replacement text" }),
-		all: Type.Optional(Type.Boolean({ description: "Replace all occurrences (default: unique match required)" })),
-	},
-	{ additionalProperties: false },
-);
-
-export const replaceEditSchema = Type.Object(
-	{
-		path: Type.String({ description: "file path for edits" }),
-		edits: Type.Array(replaceEditEntrySchema, { description: "Replacements", minItems: 1 }),
-	},
-	{ additionalProperties: false },
-);
-
-export type ReplaceEditEntry = Static<typeof replaceEditEntrySchema>;
-export type ReplaceParams = Static<typeof replaceEditSchema>;
+export const replaceEditEntrySchema = z
+	.object({
+		old_text: z.string().describe("Text to find (fuzzy whitespace matching enabled)"),
+		new_text: z.string().describe("Replacement text"),
+		all: z.boolean().describe("Replace all occurrences (default: unique match required)").optional(),
+	})
+	.strict();
+
+export const replaceEditSchema = z
+	.object({
+		path: z.string().describe("file path for edits"),
+		edits: z.array(replaceEditEntrySchema).min(1).describe("Replacements"),
+	})
+	.strict();
+
+export type ReplaceEditEntry = z.infer<typeof replaceEditEntrySchema>;
+export type ReplaceParams = z.infer<typeof replaceEditSchema>;
 
 export interface ExecuteReplaceSingleOptions {
 	session: ToolSession;