gsd-pi 2.76.0 → 2.77.0-dev.1d17f366c

package/packages/pi-coding-agent/src/core/hooks-runner.ts

@@ -0,0 +1,460 @@
+/**
+ * Layer 0 shell-hook runner.
+ *
+ * Bridges the Layer 2 extension event bus to user-configured shell commands
+ * declared in `settings.json` under the `hooks` key. Each hook entry receives
+ * the event payload as JSON on stdin and can mutate the pending action by
+ * writing a JSON response to stdout.
+ *
+ * Trust model: hooks loaded from project-scoped settings are dropped unless
+ * the user has opted in by creating `.pi/hooks.trusted` in the project root.
+ * This prevents a cloned repository from executing arbitrary shell commands.
+ */
+
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { CONFIG_DIR_NAME } from "../config.js";
+import type { ExtensionRunner } from "./extensions/runner.js";
+import type {
+	BeforeCommitEventResult,
+	BeforePrEventResult,
+	BeforePushEventResult,
+	BeforeVerifyEventResult,
+	BudgetThresholdEventResult,
+	CommitEvent,
+	InputEventResult,
+	NotificationEvent,
+	PrOpenedEvent,
+	PushEvent,
+	SessionEndEvent,
+	SessionStartEvent,
+	StopEvent,
+	ToolCallEvent,
+	ToolCallEventResult,
+	ToolResultEvent,
+	ToolResultEventResult,
+	BeforeCommitEvent,
+	BeforePrEvent,
+	BeforePushEvent,
+	BeforeVerifyEvent,
+	BudgetThresholdEvent,
+	InputEvent,
+	MilestoneEndEvent,
+	MilestoneStartEvent,
+	SessionBeforeCompactEvent,
+	SessionBeforeCompactResult,
+	SessionCompactEvent,
+	UnitEndEvent,
+	UnitStartEvent,
+	VerifyResultEvent,
+} from "./extensions/types.js";
+import type { HookEntry, HooksSettings, Settings } from "./settings-manager.js";
+
+const TRUST_MARKER = "hooks.trusted";
+const DEFAULT_TIMEOUT_MS = 30_000;
+
+export type HookName = keyof HooksSettings;
+export type HookScope = "global" | "project";
+
+interface ScopedHook extends HookEntry {
+	scope: HookScope;
+}
+
+export interface HookStdoutResult {
+	block?: boolean;
+	reason?: string;
+	message?: string;
+	title?: string;
+	body?: string;
+	action?: "pause" | "downgrade" | "continue";
+}
+
+export interface HookInvocation {
+	name: HookName;
+	scope: HookScope;
+	command: string;
+	exitCode: number;
+	stdout: string;
+	stderr: string;
+	durationMs: number;
+	timedOut: boolean;
+	parsed?: HookStdoutResult;
+}
+
+export function isProjectHooksTrusted(cwd: string): boolean {
+	return existsSync(join(cwd, CONFIG_DIR_NAME, TRUST_MARKER));
+}
+
+function collectHooks(
+	name: HookName,
+	globalSettings: Settings,
+	projectSettings: Settings,
+	cwd: string,
+): ScopedHook[] {
+	const result: ScopedHook[] = [];
+	for (const entry of globalSettings.hooks?.[name] ?? []) {
+		result.push({ ...entry, scope: "global" });
+	}
+	if (projectSettings.hooks?.[name]?.length && isProjectHooksTrusted(cwd)) {
+		for (const entry of projectSettings.hooks[name] ?? []) {
+			result.push({ ...entry, scope: "project" });
+		}
+	}
+	return result;
+}
+
+function matchesFilter(entry: HookEntry, payload: Record<string, unknown>): boolean {
+	const filter = entry.match;
+	if (!filter) return true;
+
+	if (filter.tool !== undefined) {
+		const names = Array.isArray(filter.tool) ? filter.tool : [filter.tool];
+		const toolName = payload.toolName ?? (payload as { tool?: string }).tool;
+		if (typeof toolName !== "string" || !names.includes(toolName)) return false;
+	}
+
+	if (filter.command !== undefined) {
+		const cmd = (payload.input as { command?: unknown } | undefined)?.command
+			?? (payload as { command?: unknown }).command;
+		if (typeof cmd !== "string" || !cmd.startsWith(filter.command)) return false;
+	}
+
+	return true;
+}
+
+async function runOne(
+	name: HookName,
+	hook: ScopedHook,
+	payload: unknown,
+	cwd: string,
+): Promise<HookInvocation> {
+	const timeout = hook.timeout ?? DEFAULT_TIMEOUT_MS;
+	const startedAt = Date.now();
+
+	return new Promise((resolve) => {
+		const child = spawn(hook.command, {
+			cwd,
+			shell: true,
+			stdio: ["pipe", "pipe", "pipe"],
+			env: { ...process.env, ...hook.env, GSD_HOOK_EVENT: name, GSD_HOOK_SCOPE: hook.scope },
+		});
+
+		let stdout = "";
+		let stderr = "";
+		let timedOut = false;
+
+		const timer = setTimeout(() => {
+			timedOut = true;
+			child.kill("SIGTERM");
+			setTimeout(() => {
+				if (child.exitCode === null) child.kill("SIGKILL");
+			}, 2_000);
+		}, timeout);
+
+		child.stdout.on("data", (d) => { stdout += d.toString(); });
+		child.stderr.on("data", (d) => { stderr += d.toString(); });
+
+		child.on("error", (err) => {
+			clearTimeout(timer);
+			resolve({
+				name,
+				scope: hook.scope,
+				command: hook.command,
+				exitCode: 1,
+				stdout,
+				stderr: stderr || String(err),
+				durationMs: Date.now() - startedAt,
+				timedOut: false,
+			});
+		});
+
+		child.on("close", (code) => {
+			clearTimeout(timer);
+			let parsed: HookStdoutResult | undefined;
+			const trimmed = stdout.trim();
+			if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+				try { parsed = JSON.parse(trimmed) as HookStdoutResult; } catch { /* tolerate non-JSON stdout */ }
+			}
+			resolve({
+				name,
+				scope: hook.scope,
+				command: hook.command,
+				exitCode: code ?? -1,
+				stdout,
+				stderr,
+				durationMs: Date.now() - startedAt,
+				timedOut,
+				parsed,
+			});
+		});
+
+		// Silence EPIPE if the child exits before consuming stdin.
+		child.stdin.on("error", () => { /* no-op */ });
+		try {
+			child.stdin.write(JSON.stringify(payload), () => {
+				try { child.stdin.end(); } catch { /* ignore */ }
+			});
+		} catch { /* child may have already exited */ }
+	});
+}
+
+async function runChain(
+	name: HookName,
+	payload: Record<string, unknown>,
+	hooks: ScopedHook[],
+	cwd: string,
+	onInvocation?: (i: HookInvocation) => void,
+): Promise<HookStdoutResult | undefined> {
+	let merged: HookStdoutResult | undefined;
+	for (const hook of hooks) {
+		if (!matchesFilter(hook, payload)) continue;
+		const invocation = await runOne(name, hook, payload, cwd);
+		onInvocation?.(invocation);
+
+		if (invocation.exitCode !== 0 && hook.blocking !== false) {
+			const reason = invocation.parsed?.reason
+				?? (invocation.stderr.trim()
+					|| `Hook ${hook.command} exited with code ${invocation.exitCode}`);
+			return { ...(merged ?? {}), block: true, reason };
+		}
+
+		if (invocation.parsed) {
+			if (invocation.parsed.block) return { ...(merged ?? {}), ...invocation.parsed };
+			merged = { ...(merged ?? {}), ...invocation.parsed };
+		}
+	}
+	return merged;
+}
+
+// ─── Public API ────────────────────────────────────────────────────────────
+
+export interface HooksRunnerOptions {
+	extensionRunner: ExtensionRunner;
+	getGlobalSettings: () => Settings;
+	getProjectSettings: () => Settings;
+	cwd: string;
+	onInvocation?: (invocation: HookInvocation) => void;
+}
+
+export interface HooksRunner {
+	dispose(): void;
+	/** Fire SessionStart once during bootstrap. */
+	fireSessionStart(): Promise<void>;
+	/** Fire SessionEnd during session teardown. */
+	fireSessionEnd(reason: SessionEndEvent["reason"]): Promise<void>;
+}
+
+type HandlerFn = (event: unknown, ctx: unknown) => Promise<unknown>;
+
+export function createHooksRunner(options: HooksRunnerOptions): HooksRunner {
+	const { extensionRunner, cwd, onInvocation } = options;
+
+	const dispatch = async (name: HookName, payload: Record<string, unknown>) => {
+		const hooks = collectHooks(
+			name,
+			options.getGlobalSettings(),
+			options.getProjectSettings(),
+			cwd,
+		);
+		if (hooks.length === 0) return undefined;
+		return runChain(name, payload, hooks, cwd, onInvocation);
+	};
+
+	const handlers = new Map<string, HandlerFn[]>();
+
+	handlers.set("input", [async (event: unknown): Promise<InputEventResult | undefined> => {
+		const e = event as InputEvent;
+		const result = await dispatch("UserPromptSubmit", { text: e.text, source: e.source });
+		if (result?.block) return { action: "handled" };
+		return undefined;
+	}]);
+
+	handlers.set("tool_call", [async (event: unknown): Promise<ToolCallEventResult | undefined> => {
+		const e = event as ToolCallEvent;
+		const result = await dispatch("PreToolUse", {
+			toolCallId: e.toolCallId,
+			toolName: e.toolName,
+			input: e.input,
+		});
+		if (result?.block) return { block: true, reason: result.reason };
+		return undefined;
+	}]);
+
+	handlers.set("tool_result", [async (event: unknown): Promise<ToolResultEventResult | undefined> => {
+		const e = event as ToolResultEvent;
+		await dispatch("PostToolUse", {
+			toolCallId: e.toolCallId,
+			toolName: e.toolName,
+			input: e.input,
+			content: e.content,
+			isError: e.isError,
+			details: e.details,
+		});
+		return undefined;
+	}]);
+
+	handlers.set("stop", [async (event: unknown) => {
+		const e = event as StopEvent;
+		await dispatch("Stop", { reason: e.reason });
+		return undefined;
+	}]);
+
+	handlers.set("notification", [async (event: unknown) => {
+		const e = event as NotificationEvent;
+		await dispatch("Notification", { kind: e.kind, message: e.message, details: e.details });
+		if (e.kind === "blocked") {
+			await dispatch("Blocked", { message: e.message, details: e.details });
+		}
+		return undefined;
+	}]);
+
+	handlers.set("session_end", [async (event: unknown) => {
+		const e = event as SessionEndEvent;
+		await dispatch("SessionEnd", { reason: e.reason, sessionFile: e.sessionFile });
+		return undefined;
+	}]);
+
+	handlers.set("before_commit", [async (event: unknown): Promise<BeforeCommitEventResult | undefined> => {
+		const e = event as BeforeCommitEvent;
+		const result = await dispatch("PreCommit", { message: e.message, files: e.files, cwd: e.cwd, author: e.author });
+		if (!result) return undefined;
+		if (result.block) return { cancel: true, reason: result.reason };
+		if (result.message !== undefined) return { message: result.message };
+		return undefined;
+	}]);
+
+	handlers.set("commit", [async (event: unknown) => {
+		const e = event as CommitEvent;
+		await dispatch("PostCommit", { sha: e.sha, message: e.message, files: e.files, cwd: e.cwd });
+		return undefined;
+	}]);
+
+	handlers.set("before_push", [async (event: unknown): Promise<BeforePushEventResult | undefined> => {
+		const e = event as BeforePushEvent;
+		const result = await dispatch("PrePush", { remote: e.remote, branch: e.branch, cwd: e.cwd });
+		if (result?.block) return { cancel: true, reason: result.reason };
+		return undefined;
+	}]);
+
+	handlers.set("push", [async (event: unknown) => {
+		const e = event as PushEvent;
+		await dispatch("PostPush", { remote: e.remote, branch: e.branch, cwd: e.cwd });
+		return undefined;
+	}]);
+
+	handlers.set("before_pr", [async (event: unknown): Promise<BeforePrEventResult | undefined> => {
+		const e = event as BeforePrEvent;
+		const result = await dispatch("PrePr", {
+			branch: e.branch,
+			targetBranch: e.targetBranch,
+			title: e.title,
+			body: e.body,
+			cwd: e.cwd,
+		});
+		if (!result) return undefined;
+		if (result.block) return { cancel: true, reason: result.reason };
+		if (result.title !== undefined || result.body !== undefined) {
+			return { title: result.title, body: result.body };
+		}
+		return undefined;
+	}]);
+
+	handlers.set("pr_opened", [async (event: unknown) => {
+		const e = event as PrOpenedEvent;
+		await dispatch("PostPr", { url: e.url, branch: e.branch, targetBranch: e.targetBranch, cwd: e.cwd });
+		return undefined;
+	}]);
+
+	handlers.set("before_verify", [async (event: unknown): Promise<BeforeVerifyEventResult | undefined> => {
+		const e = event as BeforeVerifyEvent;
+		const result = await dispatch("PreVerify", { unitType: e.unitType, unitId: e.unitId, cwd: e.cwd });
+		if (result?.block) return { cancel: true, reason: result.reason };
+		return undefined;
+	}]);
+
+	handlers.set("verify_result", [async (event: unknown) => {
+		const e = event as VerifyResultEvent;
+		await dispatch("PostVerify", {
+			passed: e.passed,
+			failures: e.failures,
+			unitType: e.unitType,
+			unitId: e.unitId,
+			cwd: e.cwd,
+		});
+		return undefined;
+	}]);
+
+	handlers.set("budget_threshold", [async (event: unknown): Promise<BudgetThresholdEventResult | undefined> => {
+		const e = event as BudgetThresholdEvent;
+		const result = await dispatch("BudgetThreshold", {
+			fraction: e.fraction,
+			spent: e.spent,
+			limit: e.limit,
+			currency: e.currency,
+		});
+		if (result?.action) return { action: result.action };
+		return undefined;
+	}]);
+
+	handlers.set("milestone_start", [async (event: unknown) => {
+		const e = event as MilestoneStartEvent;
+		await dispatch("PreMilestone", { milestoneId: e.milestoneId, title: e.title, cwd: e.cwd });
+		return undefined;
+	}]);
+
+	handlers.set("milestone_end", [async (event: unknown) => {
+		const e = event as MilestoneEndEvent;
+		await dispatch("PostMilestone", { milestoneId: e.milestoneId, status: e.status, cwd: e.cwd });
+		return undefined;
+	}]);
+
+	handlers.set("unit_start", [async (event: unknown) => {
+		const e = event as UnitStartEvent;
+		await dispatch("PreUnit", {
+			unitType: e.unitType,
+			unitId: e.unitId,
+			milestoneId: e.milestoneId,
+			cwd: e.cwd,
+		});
+		return undefined;
+	}]);
+
+	handlers.set("unit_end", [async (event: unknown) => {
+		const e = event as UnitEndEvent;
+		await dispatch("PostUnit", {
+			unitType: e.unitType,
+			unitId: e.unitId,
+			milestoneId: e.milestoneId,
+			status: e.status,
+			cwd: e.cwd,
+		});
+		return undefined;
+	}]);
+
+	handlers.set("session_before_compact", [async (event: unknown): Promise<SessionBeforeCompactResult | undefined> => {
+		const e = event as SessionBeforeCompactEvent;
+		const result = await dispatch("PreCompact", { branchEntries: e.branchEntries.length });
+		if (result?.block) return { cancel: true };
+		return undefined;
+	}]);
+
+	handlers.set("session_compact", [async (event: unknown) => {
+		const e = event as SessionCompactEvent;
+		await dispatch("PostCompact", { fromExtension: e.fromExtension });
+		return undefined;
+	}]);
+
+	const dispose = extensionRunner.installHookBridge("__hooks__", handlers);
+
+	return {
+		dispose,
+		async fireSessionStart() {
+			const payload: SessionStartEvent = { type: "session_start" };
+			await dispatch("SessionStart", { cwd, type: payload.type });
+		},
+		async fireSessionEnd(reason) {
+			await dispatch("SessionEnd", { reason });
+		},
+	};
+}

package/packages/pi-coding-agent/src/core/index.ts

@@ -15,6 +15,16 @@ export { type BashExecutorOptions, type BashResult, executeBash, executeBashWith
 export { FallbackResolver, type FallbackResult } from "./fallback-resolver.js";
 export type { CompactionResult } from "./compaction/index.js";
 export { createEventBus, type EventBus, type EventBusController } from "./event-bus.js";
+export {
+	createHooksRunner,
+	isProjectHooksTrusted,
+	type HookInvocation,
+	type HookName,
+	type HookScope,
+	type HookStdoutResult,
+	type HooksRunner,
+	type HooksRunnerOptions,
+} from "./hooks-runner.js";
 
 // Extensions system
 export {

package/packages/pi-coding-agent/src/core/lsp/lsp-integration.test.ts

@@ -14,6 +14,7 @@ import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
+import { spawnSync } from "node:child_process";
 
 // ---------------------------------------------------------------------------
 // Helpers — lightweight JSON-RPC over stdio (no dependency on our LSP code)
@@ -251,11 +252,23 @@ function fileToUri(filePath: string): string {
 	return `file://${path.resolve(filePath)}`;
 }
 
+function hasTypescriptLanguageServer(): boolean {
+	const probe = spawnSync("typescript-language-server", ["--help"], {
+		stdio: "ignore",
+	});
+	return probe.status === 0 || probe.status === 1;
+}
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
 
 test("LSP integration: typescript-language-server", async (t) => {
+	if (!hasTypescriptLanguageServer()) {
+		t.skip("typescript-language-server not installed in this environment");
+		return;
+	}
+
 	const { dir, cleanup } = createTempProject();
 	const mainPath = path.join(dir, "src", "main.ts");
 	const mathPath = path.join(dir, "src", "math.ts");

package/packages/pi-coding-agent/src/core/model-discovery.test.ts

@@ -5,6 +5,7 @@ import {
 	getDefaultTTL,
 	getDiscoverableProviders,
 	getDiscoveryAdapter,
+	supportsDiscoveryForApi,
 } from "./model-discovery.js";
 
 // ─── getDiscoveryAdapter ─────────────────────────────────────────────────────
@@ -52,6 +53,12 @@ describe("getDiscoveryAdapter", () => {
 		assert.equal(adapter.supportsDiscovery, false);
 	});
 
+	it("returns OpenAI-style adapter for unknown provider with OpenAI-compatible API", () => {
+		const adapter = getDiscoveryAdapter("my-proxy", ["openai-completions"]);
+		assert.equal(adapter.provider, "my-proxy");
+		assert.equal(adapter.supportsDiscovery, true);
+	});
+
 	it("static adapter fetchModels returns empty array", async () => {
 		const adapter = getDiscoveryAdapter("anthropic");
 		const models = await adapter.fetchModels("key");
@@ -123,3 +130,15 @@ describe("DISCOVERY_TTLS", () => {
 		}
 	});
 });
+
+describe("supportsDiscoveryForApi", () => {
+	it("returns true for OpenAI-compatible APIs", () => {
+		assert.equal(supportsDiscoveryForApi("openai-completions"), true);
+		assert.equal(supportsDiscoveryForApi("openai-responses"), true);
+	});
+
+	it("returns false for non-discoverable APIs", () => {
+		assert.equal(supportsDiscoveryForApi("anthropic-messages"), false);
+		assert.equal(supportsDiscoveryForApi(undefined), false);
+	});
+});

package/packages/pi-coding-agent/src/core/model-discovery.ts

@@ -26,6 +26,14 @@ export interface ProviderDiscoveryAdapter {
 	fetchModels(apiKey: string, baseUrl?: string): Promise<DiscoveredModel[]>;
 }
 
+export const OPENAI_COMPAT_DISCOVERY_APIS = new Set([
+	"openai",
+	"openai-completions",
+	"openai-responses",
+	"openai-codex-responses",
+	"azure-openai-responses",
+]);
+
 /** Per-provider TTLs in milliseconds */
 export const DISCOVERY_TTLS: Record<string, number> = {
 	ollama: 5 * 60 * 1000, // 5 minutes (local, models change often)
@@ -53,10 +61,77 @@ async function fetchWithTimeout(url: string, options: RequestInit = {}, timeoutM
 
 const OPENAI_EXCLUDED_PREFIXES = ["embedding", "tts", "dall-e", "whisper", "text-embedding", "davinci", "babbage"];
 
+function asPositiveNumber(value: unknown): number | undefined {
+	if (typeof value === "number" && Number.isFinite(value) && value > 0) return value;
+	if (typeof value === "string") {
+		const n = Number.parseFloat(value);
+		if (Number.isFinite(n) && n > 0) return n;
+	}
+	return undefined;
+}
+
+function pickFirstPositiveNumber(record: Record<string, unknown>, keys: string[]): number | undefined {
+	for (const key of keys) {
+		const value = asPositiveNumber(record[key]);
+		if (value !== undefined) return value;
+	}
+	return undefined;
+}
+
+function discoverInputModalities(rawModel: Record<string, unknown>, id: string): Array<"text" | "image"> {
+	const directModalities = rawModel.input_modalities;
+	const capabilitiesModalities = (rawModel.capabilities as Record<string, unknown> | undefined)?.input_modalities;
+	const source = Array.isArray(directModalities)
+		? directModalities
+		: Array.isArray(capabilitiesModalities)
+			? capabilitiesModalities
+			: [];
+	const supportsImage = source.some((m) => typeof m === "string" && /image|vision/i.test(m))
+		|| /vision|image|omni|multimodal/i.test(id);
+	return supportsImage ? ["text", "image"] : ["text"];
+}
+
+function parseOpenAICompatibleModel(rawModel: Record<string, unknown>): DiscoveredModel | undefined {
+	const id = typeof rawModel.id === "string" ? rawModel.id : "";
+	if (!id) return undefined;
+	if (OPENAI_EXCLUDED_PREFIXES.some((prefix) => id.startsWith(prefix))) return undefined;
+
+	const contextWindow = pickFirstPositiveNumber(rawModel, [
+		"context_window",
+		"context_length",
+		"max_context_length",
+		"max_input_tokens",
+		"input_token_limit",
+		"max_model_len",
+	]);
+	const maxTokens = pickFirstPositiveNumber(rawModel, [
+		"max_output_tokens",
+		"output_token_limit",
+		"max_completion_tokens",
+		"max_tokens",
+	]);
+	const reasoning = rawModel.reasoning === true
+		|| rawModel.supports_reasoning === true
+		|| ((rawModel.capabilities as Record<string, unknown> | undefined)?.reasoning === true);
+
+	return {
+		id,
+		name: typeof rawModel.name === "string" && rawModel.name.length > 0 ? rawModel.name : id,
+		contextWindow,
+		maxTokens,
+		reasoning,
+		input: discoverInputModalities(rawModel, id),
+	};
+}
+
 class OpenAIDiscoveryAdapter implements ProviderDiscoveryAdapter {
-	provider = "openai";
+	provider: string;
 	supportsDiscovery = true;
 
+	constructor(provider: string) {
+		this.provider = provider;
+	}
+
 	async fetchModels(apiKey: string, baseUrl?: string): Promise<DiscoveredModel[]> {
 		const url = `${baseUrl ?? "https://api.openai.com"}/v1/models`;
 		const response = await fetchWithTimeout(url, {
@@ -67,14 +142,10 @@ class OpenAIDiscoveryAdapter implements ProviderDiscoveryAdapter {
 			throw new Error(`OpenAI models API returned ${response.status}: ${response.statusText}`);
 		}
 
-		const data = (await response.json()) as { data: Array<{ id: string; owned_by?: string }> };
-		return data.data
-			.filter((m) => !OPENAI_EXCLUDED_PREFIXES.some((prefix) => m.id.startsWith(prefix)))
-			.map((m) => ({
-				id: m.id,
-				name: m.id,
-				input: ["text" as const, "image" as const],
-			}));
+		const data = (await response.json()) as { data?: Array<Record<string, unknown>> };
+		return (data.data ?? [])
+			.map((m) => parseOpenAICompatibleModel(m))
+			.filter((m): m is DiscoveredModel => !!m);
 	}
 }
 
@@ -207,7 +278,7 @@ class StaticDiscoveryAdapter implements ProviderDiscoveryAdapter {
 // ─── Registry ────────────────────────────────────────────────────────────────
 
 const adapters: Record<string, ProviderDiscoveryAdapter> = {
-	openai: new OpenAIDiscoveryAdapter(),
+	openai: new OpenAIDiscoveryAdapter("openai"),
 	ollama: new OllamaDiscoveryAdapter(),
 	openrouter: new OpenRouterDiscoveryAdapter(),
 	google: new GoogleDiscoveryAdapter(),
@@ -220,8 +291,24 @@ const adapters: Record<string, ProviderDiscoveryAdapter> = {
 	mistral: new StaticDiscoveryAdapter("mistral"),
 };
 
-export function getDiscoveryAdapter(provider: string): ProviderDiscoveryAdapter {
-	return adapters[provider] ?? new StaticDiscoveryAdapter(provider);
+export function supportsDiscoveryForApi(api: string | undefined): boolean {
+	if (!api) return false;
+	return OPENAI_COMPAT_DISCOVERY_APIS.has(api);
+}
+
+export function getDiscoveryAdapter(provider: string, providerApis?: Iterable<string>): ProviderDiscoveryAdapter {
+	const known = adapters[provider];
+	if (known) return known;
+
+	if (providerApis) {
+		for (const api of providerApis) {
+			if (supportsDiscoveryForApi(api)) {
+				return new OpenAIDiscoveryAdapter(provider);
+			}
+		}
+	}
+
+	return new StaticDiscoveryAdapter(provider);
 }
 
 export function getDiscoverableProviders(): string[] {