@oh-my-pi/pi-coding-agent 15.10.0 → 15.10.2

package/src/cli/gallery-fixtures/misc.ts

@@ -218,4 +218,33 @@ export const miscFixtures: Record<string, GalleryFixture> = {
 			},
 		},
 	},
+
+	// Built-in tool with no dedicated renderer — exercises the generic fallback
+	// (`#formatToolExecution`) path so its padded, state-tinted block is QA'd.
+	report_tool_issue: {
+		label: "Report Tool Issue",
+		streamingArgs: { tool: "lsp" },
+		args: {
+			tool: "lsp",
+			report: "Rename returned no edit for an exported symbol that has 12 references",
+		},
+		result: { content: [{ type: "text", text: "Noted, thanks!" }] },
+		errorResult: {
+			content: [{ type: "text", text: "Could not record the report: issue tracker unreachable" }],
+			isError: true,
+		},
+	},
+
+	// Stand-in for a custom/extension tool that ships no renderer — same generic
+	// fallback path most MCP/extension tools take.
+	custom: {
+		label: "Custom Tool",
+		streamingArgs: { query: "weather" },
+		args: { query: "weather in Tokyo", units: "metric" },
+		result: { content: [{ type: "text", text: "Tokyo: 22°C, partly cloudy, humidity 64%." }] },
+		errorResult: {
+			content: [{ type: "text", text: "Upstream provider returned 503 Service Unavailable" }],
+			isError: true,
+		},
+	},
 };

package/src/cli/startup-cwd.ts

@@ -0,0 +1,68 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { getProjectDir, normalizePathForComparison, setProjectDir } from "@oh-my-pi/pi-utils";
+import type { Args } from "./args";
+
+async function maybeAutoChdir(parsed: Args): Promise<void> {
+	if (parsed.allowHome || parsed.cwd) {
+		return;
+	}
+
+	const home = os.homedir();
+	if (!home) {
+		return;
+	}
+
+	const normalizePath = normalizePathForComparison;
+
+	const cwd = normalizePath(getProjectDir());
+	const normalizedHome = normalizePath(home);
+	if (cwd !== normalizedHome) {
+		return;
+	}
+
+	const isDirectory = async (p: string) => {
+		try {
+			const s = await fs.stat(p);
+			return s.isDirectory();
+		} catch {
+			return false;
+		}
+	};
+
+	const candidates = [path.join(home, "tmp"), "/tmp", "/var/tmp"];
+	for (const candidate of candidates) {
+		try {
+			if (!(await isDirectory(candidate))) {
+				continue;
+			}
+			setProjectDir(candidate);
+			return;
+		} catch {
+			// Try next candidate.
+		}
+	}
+
+	try {
+		const fallback = os.tmpdir();
+		if (fallback && normalizePath(fallback) !== cwd && (await isDirectory(fallback))) {
+			setProjectDir(fallback);
+		}
+	} catch {
+		// Ignore fallback errors.
+	}
+}
+
+export async function applyStartupCwd(parsed: Args): Promise<void> {
+	if (parsed.cwd) {
+		setProjectDir(parsed.cwd);
+		// setProjectDir resolves the (possibly relative) target against the launch
+		// cwd and chdirs into it. Re-sync parsed.cwd to the resolved absolute path
+		// so downstream consumers (buildSessionOptions, settings/discovery, session
+		// persistence) don't re-resolve a relative string against the new cwd.
+		parsed.cwd = getProjectDir();
+		return;
+	}
+	await maybeAutoChdir(parsed);
+}

package/src/commands/launch.ts

@@ -49,6 +49,9 @@ export default class Index extends Command {
 		"allow-home": Flags.boolean({
 			description: "Allow starting in ~ without auto-switching to a temp dir",
 		}),
+		cwd: Flags.string({
+			description: "Directory to start in (overrides the launch cwd)",
+		}),
 		mode: Flags.string({
 			description: "Output mode: text (default), json, rpc, or rpc-ui",
 			options: ["text", "json", "rpc", "acp", "rpc-ui"],

package/src/commit/analysis/conventional.ts

@@ -1,5 +1,5 @@
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Api, Model } from "@oh-my-pi/pi-ai";
+import type { Api, ApiKey, Model } from "@oh-my-pi/pi-ai";
 import { completeSimple } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
 import analysisSystemPrompt from "../../commit/prompts/analysis-system.md" with { type: "text" };
@@ -14,7 +14,7 @@ const ConventionalAnalysisTool = createConventionalAnalysisTool(
 
 export interface ConventionalAnalysisInput {
 	model: Model<Api>;
-	apiKey: string;
+	apiKey: ApiKey;
 	thinkingLevel?: ThinkingLevel;
 	contextFiles?: Array<{ path: string; content: string }>;
 	userContext?: string;

package/src/commit/analysis/summary.ts

@@ -1,5 +1,5 @@
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Api, AssistantMessage, Model } from "@oh-my-pi/pi-ai";
+import type { Api, ApiKey, AssistantMessage, Model } from "@oh-my-pi/pi-ai";
 import { completeSimple, validateToolCall } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
@@ -19,7 +19,7 @@ const SummaryTool = {
 
 export interface SummaryInput {
 	model: Model<Api>;
-	apiKey: string;
+	apiKey: ApiKey;
 	thinkingLevel?: ThinkingLevel;
 	commitType: string;
 	scope: string | null;

package/src/commit/changelog/generate.ts

@@ -1,5 +1,5 @@
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Api, AssistantMessage, Model } from "@oh-my-pi/pi-ai";
+import type { Api, ApiKey, AssistantMessage, Model } from "@oh-my-pi/pi-ai";
 import { completeSimple, validateToolCall } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
@@ -25,7 +25,7 @@ export const changelogTool = {
 
 export interface ChangelogPromptInput {
 	model: Model<Api>;
-	apiKey: string;
+	apiKey: ApiKey;
 	thinkingLevel?: ThinkingLevel;
 	changelogPath: string;
 	isPackageChangelog: boolean;

package/src/commit/changelog/index.ts

@@ -1,6 +1,6 @@
 import * as path from "node:path";
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Api, Model } from "@oh-my-pi/pi-ai";
+import type { Api, ApiKey, Model } from "@oh-my-pi/pi-ai";
 import { logger } from "@oh-my-pi/pi-utils";
 import { CHANGELOG_CATEGORIES } from "../../commit/types";
 import * as git from "../../utils/git";
@@ -15,7 +15,7 @@ const DEFAULT_MAX_DIFF_CHARS = 120_000;
 export interface ChangelogFlowInput {
 	cwd: string;
 	model: Model<Api>;
-	apiKey: string;
+	apiKey: ApiKey;
 	thinkingLevel?: ThinkingLevel;
 	stagedFiles: string[];
 	dryRun: boolean;

package/src/commit/map-reduce/index.ts

@@ -1,5 +1,5 @@
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Api, Model } from "@oh-my-pi/pi-ai";
+import type { Api, ApiKey, Model } from "@oh-my-pi/pi-ai";
 import { $env } from "@oh-my-pi/pi-utils";
 import { parseFileDiffs } from "../../commit/git/diff";
 import type { ConventionalAnalysis } from "../../commit/types";
@@ -21,10 +21,10 @@ export interface MapReduceSettings {
 
 export interface MapReduceInput {
 	model: Model<Api>;
-	apiKey: string;
+	apiKey: ApiKey;
 	thinkingLevel?: ThinkingLevel;
 	smolModel: Model<Api>;
-	smolApiKey: string;
+	smolApiKey: ApiKey;
 	smolThinkingLevel?: ThinkingLevel;
 	diff: string;
 	stat: string;

package/src/commit/map-reduce/map-phase.ts

@@ -1,5 +1,5 @@
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Api, AssistantMessage, Message, Model } from "@oh-my-pi/pi-ai";
+import type { Api, ApiKey, AssistantMessage, Message, Model } from "@oh-my-pi/pi-ai";
 import { completeSimple } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
 import fileObserverSystemPrompt from "../../commit/prompts/file-observer-system.md" with { type: "text" };
@@ -18,7 +18,7 @@ const RETRY_BACKOFF_MS = 1000;
 
 export interface MapPhaseInput {
 	model: Model<Api>;
-	apiKey: string;
+	apiKey: ApiKey;
 	thinkingLevel?: ThinkingLevel;
 	files: FileDiff[];
 	config?: {

package/src/commit/map-reduce/reduce-phase.ts

@@ -1,5 +1,5 @@
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Api, Model } from "@oh-my-pi/pi-ai";
+import type { Api, ApiKey, Model } from "@oh-my-pi/pi-ai";
 import { completeSimple } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
 import reduceSystemPrompt from "../../commit/prompts/reduce-system.md" with { type: "text" };
@@ -12,7 +12,7 @@ const ReduceTool = createConventionalAnalysisTool("Synthesize file observations
 
 export interface ReducePhaseInput {
 	model: Model<Api>;
-	apiKey: string;
+	apiKey: ApiKey;
 	thinkingLevel?: ThinkingLevel;
 	observations: FileObservation[];
 	stat: string;

package/src/commit/model-selection.ts

@@ -1,7 +1,9 @@
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Api, Model } from "@oh-my-pi/pi-ai";
+import type { Api, ApiKey, Model } from "@oh-my-pi/pi-ai";
+import type { ApiKeyResolverRegistry } from "../config/api-key-resolver";
 import { MODEL_ROLE_IDS } from "../config/model-registry";
 import {
+	getModelMatchPreferences,
 	type ModelLookupRegistry,
 	parseModelPattern,
 	resolveModelRoleValue,
@@ -12,13 +14,19 @@ import MODEL_PRIO from "../priority.json" with { type: "json" };
 
 export interface ResolvedCommitModel {
 	model: Model<Api>;
-	apiKey: string;
+	/**
+	 * Resolver for the model's bearer: re-resolves on 401 / usage-limit so the
+	 * whole commit pipeline (analysis, map/reduce, changelog) inherits the
+	 * central force-refresh + account-rotation policy.
+	 */
+	apiKey: ApiKey;
 	thinkingLevel?: ThinkingLevel;
 }
 
-type CommitModelRegistry = ModelLookupRegistry & {
-	getApiKey: (model: Model<Api>) => Promise<string | undefined>;
-};
+type CommitModelRegistry = ModelLookupRegistry &
+	ApiKeyResolverRegistry & {
+		getApiKey: (model: Model<Api>) => Promise<string | undefined>;
+	};
 
 export async function resolvePrimaryModel(
 	override: string | undefined,
@@ -26,7 +34,7 @@ export async function resolvePrimaryModel(
 	modelRegistry: CommitModelRegistry,
 ): Promise<ResolvedCommitModel> {
 	const available = modelRegistry.getAvailable();
-	const matchPreferences = { usageOrder: settings.getStorage()?.getModelUsageOrder() };
+	const matchPreferences = getModelMatchPreferences(settings);
 	const resolved = override
 		? resolveModelRoleValue(override, available, { settings, matchPreferences, modelRegistry })
 		: resolveRoleSelection(["commit", "smol", ...MODEL_ROLE_IDS], settings, available, modelRegistry);
@@ -38,28 +46,45 @@ export async function resolvePrimaryModel(
 	if (!apiKey) {
 		throw new Error(`No API key available for model ${model.provider}/${model.id}`);
 	}
-	return { model, apiKey, thinkingLevel: resolved?.thinkingLevel };
+	return {
+		model,
+		apiKey: modelRegistry.resolver(model.provider, { baseUrl: model.baseUrl }),
+		thinkingLevel: resolved?.thinkingLevel,
+	};
 }
 
 export async function resolveSmolModel(
 	settings: Settings,
 	modelRegistry: CommitModelRegistry,
 	fallbackModel: Model<Api>,
-	fallbackApiKey: string,
+	fallbackApiKey: ApiKey,
 ): Promise<ResolvedCommitModel> {
 	const available = modelRegistry.getAvailable();
 	const resolvedSmol = resolveRoleSelection(["smol"], settings, available, modelRegistry);
 	if (resolvedSmol?.model) {
 		const apiKey = await modelRegistry.getApiKey(resolvedSmol.model);
-		if (apiKey) return { model: resolvedSmol.model, apiKey, thinkingLevel: resolvedSmol.thinkingLevel };
+		if (apiKey) {
+			return {
+				model: resolvedSmol.model,
+				apiKey: modelRegistry.resolver(resolvedSmol.model.provider, {
+					baseUrl: resolvedSmol.model.baseUrl,
+				}),
+				thinkingLevel: resolvedSmol.thinkingLevel,
+			};
+		}
 	}
 
-	const matchPreferences = { usageOrder: settings.getStorage()?.getModelUsageOrder() };
+	const matchPreferences = getModelMatchPreferences(settings);
 	for (const pattern of MODEL_PRIO.smol) {
 		const candidate = parseModelPattern(pattern, available, matchPreferences, { modelRegistry }).model;
 		if (!candidate) continue;
 		const apiKey = await modelRegistry.getApiKey(candidate);
-		if (apiKey) return { model: candidate, apiKey };
+		if (apiKey) {
+			return {
+				model: candidate,
+				apiKey: modelRegistry.resolver(candidate.provider, { baseUrl: candidate.baseUrl }),
+			};
+		}
 	}
 
 	return { model: fallbackModel, apiKey: fallbackApiKey };

package/src/commit/pipeline.ts

@@ -1,6 +1,6 @@
 import * as path from "node:path";
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Api, Model } from "@oh-my-pi/pi-ai";
+import type { Api, ApiKey, Model } from "@oh-my-pi/pi-ai";
 import { getProjectDir, logger, prompt } from "@oh-my-pi/pi-utils";
 import { ModelRegistry } from "../config/model-registry";
 import { Settings } from "../config/settings";
@@ -145,10 +145,10 @@ async function generateAnalysis(input: {
 	contextFiles: Array<{ path: string; content: string }>;
 	userContext?: string;
 	primaryModel: Model<Api>;
-	primaryApiKey: string;
+	primaryApiKey: ApiKey;
 	primaryThinkingLevel?: ThinkingLevel;
 	smolModel: Model<Api>;
-	smolApiKey: string;
+	smolApiKey: ApiKey;
 	smolThinkingLevel?: ThinkingLevel;
 	commitSettings: {
 		mapReduceEnabled: boolean;
@@ -206,7 +206,7 @@ async function generateSummaryWithRetry(input: {
 	analysis: ConventionalAnalysis;
 	stat: string;
 	model: Model<Api>;
-	apiKey: string;
+	apiKey: ApiKey;
 	thinkingLevel?: ThinkingLevel;
 	userContext?: string;
 }): Promise<{ summary: string }> {

package/src/config/api-key-resolver.ts

@@ -0,0 +1,58 @@
+import type { ApiKeyResolver, AuthStorage } from "@oh-my-pi/pi-ai";
+
+export interface ApiKeyResolverOptions {
+	/** Session id for credential stickiness; read at resolve time by the caller. */
+	sessionId?: string;
+	/** Provider base URL hint forwarded to the auth-storage cascade. */
+	baseUrl?: string;
+}
+
+/**
+ * Minimal slice of `ModelRegistry` the resolver needs. Typed structurally so
+ * narrower registry shells (e.g. the commit pipeline's `CommitModelRegistry`)
+ * can build resolvers without depending on the full class.
+ */
+export interface ApiKeyResolverRegistry {
+	getApiKeyForProvider(
+		provider: string,
+		sessionId?: string,
+		options?: { baseUrl?: string; forceRefresh?: boolean; signal?: AbortSignal },
+	): Promise<string | undefined>;
+	authStorage: Pick<AuthStorage, "rotateSessionCredential">;
+	/**
+	 * Build an {@link ApiKeyResolver} implementing the central a/b/c auth-retry
+	 * policy: initial → resolve; step (b) → force-refresh same account; step (c)
+	 * → rotate to a sibling credential, then re-resolve.
+	 *
+	 * The resolver is stateless (safe to reuse across requests). Callers that
+	 * need the initial key for a guard can call `resolveApiKeyOnce(resolver)`.
+	 */
+	resolver(provider: string, options?: ApiKeyResolverOptions): ApiKeyResolver;
+}
+
+/**
+ * Default implementation of {@link ApiKeyResolverRegistry.resolver}.
+ * Also usable standalone for structural registries that don't carry the method.
+ */
+export function createApiKeyResolver(
+	registry: Pick<ApiKeyResolverRegistry, "getApiKeyForProvider" | "authStorage">,
+	provider: string,
+	options: ApiKeyResolverOptions = {},
+): ApiKeyResolver {
+	const { sessionId, baseUrl } = options;
+	return async ({ lastChance, error, signal }) => {
+		if (error === undefined) {
+			return registry.getApiKeyForProvider(provider, sessionId, { baseUrl });
+		}
+		if (lastChance) {
+			// Account constraint (401 / usage / account-rate-limit): rotate to a
+			// sibling credential. We do NOT honor any retry-after here — if a
+			// sibling exists we switch immediately; the precise no-sibling backoff
+			// is owned by `markUsageLimitReached` (default + server usage-report
+			// reset) and the outer whole-turn retry layer.
+			await registry.authStorage.rotateSessionCredential(provider, sessionId, { error, signal });
+			return registry.getApiKeyForProvider(provider, sessionId, { baseUrl });
+		}
+		return registry.getApiKeyForProvider(provider, sessionId, { baseUrl, forceRefresh: true, signal });
+	};
+}

package/src/config/model-provider-priority.ts

@@ -0,0 +1,55 @@
+const DEFAULT_MODEL_PROVIDER_ORDER = [
+	// First-party / native account providers. Prefer these over relays when the
+	// same upstream model is available in more than one place.
+	"openai-codex",
+	"anthropic",
+	"openai",
+	"google-gemini-cli",
+	"google",
+	"google-vertex",
+	"kimi-code",
+	"moonshot",
+	"qwen-portal",
+	"zai",
+	"xai-oauth",
+	"xai",
+	"mistral",
+	"deepseek",
+	"groq",
+
+	// High-quality aggregators / hosted inference providers.
+	"fireworks",
+	"cerebras",
+	"openrouter",
+	"together",
+
+	// Generic gateways and editor/proxy providers. These are useful when picked
+	// explicitly, but should not win ambiguous automatic role selection.
+	"alibaba-coding-plan",
+	"google-antigravity",
+	"opencode-zen",
+	"gitlab-duo",
+	"opencode-go",
+	"kilo",
+	"vercel-ai-gateway",
+	"cloudflare-ai-gateway",
+	"nanogpt",
+	"github-copilot",
+] as const;
+
+function addProviderRank(rank: Map<string, number>, provider: string): void {
+	const normalized = provider.trim().toLowerCase();
+	if (!normalized || rank.has(normalized)) return;
+	rank.set(normalized, rank.size);
+}
+
+export function buildModelProviderPriorityRank(configuredProviderOrder?: readonly string[]): Map<string, number> {
+	const rank = new Map<string, number>();
+	for (const provider of configuredProviderOrder ?? []) {
+		addProviderRank(rank, provider);
+	}
+	for (const provider of DEFAULT_MODEL_PROVIDER_ORDER) {
+		addProviderRank(rank, provider);
+	}
+	return rank;
+}

package/src/config/model-registry.ts

@@ -95,12 +95,14 @@ const STARTUP_MODEL_CACHE_PROVIDER_IDS: readonly string[] = [
 	...SPECIAL_MODEL_MANAGER_PROVIDER_IDS,
 ];
 
+import type { ApiKeyResolver } from "@oh-my-pi/pi-ai";
 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 { parseModelString, resolveProviderModelReference } from "../config/model-resolver";
 import { isValidThemeColor, type ThemeColor } from "../modes/theme/theme";
 import type { AuthStorage, OAuthCredential } from "../session/auth-storage";
+import { type ApiKeyResolverOptions, createApiKeyResolver } from "./api-key-resolver";
 import { type ConfigError, ConfigFile } from "./config-file";
 import {
 	buildCanonicalModelIndex,
@@ -116,6 +118,7 @@ import {
 	getModelLikeIdSegments,
 	stripBracketedModelIdAffixes,
 } from "./model-id-affixes";
+import { buildModelProviderPriorityRank } from "./model-provider-priority";
 import {
 	type ModelOverride,
 	type ModelsConfig,
@@ -2206,27 +2209,8 @@ export class ModelRegistry {
 		});
 	}
 
-	#providerRank(models: readonly Model<Api>[]): Map<string, number> {
-		const configuredProviders = getConfiguredProviderOrderFromSettings();
-		const result = new Map<string, number>();
-		let nextRank = 0;
-		for (const provider of configuredProviders) {
-			const normalized = provider.trim().toLowerCase();
-			if (!normalized || result.has(normalized)) {
-				continue;
-			}
-			result.set(normalized, nextRank);
-			nextRank += 1;
-		}
-		for (const model of models) {
-			const normalized = model.provider.toLowerCase();
-			if (result.has(normalized)) {
-				continue;
-			}
-			result.set(normalized, nextRank);
-			nextRank += 1;
-		}
-		return result;
+	#providerRank(): Map<string, number> {
+		return buildModelProviderPriorityRank(getConfiguredProviderOrderFromSettings());
 	}
 
 	#resolveCanonicalVariant(
@@ -2236,7 +2220,7 @@ export class ModelRegistry {
 		if (variants.length === 0) {
 			return undefined;
 		}
-		const providerRank = this.#providerRank(allCandidates);
+		const providerRank = this.#providerRank();
 		const modelOrder = new Map<string, number>();
 		for (let index = 0; index < allCandidates.length; index += 1) {
 			modelOrder.set(formatCanonicalVariantSelector(allCandidates[index]!), index);
@@ -2365,12 +2349,33 @@ export class ModelRegistry {
 
 	/**
 	 * Get API key for a provider (e.g., "openai").
+	 *
+	 * `options.forceRefresh` powers step (b) of the auth-retry policy — it
+	 * re-mints the session-sticky OAuth token even when the cached copy still
+	 * looks valid. `options.signal` is threaded into any broker-bound refresh.
 	 */
-	async getApiKeyForProvider(provider: string, sessionId?: string, baseUrl?: string): Promise<string | undefined> {
+	async getApiKeyForProvider(
+		provider: string,
+		sessionId?: string,
+		options?: { baseUrl?: string; forceRefresh?: boolean; signal?: AbortSignal },
+	): Promise<string | undefined> {
 		if (this.#keylessProviders.has(provider) && !this.authStorage.hasAuth(provider)) {
 			return kNoAuth;
 		}
-		return this.authStorage.getApiKey(provider, sessionId, { baseUrl });
+		return this.authStorage.getApiKey(provider, sessionId, {
+			baseUrl: options?.baseUrl,
+			forceRefresh: options?.forceRefresh,
+			signal: options?.signal,
+		});
+	}
+
+	/**
+	 * Build an {@link ApiKeyResolver} for this provider, implementing the
+	 * central a/b/c auth-retry policy. Callers that need the initial key for
+	 * a guard can call `resolveApiKeyOnce(resolver)`.
+	 */
+	resolver(provider: string, options?: ApiKeyResolverOptions): ApiKeyResolver {
+		return createApiKeyResolver(this, provider, options);
 	}
 
 	async #peekApiKeyForProvider(provider: string): Promise<string | undefined> {