gsd-pi 2.76.0-dev.4100bd590 → 2.76.0-dev.82e249f7b

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[] {

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

@@ -6,6 +6,7 @@ import { afterEach, beforeEach, describe, it } from "node:test";
 import { AuthStorage } from "./auth-storage.js";
 import { ModelDiscoveryCache } from "./discovery-cache.js";
 import { getDefaultTTL, getDiscoverableProviders, getDiscoveryAdapter } from "./model-discovery.js";
+import { ModelRegistry } from "./model-registry.js";
 
 let testDir: string;
 
@@ -133,3 +134,77 @@ describe("Discovery TTL configuration", () => {
 		assert.equal(customTTL, defaultTTL);
 	});
 });
+
+describe("ModelRegistry discovery — OpenAI-compatible custom providers", () => {
+	it("discovers custom OpenAI-compatible providers and maps capability metadata", async () => {
+		const providerName = `minimax-openai-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+		const modelsPath = join(testDir, "models.json");
+		writeFileSync(
+			modelsPath,
+			JSON.stringify(
+				{
+					providers: {
+						[providerName]: {
+							baseUrl: "https://api.minimax.example",
+							apiKey: "minimax-test-key",
+							api: "openai-completions",
+							models: [{ id: "bootstrap-model" }],
+						},
+					},
+				},
+				null,
+				2,
+			),
+			"utf-8",
+		);
+
+		const prevFetch = globalThis.fetch;
+		let requestedUrl = "";
+		globalThis.fetch = (async (input: string | URL | Request) => {
+			requestedUrl = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+			return new Response(
+				JSON.stringify({
+					data: [
+						{
+							id: "MiniMax-M2.7-highspeed",
+							name: "MiniMax M2.7 Highspeed",
+							context_window: 165000,
+							max_output_tokens: 32768,
+							supports_reasoning: true,
+							input_modalities: ["text", "image"],
+						},
+					],
+				}),
+				{
+					status: 200,
+					headers: { "content-type": "application/json" },
+				},
+			);
+		}) as typeof globalThis.fetch;
+
+		try {
+			const registry = new ModelRegistry(AuthStorage.inMemory({}), modelsPath);
+			// Guard against global cache leakage from prior test runs.
+			registry.getDiscoveryCache().clear(providerName);
+			const results = await registry.discoverModels([providerName]);
+
+			const discovery = results.find((r) => r.provider === providerName);
+			assert.ok(discovery, "discovery result should include custom provider");
+			assert.equal(discovery?.error, undefined, "custom provider discovery should succeed");
+			assert.equal(requestedUrl, "https://api.minimax.example/v1/models");
+
+			const discovered = registry
+				.getAllWithDiscovered()
+				.find((m) => m.provider === providerName && m.id === "MiniMax-M2.7-highspeed");
+			assert.ok(discovered, "discovered model should be merged into model list");
+			assert.equal(discovered?.api, "openai-completions");
+			assert.equal(discovered?.baseUrl, "https://api.minimax.example");
+			assert.equal(discovered?.contextWindow, 165000);
+			assert.equal(discovered?.maxTokens, 32768);
+			assert.equal(discovered?.reasoning, true);
+			assert.deepEqual(discovered?.input, ["text", "image"]);
+		} finally {
+			globalThis.fetch = prevFetch;
+		}
+	});
+});

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

@@ -29,7 +29,7 @@ import { getAgentDir } from "../config.js";
 import type { AuthStorage } from "./auth-storage.js";
 import { ModelDiscoveryCache } from "./discovery-cache.js";
 import type { DiscoveredModel, DiscoveryResult } from "./model-discovery.js";
-import { getDefaultTTL, getDiscoverableProviders, getDiscoveryAdapter } from "./model-discovery.js";
+import { getDefaultTTL, getDiscoverableProviders, getDiscoveryAdapter, supportsDiscoveryForApi } from "./model-discovery.js";
 import { clearConfigValueCache, resolveConfigValue, resolveHeaders } from "./resolve-config-value.js";
 import { isLocalModel } from "./local-model-check.js";
 
@@ -788,11 +788,12 @@ export class ModelRegistry {
 	 * Results are cached and merged into the registry (never overrides existing models).
 	 */
 	async discoverModels(providers?: string[]): Promise<DiscoveryResult[]> {
-		const targetProviders = providers ?? getDiscoverableProviders();
+		const targetProviders = providers ?? this.getAutoDiscoverableProviders();
 		const results: DiscoveryResult[] = [];
 
 		for (const providerName of targetProviders) {
-			const adapter = getDiscoveryAdapter(providerName);
+			const providerApis = this.getProviderApis(providerName);
+			const adapter = getDiscoveryAdapter(providerName, providerApis);
 			if (!adapter.supportsDiscovery) continue;
 
 			// Skip if cache is still fresh
@@ -812,8 +813,10 @@ export class ModelRegistry {
 				const apiKey = await this.authStorage.getApiKey(providerName);
 				if (!apiKey && !this.isProviderRequestReady(providerName)) continue;
 
-				const models = await adapter.fetchModels(apiKey ?? "", undefined);
-				this.discoveryCache.set(providerName, models);
+				const baseUrl = this.getProviderBaseUrl(providerName);
+				const models = await adapter.fetchModels(apiKey ?? "", baseUrl);
+				const ttlMs = this.getDiscoveryTtl(providerName, providerApis);
+				this.discoveryCache.set(providerName, models, ttlMs);
 				results.push({
 					provider: providerName,
 					models,
@@ -865,24 +868,97 @@ export class ModelRegistry {
 		const converted: Model<Api>[] = [];
 		for (const result of results) {
 			if (result.error) continue;
+			const providerDefaults = this.getDiscoveryProviderDefaults(result.provider);
 			for (const dm of result.models) {
 				converted.push({
 					id: dm.id,
 					name: dm.name ?? dm.id,
-					api: "openai" as Api,
+					api: providerDefaults.api,
 					provider: result.provider,
-					baseUrl: "",
+					baseUrl: providerDefaults.baseUrl,
 					reasoning: dm.reasoning ?? false,
-					input: dm.input ?? ["text"],
+					input: dm.input ?? providerDefaults.input,
 					cost: dm.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-					contextWindow: dm.contextWindow ?? 128000,
-					maxTokens: dm.maxTokens ?? 16384,
+					contextWindow: dm.contextWindow ?? providerDefaults.contextWindow,
+					maxTokens: dm.maxTokens ?? providerDefaults.maxTokens,
 				} as Model<Api>);
 			}
 		}
 		return converted;
 	}
 
+	private getProviderApis(provider: string): Set<string> {
+		const apis = new Set<string>();
+		for (const model of this.models) {
+			if (model.provider === provider && typeof model.api === "string" && model.api.length > 0) {
+				apis.add(model.api);
+			}
+		}
+
+		const providerConfig = this.registeredProviders.get(provider);
+		if (providerConfig?.api) apis.add(providerConfig.api);
+		for (const modelDef of providerConfig?.models ?? []) {
+			if (modelDef.api) apis.add(modelDef.api);
+		}
+		return apis;
+	}
+
+	private getAutoDiscoverableProviders(): string[] {
+		const discoverable = new Set<string>(getDiscoverableProviders());
+		for (const provider of new Set(this.models.map((m) => m.provider))) {
+			const apis = this.getProviderApis(provider);
+			for (const api of apis) {
+				if (supportsDiscoveryForApi(api)) {
+					discoverable.add(provider);
+					break;
+				}
+			}
+		}
+		return [...discoverable];
+	}
+
+	private getProviderBaseUrl(provider: string): string | undefined {
+		const fromModels = this.models.find((m) => m.provider === provider && typeof m.baseUrl === "string" && m.baseUrl.length > 0);
+		if (fromModels?.baseUrl) return fromModels.baseUrl;
+		return this.registeredProviders.get(provider)?.baseUrl;
+	}
+
+	private getDiscoveryProviderDefaults(provider: string): {
+		api: Api;
+		baseUrl: string;
+		input: ("text" | "image")[];
+		contextWindow: number;
+		maxTokens: number;
+	} {
+		const first = this.models.find((m) => m.provider === provider);
+		if (first) {
+			return {
+				api: first.api,
+				baseUrl: first.baseUrl,
+				input: first.input,
+				contextWindow: first.contextWindow,
+				maxTokens: first.maxTokens,
+			};
+		}
+
+		return {
+			api: "openai-completions",
+			baseUrl: this.registeredProviders.get(provider)?.baseUrl ?? "",
+			input: ["text"],
+			contextWindow: 128000,
+			maxTokens: 16384,
+		};
+	}
+
+	private getDiscoveryTtl(provider: string, providerApis: Set<string>): number {
+		for (const api of providerApis) {
+			if (supportsDiscoveryForApi(api)) {
+				return getDefaultTTL("openai");
+			}
+		}
+		return getDefaultTTL(provider);
+	}
+
 	/**
 	 * Check if a model's baseUrl points to a local endpoint.
 	 * Delegates to standalone isLocalModel() function.

package/packages/pi-coding-agent/src/modes/interactive/components/provider-manager.ts

@@ -12,7 +12,7 @@ import {
 	type TUI,
 } from "@gsd/pi-tui";
 import type { AuthStorage } from "../../../core/auth-storage.js";
-import { getDiscoverableProviders } from "../../../core/model-discovery.js";
+import { getDiscoverableProviders, getDiscoveryAdapter } from "../../../core/model-discovery.js";
 import { providerDisplayName } from "./model-selector.js";
 import type { ModelRegistry } from "../../../core/model-registry.js";
 import { ModelsJsonWriter } from "../../../core/models-json-writer.js";
@@ -102,12 +102,21 @@ export class ProviderManagerComponent extends Container implements Focusable {
 
 		this.providers = Array.from(providerNames)
 			.sort()
-			.map((name) => ({
-				name,
-				hasAuth: this.authStorage.hasAuth(name),
-				supportsDiscovery: discoverableSet.has(name),
-				modelCount: providerModelCounts.get(name) ?? 0,
-			}));
+			.map((name) => {
+				const providerApis = new Set(
+					allModels
+						.filter((m) => m.provider === name)
+						.map((m) => m.api)
+						.filter((api): api is string => typeof api === "string" && api.length > 0),
+				);
+				return {
+					name,
+					hasAuth: this.authStorage.hasAuth(name),
+					supportsDiscovery:
+						discoverableSet.has(name) || getDiscoveryAdapter(name, providerApis).supportsDiscovery,
+					modelCount: providerModelCounts.get(name) ?? 0,
+				};
+			});
 		this.clampSelectedIndex();
 	}