@oh-my-pi/pi-coding-agent 17.0.8 → 17.1.0

package/src/commands/bench.ts

@@ -15,15 +15,24 @@ export default class Bench extends Command {
 	};
 
 	static flags = {
-		runs: Flags.integer({ description: "Requests per model (results are averaged)", default: 10 }),
-		"max-tokens": Flags.integer({ description: "Max output tokens per request", default: 512 }),
+		runs: Flags.integer({ description: "Requests per model (results are averaged; default: 10)" }),
+		"max-tokens": Flags.integer({ description: "Max output tokens per request (default: 512; cache mode: 64)" }),
 		prompt: Flags.string({ description: "Custom prompt text (default: bundled bench prompt)" }),
 		"service-tier": Flags.string({
 			description: "Service tier applied per model family (default: configured `tier.*` settings; `none` omits it)",
 			options: SERVICE_TIER_OPENAI_VALUES,
 		}),
 		json: Flags.boolean({ description: "Output JSON" }),
-		par: Flags.integer({ description: "Execute runs with N parallel queries/requests", default: 4 }),
+		par: Flags.integer({ description: "Execute runs with N parallel queries/requests (default: 4)" }),
+		cache: Flags.boolean({
+			description: "Run independent cold/warm prompt-cache pairs (not supported for openai-codex-responses)",
+		}),
+		"cache-prefix-file": Flags.string({ description: "Stable prompt prefix file for --cache" }),
+		"cache-prefix-bytes": Flags.integer({ description: "Stable prefix byte budget for --cache (default: 8192)" }),
+		"cache-pairs": Flags.integer({ description: "Cold/warm pairs per model for --cache (default: 1)" }),
+		"cache-concurrency": Flags.integer({
+			description: "Concurrent cache pairs for --cache; each pair remains sequential (default: 1)",
+		}),
 	};
 
 	static examples = [
@@ -31,7 +40,7 @@ export default class Bench extends Command {
 		"# Fuzzy selectors work\n  omp bench opus sonnet",
 		"# Average over 3 runs each\n  omp bench opus gpt-5.2 --runs 3",
 		"# Force priority serving tier\n  omp bench openai-codex/gpt-5.5:low --runs 10 --service-tier priority",
-		"# Machine-readable output\n  omp bench opus --json",
+		"# Measure one cold/warm prompt-cache pair\n  omp bench openai/gpt-5.6 --cache --json",
 	];
 
 	async run(): Promise<void> {
@@ -45,6 +54,11 @@ export default class Bench extends Command {
 				serviceTier: flags["service-tier"],
 				json: flags.json,
 				par: flags.par,
+				cache: flags.cache,
+				cachePrefixFile: flags["cache-prefix-file"],
+				cachePrefixBytes: flags["cache-prefix-bytes"],
+				cachePairs: flags["cache-pairs"],
+				cacheConcurrency: flags["cache-concurrency"],
 			},
 		});
 	}

package/src/commands/launch.ts

@@ -83,6 +83,10 @@ export default class Index extends Command {
 			description: "Load an extra config.yml-style overlay for this run (repeatable)",
 			multiple: true,
 		}),
+		"add-dir": Flags.string({
+			description: "Add a workspace directory beyond the working directory (repeatable)",
+			multiple: true,
+		}),
 		print: Flags.boolean({
 			char: "p",
 			description: "Non-interactive mode: process prompt and exit",

package/src/config/__tests__/model-registry.test.ts

@@ -0,0 +1,147 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import type { AuthStorage } from "@oh-my-pi/pi-ai";
+import { ModelRegistry } from "../model-registry";
+
+/**
+ * Stub AuthStorage that satisfies the surface used by ModelRegistry's
+ * constructor (#loadModels → clearConfigApiKeys, constructor →
+ * setFallbackResolver). The awaiter under test never reaches auth-gated code
+ * paths, so no real credential store is required.
+ */
+function createStubAuthStorage(): AuthStorage {
+	const stub = {
+		setFallbackResolver: () => {},
+		clearConfigApiKeys: () => {},
+		hasAuth: () => false,
+	};
+	return stub as unknown as AuthStorage;
+}
+
+describe("ModelRegistry.awaitBackgroundRefresh", () => {
+	let tmpDir: string;
+	let registry: ModelRegistry;
+
+	beforeEach(() => {
+		tmpDir = mkdtempSync(path.join(os.tmpdir(), "omp-reg-"));
+		// Construct with an explicit modelsPath inside the temp dir so the
+		// constructor's #loadModels read returns "not-found" rather than
+		// touching the host's ~/.omp/agent/models.yaml. isBunTestRuntime()
+		// auto-stubs #fetch in the constructor.
+		registry = new ModelRegistry(createStubAuthStorage(), path.join(tmpDir, "models.yaml"));
+	});
+
+	afterEach(() => {
+		vi.restoreAllMocks();
+		rmSync(tmpDir, { recursive: true, force: true });
+	});
+
+	test("resolves immediately when no background refresh is in flight", async () => {
+		// No refreshInBackground() called → #backgroundRefresh is undefined.
+		// The awaiter must settle within a single microtask, never hanging.
+		let settled = false;
+		const p = registry.awaitBackgroundRefresh().then(() => {
+			settled = true;
+		});
+		await Promise.resolve();
+		await p;
+		expect(settled).toBe(true);
+	});
+
+	test("blocks until the in-flight background refresh resolves, then resolves", async () => {
+		// Drive refreshInBackground with a controlled refresh() return value so
+		// #backgroundRefresh is captured but not yet settled.
+		const { promise, resolve } = Promise.withResolvers<void>();
+		const refreshSpy = vi.spyOn(registry, "refresh").mockReturnValue(promise);
+
+		registry.refreshInBackground();
+		expect(refreshSpy).toHaveBeenCalledTimes(1);
+
+		let settled = false;
+		const awaitPromise = registry.awaitBackgroundRefresh().then(() => {
+			settled = true;
+		});
+
+		// Yield to the microtask queue: the awaiter must still be pending.
+		for (let i = 0; i < 5; i++) await Promise.resolve();
+		expect(settled).toBe(false);
+
+		resolve();
+
+		await awaitPromise;
+		expect(settled).toBe(true);
+	});
+
+	test("resolves even when the underlying refresh rejects (refreshInBackground swallows)", async () => {
+		// refreshInBackground wraps refresh() in .catch(...) so discovery errors
+		// never reach awaitBackgroundRefresh callers. The awaiter must resolve,
+		// not propagate the rejection.
+		const { promise, reject } = Promise.withResolvers<void>();
+		vi.spyOn(registry, "refresh").mockReturnValue(promise);
+
+		registry.refreshInBackground();
+
+		let settled = false;
+		const awaitPromise = registry.awaitBackgroundRefresh().then(() => {
+			settled = true;
+		});
+
+		reject(new Error("synthetic discovery failure"));
+
+		await awaitPromise;
+		expect(settled).toBe(true);
+	});
+
+	test("awaiter is a no-op after the in-flight refresh settles and clears #backgroundRefresh", async () => {
+		// Once refreshInBackground's promise resolves, #backgroundRefresh is
+		// cleared in the .finally. A subsequent awaitBackgroundRefresh must be
+		// an immediate no-op (microtask), not hang waiting for a stale promise
+		// or a second refresh that was never started.
+		const { promise, resolve } = Promise.withResolvers<void>();
+		vi.spyOn(registry, "refresh").mockReturnValue(promise);
+
+		registry.refreshInBackground();
+		resolve();
+		await registry.awaitBackgroundRefresh();
+
+		// Now #backgroundRefresh is cleared. A fresh await must resolve in a
+		// single microtask — measure by asserting it settles before a second
+		// microtask tick.
+		let settled = false;
+		const p = registry.awaitBackgroundRefresh().then(() => {
+			settled = true;
+		});
+		await Promise.resolve();
+		expect(settled).toBe(true);
+		await p;
+	});
+
+	test("refreshInBackground deduplicates: a second call while in-flight starts no new refresh", async () => {
+		// The guard `if (this.#backgroundRefresh) return` at the top of
+		// refreshInBackground prevents concurrent refreshes. A second call
+		// while the first is still pending must not invoke refresh() again.
+		const { promise, resolve } = Promise.withResolvers<void>();
+		const refreshSpy = vi.spyOn(registry, "refresh").mockReturnValue(promise);
+
+		registry.refreshInBackground();
+		registry.refreshInBackground();
+		registry.refreshInBackground();
+
+		expect(refreshSpy).toHaveBeenCalledTimes(1);
+
+		resolve();
+		await registry.awaitBackgroundRefresh();
+
+		// After settle, #backgroundRefresh is cleared — a new call DOES start
+		// a fresh refresh.
+		const { promise: secondPromise, resolve: secondResolve } = Promise.withResolvers<void>();
+		refreshSpy.mockReturnValue(secondPromise);
+		registry.refreshInBackground();
+		expect(refreshSpy).toHaveBeenCalledTimes(2);
+
+		secondResolve();
+		await registry.awaitBackgroundRefresh();
+	});
+});

package/src/config/model-registry.ts

@@ -869,6 +869,28 @@ export class ModelRegistry {
 		this.#backgroundRefresh = refreshPromise;
 	}
 
+	/**
+	 * Wait for any in-flight background model discovery to settle.
+	 *
+	 * Background discovery started by {@link refreshInBackground} is
+	 * fire-and-forget; RPC consumers (e.g. `get_available_models`,
+	 * `set_model`) and deferred `--model` resolution that read the registry
+	 * immediately after session creation can otherwise observe a partial
+	 * catalog before discovery-backed providers have populated `#models`.
+	 * Awaiting the tracked promise ensures the response reflects every
+	 * configured provider once the initial background refresh resolves.
+	 *
+	 * No-op when no refresh is in flight (`#backgroundRefresh` cleared in the
+	 * `finally` of `refreshInBackground` on completion). Resolves immediately
+	 * in that case so already-warm sessions are unaffected. Discovery errors
+	 * remain swallowed by `refreshInBackground`'s existing `.catch`.
+	 */
+	async awaitBackgroundRefresh(): Promise<void> {
+		if (this.#backgroundRefresh) {
+			await this.#backgroundRefresh;
+		}
+	}
+
 	async refreshProvider(providerId: string, strategy: ModelRefreshStrategy = "online"): Promise<void> {
 		this.#reloadStaticModels();
 		for (const selector of this.#suppressedSelectors.keys()) {
@@ -2101,6 +2123,24 @@ export class ModelRegistry {
 			.map(provider => provider.provider);
 	}
 
+	/**
+	 * Whether `providerId` is known to the registry: it has at least one live
+	 * model, or it is configured for dynamic discovery (models.yml `discovery:`
+	 * or a runtime extension provider) and is not disabled. Discovery-only
+	 * providers can hold zero models at startup — cached rows never persist
+	 * live auth headers (#5780), so a provider whose discovered models all
+	 * carry config headers (`authHeader: true`) only materializes models after
+	 * the online refresh completes.
+	 */
+	hasProvider(providerId: string): boolean {
+		if (this.#models.some(model => model.provider === providerId)) return true;
+		if (getDisabledProviderIdsFromSettings().has(providerId)) return false;
+		return (
+			this.#discoverableProviders.some(provider => provider.provider === providerId) ||
+			this.#runtimeModelManagers.has(providerId)
+		);
+	}
+
 	getProviderDiscoveryState(provider: string): ProviderDiscoveryState | undefined {
 		return this.#providerDiscoveryStates.get(provider);
 	}
@@ -2131,13 +2171,21 @@ export class ModelRegistry {
 	/**
 	 * Get API key for a model.
 	 */
-	async getApiKey(model: Model<Api>, sessionId?: string): Promise<string | undefined> {
+	async getApiKey(
+		model: Model<Api>,
+		sessionId?: string,
+		options?: { signal?: AbortSignal },
+	): Promise<string | undefined> {
 		const commandKey = this.#resolveCommandBackedApiKey(model.provider);
 		if (commandKey.configured) return commandKey.value;
 		if (this.#keylessProviders.has(model.provider) && !this.authStorage.hasAuth(model.provider)) {
 			return kNoAuth;
 		}
-		return this.authStorage.getApiKey(model.provider, sessionId, { baseUrl: model.baseUrl, modelId: model.id });
+		return this.authStorage.getApiKey(model.provider, sessionId, {
+			baseUrl: model.baseUrl,
+			modelId: model.id,
+			signal: options?.signal,
+		});
 	}
 
 	/**

package/src/config/model-resolver.ts

@@ -782,7 +782,6 @@ function parseModelPatternWithContext(
 	options?: { allowInvalidThinkingSelectorFallback?: boolean },
 ): ParsedModelResult {
 	// Exact match on the full pattern first (no fuzzy): a literal id that
-	// contains a colon (`coding-router:max`) wins over any suffix split.
 	const exactMatch = matchModel(pattern, availableModels, context, { exactOnly: true });
 	if (exactMatch) {
 		return { model: exactMatch, thinkingLevel: undefined, warning: undefined, explicitThinkingLevel: false };

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

@@ -73,8 +73,19 @@ export const OpenAICompatSchema = type({
 	"whenThinking?": OpenAICompatFieldsSchema,
 });
 
+const BedrockCompatSchema = type({
+	"promptCacheMode?": '"none" | "automatic" | "explicit"',
+	"supportsLongPromptCacheRetention?": "boolean",
+	"promptCacheMinimumTokens?": "number >= 0",
+	"promptCacheMaximumCheckpoints?": "number >= 0",
+});
+
+// Provider-level overrides can target bundled models whose API is not repeated
+// in models.yml, so preserve the sparse compat shape for each supported API.
+const ApiCompatSchema = OpenAICompatSchema.and(BedrockCompatSchema);
+
 const ApiSchema = type(
-	'"openai-completions" | "openai-responses" | "openai-codex-responses" | "azure-openai-responses" | "anthropic-messages" | "google-generative-ai" | "google-gemini-cli" | "google-vertex"',
+	'"openai-completions" | "openai-responses" | "openai-codex-responses" | "azure-openai-responses" | "anthropic-messages" | "bedrock-converse-stream" | "google-generative-ai" | "google-gemini-cli" | "google-vertex"',
 );
 
 const EffortSchema = type('"minimal" | "low" | "medium" | "high" | "xhigh" | "max"');
@@ -173,7 +184,7 @@ const ModelDefinitionSchema = type({
 	"maxTokens?": "number",
 	"omitMaxOutputTokens?": "boolean",
 	"headers?": { "[string]": "string" },
-	"compat?": OpenAICompatSchema,
+	"compat?": ApiCompatSchema,
 	"contextPromotionTarget?": "string",
 	"compactionModel?": "string",
 	"remoteCompaction?": RemoteCompactionSchema,
@@ -222,7 +233,7 @@ export const ModelOverrideSchema = type({
 	"maxTokens?": "number",
 	"omitMaxOutputTokens?": "boolean",
 	"headers?": { "[string]": "string" },
-	"compat?": OpenAICompatSchema,
+	"compat?": ApiCompatSchema,
 	"contextPromotionTarget?": "string",
 	"compactionModel?": "string",
 	"remoteCompaction?": RemoteCompactionSchema,
@@ -263,7 +274,7 @@ const ProviderConfigSchema = type({
 	"apiKey?": "string",
 	"api?": ApiSchema,
 	"headers?": { "[string]": "string" },
-	"compat?": OpenAICompatSchema,
+	"compat?": ApiCompatSchema,
 	"remoteCompaction?": RemoteCompactionSchema,
 	"authHeader?": "boolean",
 	"auth?": ProviderAuthSchema,

package/src/config/provider-globals.ts

@@ -1,10 +1,10 @@
-import * as imageGen from "../tools/image-gen";
+import { setImageProviderOrder } from "../tools/image-gen";
 import * as webSearch from "../web/search";
 
 interface ProviderGlobalSettings {
+	get(path: "providers.webSearchOrder"): unknown;
 	get(path: "providers.webSearchExclude"): unknown;
-	get(path: "providers.webSearch"): unknown;
-	get(path: "providers.image"): unknown;
+	get(path: "providers.imageOrder"): unknown;
 }
 
 export function applyProviderGlobalsFromSettings(settings: ProviderGlobalSettings): void {
@@ -13,13 +13,13 @@ export function applyProviderGlobalsFromSettings(settings: ProviderGlobalSetting
 		webSearch.setExcludedSearchProviders(excludedWebSearchProviders.filter(webSearch.isSearchProviderId));
 	}
 
-	const webSearchProvider = settings.get("providers.webSearch");
-	if (typeof webSearchProvider === "string" && webSearch.isSearchProviderPreference(webSearchProvider)) {
-		webSearch.setPreferredSearchProvider(webSearchProvider);
+	const orderedWebSearchProviders = settings.get("providers.webSearchOrder");
+	if (Array.isArray(orderedWebSearchProviders)) {
+		webSearch.setSearchProviderOrder(orderedWebSearchProviders.filter(webSearch.isSearchProviderId));
 	}
 
-	const imageProvider = settings.get("providers.image");
-	if (imageGen.isImageProviderPreference(imageProvider)) {
-		imageGen.setPreferredImageProvider(imageProvider);
+	const orderedImageProviders = settings.get("providers.imageOrder");
+	if (Array.isArray(orderedImageProviders)) {
+		setImageProviderOrder(orderedImageProviders.filter((entry): entry is string => typeof entry === "string"));
 	}
 }

package/src/config/service-tier.ts

@@ -1,4 +1,4 @@
-import type { ServiceTier, ServiceTierByFamily } from "@oh-my-pi/pi-ai";
+import type { ServiceTier, ServiceTierByFamily, ServiceTierFamily } from "@oh-my-pi/pi-ai";
 import type { SubmenuOption } from "./settings-schema";
 
 /**
@@ -16,6 +16,31 @@ export type ServiceTierOpenAISettingValue = (typeof SERVICE_TIER_OPENAI_VALUES)[
 export type ServiceTierAnthropicSettingValue = (typeof SERVICE_TIER_ANTHROPIC_VALUES)[number];
 export type ServiceTierGoogleSettingValue = (typeof SERVICE_TIER_GOOGLE_VALUES)[number];
 
+/** Whether a runtime value names a provider family with an independent service-tier knob. */
+export function isServiceTierFamily(value: unknown): value is ServiceTierFamily {
+	return value === "openai" || value === "anthropic" || value === "google";
+}
+
+/** Whether a runtime value is a supported service tier for one provider family. */
+export function isServiceTierForFamily(family: string, tier: unknown): tier is ServiceTier {
+	if (typeof tier !== "string" || tier === "none") return false;
+	let values: readonly string[];
+	switch (family) {
+		case "openai":
+			values = SERVICE_TIER_OPENAI_VALUES;
+			break;
+		case "anthropic":
+			values = SERVICE_TIER_ANTHROPIC_VALUES;
+			break;
+		case "google":
+			values = SERVICE_TIER_GOOGLE_VALUES;
+			break;
+		default:
+			return false;
+	}
+	return values.includes(tier);
+}
+
 /**
  * Inherit-capable single value for the subagent/advisor tiers. The chosen tier
  * is broadcast across families and applied to whichever family the spawned