@oh-my-pi/pi-coding-agent 3.15.0 → 3.20.0

package/src/core/model-registry.ts

@@ -35,8 +35,10 @@ const ModelDefinitionSchema = Type.Object({
 		Type.Union([
 			Type.Literal("openai-completions"),
 			Type.Literal("openai-responses"),
+			Type.Literal("openai-codex-responses"),
 			Type.Literal("anthropic-messages"),
 			Type.Literal("google-generative-ai"),
+			Type.Literal("google-vertex"),
 		]),
 	),
 	reasoning: Type.Boolean(),
@@ -54,19 +56,21 @@ const ModelDefinitionSchema = Type.Object({
 });
 
 const ProviderConfigSchema = Type.Object({
-	baseUrl: Type.String({ minLength: 1 }),
-	apiKey: Type.String({ minLength: 1 }),
+	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("anthropic-messages"),
 			Type.Literal("google-generative-ai"),
+			Type.Literal("google-vertex"),
 		]),
 	),
 	headers: Type.Optional(Type.Record(Type.String(), Type.String())),
 	authHeader: Type.Optional(Type.Boolean()),
-	models: Type.Array(ModelDefinitionSchema),
+	models: Type.Optional(Type.Array(ModelDefinitionSchema)),
 });
 
 const ModelsConfigSchema = Type.Object({
@@ -75,6 +79,27 @@ const ModelsConfigSchema = Type.Object({
 
 type ModelsConfig = Static<typeof ModelsConfigSchema>;
 
+/** Provider override config (baseUrl, headers, apiKey) without custom models */
+interface ProviderOverride {
+	baseUrl?: string;
+	headers?: Record<string, string>;
+	apiKey?: string;
+}
+
+/** Result of loading custom models from models.json */
+interface CustomModelsResult {
+	models: Model<Api>[];
+	/** Providers with custom models (full replacement) */
+	replacedProviders: Set<string>;
+	/** Providers with only baseUrl/headers override (no custom models) */
+	overrides: Map<string, ProviderOverride>;
+	error: string | undefined;
+}
+
+function emptyCustomModelsResult(error?: string): CustomModelsResult {
+	return { models: [], replacedProviders: new Set(), overrides: new Map(), error };
+}
+
 /**
  * Resolve an API key config value to an actual key.
  * Checks environment variable first, then treats as literal.
@@ -111,8 +136,7 @@ export class ModelRegistry {
 			}
 			return undefined;
 		});
-
-		// Load models
+		// Load models synchronously in constructor
 		this.loadModels();
 	}
 
@@ -133,15 +157,10 @@ export class ModelRegistry {
 	}
 
 	private loadModels(): void {
-		// Load built-in models
-		const builtInModels: Model<Api>[] = [];
-		for (const provider of getProviders()) {
-			const providerModels = getModels(provider as KnownProvider);
-			builtInModels.push(...(providerModels as Model<Api>[]));
-		}
-
-		// Load custom models from models.json (check primary path, then fallbacks)
+		// Load custom models from models.json first (to know which providers to skip/override)
 		let customModels: Model<Api>[] = [];
+		let replacedProviders: Set<string> = new Set();
+		let overrides: Map<string, ProviderOverride> = new Map();
 		const pathsToCheck = this.modelsJsonPath ? [this.modelsJsonPath, ...this.fallbackPaths] : this.fallbackPaths;
 
 		if (pathsToCheck.length > 0) {
@@ -157,11 +176,14 @@ export class ModelRegistry {
 					// Keep built-in models even if custom models failed to load
 				} else {
 					customModels = result.models;
+					replacedProviders = result.replacedProviders;
+					overrides = result.overrides;
 				}
 				break; // Use first existing file
 			}
 		}
 
+		const builtInModels = this.loadBuiltInModels(replacedProviders, overrides);
 		const combined = [...builtInModels, ...customModels];
 
 		// Update github-copilot base URL based on OAuth credentials
@@ -177,9 +199,27 @@ export class ModelRegistry {
 		}
 	}
 
-	private loadCustomModels(modelsJsonPath: string): { models: Model<Api>[]; error: string | undefined } {
+	/** Load built-in models, skipping replaced providers and applying overrides */
+	private loadBuiltInModels(replacedProviders: Set<string>, overrides: Map<string, ProviderOverride>): Model<Api>[] {
+		return getProviders()
+			.filter((provider) => !replacedProviders.has(provider))
+			.flatMap((provider) => {
+				const models = getModels(provider as KnownProvider) as Model<Api>[];
+				const override = overrides.get(provider);
+				if (!override) return models;
+
+				// Apply baseUrl/headers override to all models of this provider
+				return models.map((m) => ({
+					...m,
+					baseUrl: override.baseUrl ?? m.baseUrl,
+					headers: override.headers ? { ...m.headers, ...override.headers } : m.headers,
+				}));
+			});
+	}
+
+	private loadCustomModels(modelsJsonPath: string): CustomModelsResult {
 		if (!existsSync(modelsJsonPath)) {
-			return { models: [], error: undefined };
+			return emptyCustomModelsResult();
 		}
 
 		try {
@@ -193,38 +233,68 @@ export class ModelRegistry {
 				const errors =
 					validate.errors?.map((e: any) => `  - ${e.instancePath || "root"}: ${e.message}`).join("\n") ||
 					"Unknown schema error";
-				return {
-					models: [],
-					error: `Invalid models.json schema:\n${errors}\n\nFile: ${modelsJsonPath}`,
-				};
+				return emptyCustomModelsResult(`Invalid models.json schema:\n${errors}\n\nFile: ${modelsJsonPath}`);
 			}
 
 			// Additional validation
 			this.validateConfig(config);
 
-			// Parse models
-			return { models: this.parseModels(config), error: undefined };
+			// Separate providers into "full replacement" (has models) vs "override-only" (no models)
+			const replacedProviders = new Set<string>();
+			const overrides = new Map<string, ProviderOverride>();
+
+			for (const [providerName, providerConfig] of Object.entries(config.providers)) {
+				if (providerConfig.models && providerConfig.models.length > 0) {
+					// Has custom models -> full replacement
+					replacedProviders.add(providerName);
+				} else {
+					// No models -> just override baseUrl/headers on built-in
+					overrides.set(providerName, {
+						baseUrl: providerConfig.baseUrl,
+						headers: providerConfig.headers,
+						apiKey: providerConfig.apiKey,
+					});
+					// Store API key for fallback resolver
+					if (providerConfig.apiKey) {
+						this.customProviderApiKeys.set(providerName, providerConfig.apiKey);
+					}
+				}
+			}
+
+			return { models: this.parseModels(config), replacedProviders, overrides, error: undefined };
 		} catch (error) {
 			if (error instanceof SyntaxError) {
-				return {
-					models: [],
-					error: `Failed to parse models.json: ${error.message}\n\nFile: ${modelsJsonPath}`,
-				};
+				return emptyCustomModelsResult(`Failed to parse models.json: ${error.message}\n\nFile: ${modelsJsonPath}`);
 			}
-			return {
-				models: [],
-				error: `Failed to load models.json: ${
-					error instanceof Error ? error.message : error
-				}\n\nFile: ${modelsJsonPath}`,
-			};
+			return emptyCustomModelsResult(
+				`Failed to load models.json: ${error instanceof Error ? error.message : error}\n\nFile: ${modelsJsonPath}`,
+			);
 		}
 	}
 
 	private validateConfig(config: ModelsConfig): void {
 		for (const [providerName, providerConfig] of Object.entries(config.providers)) {
 			const hasProviderApi = !!providerConfig.api;
+			const models = providerConfig.models ?? [];
+
+			if (models.length === 0) {
+				// Override-only config: just needs baseUrl (to override built-in)
+				if (!providerConfig.baseUrl) {
+					throw new Error(
+						`Provider ${providerName}: must specify either "baseUrl" (for override) or "models" (for replacement).`,
+					);
+				}
+			} else {
+				// Full replacement: needs baseUrl and apiKey
+				if (!providerConfig.baseUrl) {
+					throw new Error(`Provider ${providerName}: "baseUrl" is required when defining custom models.`);
+				}
+				if (!providerConfig.apiKey) {
+					throw new Error(`Provider ${providerName}: "apiKey" is required when defining custom models.`);
+				}
+			}
 
-			for (const modelDef of providerConfig.models) {
+			for (const modelDef of models) {
 				const hasModelApi = !!modelDef.api;
 
 				if (!hasProviderApi && !hasModelApi) {
@@ -247,10 +317,15 @@ export class ModelRegistry {
 		const models: Model<Api>[] = [];
 
 		for (const [providerName, providerConfig] of Object.entries(config.providers)) {
+			const modelDefs = providerConfig.models ?? [];
+			if (modelDefs.length === 0) continue; // Override-only, no custom models
+
 			// Store API key config for fallback resolver
-			this.customProviderApiKeys.set(providerName, providerConfig.apiKey);
+			if (providerConfig.apiKey) {
+				this.customProviderApiKeys.set(providerName, providerConfig.apiKey);
+			}
 
-			for (const modelDef of providerConfig.models) {
+			for (const modelDef of modelDefs) {
 				const api = modelDef.api || providerConfig.api;
 				if (!api) continue;
 
@@ -261,19 +336,20 @@ export class ModelRegistry {
 						: undefined;
 
 				// If authHeader is true, add Authorization header with resolved API key
-				if (providerConfig.authHeader) {
+				if (providerConfig.authHeader && providerConfig.apiKey) {
 					const resolvedKey = resolveApiKeyConfig(providerConfig.apiKey);
 					if (resolvedKey) {
 						headers = { ...headers, Authorization: `Bearer ${resolvedKey}` };
 					}
 				}
 
+				// baseUrl is validated to exist for providers with models
 				models.push({
 					id: modelDef.id,
 					name: modelDef.name,
 					api: api as Api,
 					provider: providerName,
-					baseUrl: providerConfig.baseUrl,
+					baseUrl: providerConfig.baseUrl!,
 					reasoning: modelDef.reasoning,
 					input: modelDef.input as ("text" | "image")[],
 					cost: modelDef.cost,
@@ -297,17 +373,11 @@ export class ModelRegistry {
 	}
 
 	/**
-	 * Get only models that have valid API keys available.
+	 * Get only models that have auth configured.
+	 * This is a fast check that doesn't refresh OAuth tokens.
 	 */
-	async getAvailable(): Promise<Model<Api>[]> {
-		const available: Model<Api>[] = [];
-		for (const model of this.models) {
-			const apiKey = await this.authStorage.getApiKey(model.provider);
-			if (apiKey) {
-				available.push(model);
-			}
-		}
-		return available;
+	getAvailable(): Model<Api>[] {
+		return this.models.filter((m) => this.authStorage.hasAuth(m.provider));
 	}
 
 	/**
@@ -324,6 +394,13 @@ export class ModelRegistry {
 		return this.authStorage.getApiKey(model.provider);
 	}
 
+	/**
+	 * Get API key for a provider (e.g., "openai").
+	 */
+	async getApiKeyForProvider(provider: string): Promise<string | undefined> {
+		return this.authStorage.getApiKey(provider);
+	}
+
 	/**
 	 * Check if a model is using OAuth credentials (subscription).
 	 */

package/src/core/model-resolver.ts

@@ -13,9 +13,11 @@ import type { ModelRegistry } from "./model-registry";
 export const defaultModelPerProvider: Record<KnownProvider, string> = {
 	anthropic: "claude-sonnet-4-5",
 	openai: "gpt-5.1-codex",
+	"openai-codex": "codex-max",
 	google: "gemini-2.5-pro",
 	"google-gemini-cli": "gemini-2.5-pro",
 	"google-antigravity": "gemini-3-pro-high",
+	"google-vertex": "gemini-2.5-pro",
 	"github-copilot": "gpt-4o",
 	openrouter: "openai/gpt-5.1-codex",
 	xai: "grok-4-fast-non-reasoning",
@@ -192,7 +194,7 @@ export function parseModelPattern(pattern: string, availableModels: Model<Api>[]
  * strips colon-suffixes to find a match.
  */
 export async function resolveModelScope(patterns: string[], modelRegistry: ModelRegistry): Promise<ScopedModel[]> {
-	const availableModels = await modelRegistry.getAvailable();
+	const availableModels = modelRegistry.getAvailable();
 	const scopedModels: ScopedModel[] = [];
 
 	for (const pattern of patterns) {
@@ -321,7 +323,7 @@ export async function findInitialModel(options: {
 	}
 
 	// 4. Try first available model with valid API key
-	const availableModels = await modelRegistry.getAvailable();
+	const availableModels = modelRegistry.getAvailable();
 
 	if (availableModels.length > 0) {
 		// Try to find a default model from known providers
@@ -382,7 +384,7 @@ export async function restoreModelFromSession(
 	}
 
 	// Try to find any available model
-	const availableModels = await modelRegistry.getAvailable();
+	const availableModels = modelRegistry.getAvailable();
 
 	if (availableModels.length > 0) {
 		// Try to find a default model from known providers
@@ -427,7 +429,7 @@ export async function findSmolModel(
 	modelRegistry: ModelRegistry,
 	savedModel?: string,
 ): Promise<Model<Api> | undefined> {
-	const availableModels = await modelRegistry.getAvailable();
+	const availableModels = modelRegistry.getAvailable();
 	if (availableModels.length === 0) return undefined;
 
 	// 1. Try saved model from settings
@@ -466,7 +468,7 @@ export async function findSlowModel(
 	modelRegistry: ModelRegistry,
 	savedModel?: string,
 ): Promise<Model<Api> | undefined> {
-	const availableModels = await modelRegistry.getAvailable();
+	const availableModels = modelRegistry.getAvailable();
 	if (availableModels.length === 0) return undefined;
 
 	// 1. Try saved model from settings

package/src/core/prompt-templates.ts

@@ -0,0 +1,242 @@
+import { join, resolve } from "node:path";
+import { CONFIG_DIR_NAME, getPromptsDir } from "../config";
+
+/**
+ * Represents a prompt template loaded from a markdown file
+ */
+export interface PromptTemplate {
+	name: string;
+	description: string;
+	content: string;
+	source: string; // e.g., "(user)", "(project)", "(project:frontend)"
+}
+
+/**
+ * Parse YAML frontmatter from markdown content
+ * Returns { frontmatter, content } where content has frontmatter stripped
+ */
+function parseFrontmatter(content: string): { frontmatter: Record<string, string>; content: string } {
+	const frontmatter: Record<string, string> = {};
+
+	if (!content.startsWith("---")) {
+		return { frontmatter, content };
+	}
+
+	const endIndex = content.indexOf("\n---", 3);
+	if (endIndex === -1) {
+		return { frontmatter, content };
+	}
+
+	const frontmatterBlock = content.slice(4, endIndex);
+	const remainingContent = content.slice(endIndex + 4).trim();
+
+	// Simple YAML parsing - just key: value pairs
+	for (const line of frontmatterBlock.split("\n")) {
+		const match = line.match(/^(\w+):\s*(.*)$/);
+		if (match) {
+			frontmatter[match[1]] = match[2].trim();
+		}
+	}
+
+	return { frontmatter, content: remainingContent };
+}
+
+/**
+ * Parse command arguments respecting quoted strings (bash-style)
+ * Returns array of arguments
+ */
+export function parseCommandArgs(argsString: string): string[] {
+	const args: string[] = [];
+	let current = "";
+	let inQuote: string | null = null;
+
+	for (let i = 0; i < argsString.length; i++) {
+		const char = argsString[i];
+
+		if (inQuote) {
+			if (char === inQuote) {
+				inQuote = null;
+			} else {
+				current += char;
+			}
+		} else if (char === '"' || char === "'") {
+			inQuote = char;
+		} else if (char === " " || char === "\t") {
+			if (current) {
+				args.push(current);
+				current = "";
+			}
+		} else {
+			current += char;
+		}
+	}
+
+	if (current) {
+		args.push(current);
+	}
+
+	return args;
+}
+
+/**
+ * Substitute argument placeholders in template content
+ * Supports $1, $2, ... for positional args, $@ and $ARGUMENTS for all args
+ *
+ * Note: Replacement happens on the template string only. Argument values
+ * containing patterns like $1, $@, or $ARGUMENTS are NOT recursively substituted.
+ */
+export function substituteArgs(content: string, args: string[]): string {
+	let result = content;
+
+	// Replace $1, $2, etc. with positional args FIRST (before wildcards)
+	// This prevents wildcard replacement values containing $<digit> patterns from being re-substituted
+	result = result.replace(/\$(\d+)/g, (_, num) => {
+		const index = parseInt(num, 10) - 1;
+		return args[index] ?? "";
+	});
+
+	// Pre-compute all args joined (optimization)
+	const allArgs = args.join(" ");
+
+	// Replace $ARGUMENTS with all args joined (new syntax, aligns with Claude, Codex, OpenCode)
+	result = result.replace(/\$ARGUMENTS/g, allArgs);
+
+	// Replace $@ with all args joined (existing syntax)
+	result = result.replace(/\$@/g, allArgs);
+
+	return result;
+}
+
+/**
+ * Recursively scan a directory for .md files (and symlinks to .md files) and load them as prompt templates
+ */
+async function loadTemplatesFromDir(
+	dir: string,
+	source: "user" | "project",
+	subdir: string = "",
+): Promise<PromptTemplate[]> {
+	const templates: PromptTemplate[] = [];
+
+	try {
+		const stat = await Bun.file(`${dir}/.`).exists();
+		if (!stat) return templates;
+	} catch {
+		return templates;
+	}
+
+	try {
+		const glob = new Bun.Glob("**/*");
+		const entries = [];
+		for await (const entry of glob.scan({ cwd: dir, absolute: false, onlyFiles: false })) {
+			entries.push(entry);
+		}
+
+		// Group by path depth to process directories before deeply nested files
+		entries.sort((a, b) => a.split("/").length - b.split("/").length);
+
+		for (const entry of entries) {
+			const fullPath = join(dir, entry);
+			const file = Bun.file(fullPath);
+
+			try {
+				const stat = await file.exists();
+				if (!stat) continue;
+
+				if (entry.endsWith(".md")) {
+					const rawContent = await file.text();
+					const { frontmatter, content } = parseFrontmatter(rawContent);
+
+					const name = entry.split("/").pop()!.slice(0, -3); // Remove .md extension
+
+					// Build source string based on subdirectory structure
+					const entryDir = entry.includes("/") ? entry.split("/").slice(0, -1).join(":") : "";
+					const fullSubdir = subdir && entryDir ? `${subdir}:${entryDir}` : entryDir || subdir;
+
+					let sourceStr: string;
+					if (source === "user") {
+						sourceStr = fullSubdir ? `(user:${fullSubdir})` : "(user)";
+					} else {
+						sourceStr = fullSubdir ? `(project:${fullSubdir})` : "(project)";
+					}
+
+					// Get description from frontmatter or first non-empty line
+					let description = frontmatter.description || "";
+					if (!description) {
+						const firstLine = content.split("\n").find((line) => line.trim());
+						if (firstLine) {
+							// Truncate if too long
+							description = firstLine.slice(0, 60);
+							if (firstLine.length > 60) description += "...";
+						}
+					}
+
+					// Append source to description
+					description = description ? `${description} ${sourceStr}` : sourceStr;
+
+					templates.push({
+						name,
+						description,
+						content,
+						source: sourceStr,
+					});
+				}
+			} catch (_error) {
+				// Silently skip files that can't be read
+			}
+		}
+	} catch (_error) {
+		// Silently skip directories that can't be read
+	}
+
+	return templates;
+}
+
+export interface LoadPromptTemplatesOptions {
+	/** Working directory for project-local templates. Default: process.cwd() */
+	cwd?: string;
+	/** Agent config directory for global templates. Default: from getPromptsDir() */
+	agentDir?: string;
+}
+
+/**
+ * Load all prompt templates from:
+ * 1. Global: agentDir/prompts/
+ * 2. Project: cwd/{CONFIG_DIR_NAME}/prompts/
+ */
+export async function loadPromptTemplates(options: LoadPromptTemplatesOptions = {}): Promise<PromptTemplate[]> {
+	const resolvedCwd = options.cwd ?? process.cwd();
+	const resolvedAgentDir = options.agentDir ?? getPromptsDir();
+
+	const templates: PromptTemplate[] = [];
+
+	// 1. Load global templates from agentDir/prompts/
+	// Note: if agentDir is provided, it should be the agent dir, not the prompts dir
+	const globalPromptsDir = options.agentDir ? join(options.agentDir, "prompts") : resolvedAgentDir;
+	templates.push(...(await loadTemplatesFromDir(globalPromptsDir, "user")));
+
+	// 2. Load project templates from cwd/{CONFIG_DIR_NAME}/prompts/
+	const projectPromptsDir = resolve(resolvedCwd, CONFIG_DIR_NAME, "prompts");
+	templates.push(...(await loadTemplatesFromDir(projectPromptsDir, "project")));
+
+	return templates;
+}
+
+/**
+ * Expand a prompt template if it matches a template name.
+ * Returns the expanded content or the original text if not a template.
+ */
+export function expandPromptTemplate(text: string, templates: PromptTemplate[]): string {
+	if (!text.startsWith("/")) return text;
+
+	const spaceIndex = text.indexOf(" ");
+	const templateName = spaceIndex === -1 ? text.slice(1) : text.slice(1, spaceIndex);
+	const argsString = spaceIndex === -1 ? "" : text.slice(spaceIndex + 1);
+
+	const template = templates.find((t) => t.name === templateName);
+	if (template) {
+		const args = parseCommandArgs(argsString);
+		return substituteArgs(template.content, args);
+	}
+
+	return text;
+}