gsd-pi 2.17.0 → 2.19.0

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

@@ -0,0 +1,231 @@
+/**
+ * Provider discovery adapters for runtime model enumeration.
+ * Each adapter implements ProviderDiscoveryAdapter to fetch models from provider APIs.
+ */
+
+export interface DiscoveredModel {
+	id: string;
+	name?: string;
+	contextWindow?: number;
+	maxTokens?: number;
+	reasoning?: boolean;
+	input?: ("text" | "image")[];
+	cost?: { input: number; output: number; cacheRead: number; cacheWrite: number };
+}
+
+export interface DiscoveryResult {
+	provider: string;
+	models: DiscoveredModel[];
+	fetchedAt: number;
+	error?: string;
+}
+
+export interface ProviderDiscoveryAdapter {
+	provider: string;
+	supportsDiscovery: boolean;
+	fetchModels(apiKey: string, baseUrl?: string): Promise<DiscoveredModel[]>;
+}
+
+/** Per-provider TTLs in milliseconds */
+export const DISCOVERY_TTLS: Record<string, number> = {
+	ollama: 5 * 60 * 1000, // 5 minutes (local, models change often)
+	openai: 60 * 60 * 1000, // 1 hour
+	google: 60 * 60 * 1000, // 1 hour
+	openrouter: 60 * 60 * 1000, // 1 hour
+	default: 24 * 60 * 60 * 1000, // 24 hours
+};
+
+export function getDefaultTTL(provider: string): number {
+	return DISCOVERY_TTLS[provider] ?? DISCOVERY_TTLS.default;
+}
+
+async function fetchWithTimeout(url: string, options: RequestInit = {}, timeoutMs = 5000): Promise<Response> {
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), timeoutMs);
+	try {
+		return await fetch(url, { ...options, signal: controller.signal });
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+
+// ─── OpenAI Adapter ──────────────────────────────────────────────────────────
+
+const OPENAI_EXCLUDED_PREFIXES = ["embedding", "tts", "dall-e", "whisper", "text-embedding", "davinci", "babbage"];
+
+class OpenAIDiscoveryAdapter implements ProviderDiscoveryAdapter {
+	provider = "openai";
+	supportsDiscovery = true;
+
+	async fetchModels(apiKey: string, baseUrl?: string): Promise<DiscoveredModel[]> {
+		const url = `${baseUrl ?? "https://api.openai.com"}/v1/models`;
+		const response = await fetchWithTimeout(url, {
+			headers: { Authorization: `Bearer ${apiKey}` },
+		});
+
+		if (!response.ok) {
+			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],
+			}));
+	}
+}
+
+// ─── Ollama Adapter ──────────────────────────────────────────────────────────
+
+class OllamaDiscoveryAdapter implements ProviderDiscoveryAdapter {
+	provider = "ollama";
+	supportsDiscovery = true;
+
+	async fetchModels(_apiKey: string, baseUrl?: string): Promise<DiscoveredModel[]> {
+		const url = `${baseUrl ?? "http://localhost:11434"}/api/tags`;
+		const response = await fetchWithTimeout(url);
+
+		if (!response.ok) {
+			throw new Error(`Ollama tags API returned ${response.status}: ${response.statusText}`);
+		}
+
+		const data = (await response.json()) as {
+			models: Array<{ name: string; size: number; details?: { parameter_size?: string } }>;
+		};
+
+		return (data.models ?? []).map((m) => ({
+			id: m.name,
+			name: m.name,
+			input: ["text" as const],
+		}));
+	}
+}
+
+// ─── OpenRouter Adapter ──────────────────────────────────────────────────────
+
+class OpenRouterDiscoveryAdapter implements ProviderDiscoveryAdapter {
+	provider = "openrouter";
+	supportsDiscovery = true;
+
+	async fetchModels(apiKey: string, baseUrl?: string): Promise<DiscoveredModel[]> {
+		const url = `${baseUrl ?? "https://openrouter.ai"}/api/v1/models`;
+		const response = await fetchWithTimeout(url, {
+			headers: { Authorization: `Bearer ${apiKey}` },
+		});
+
+		if (!response.ok) {
+			throw new Error(`OpenRouter models API returned ${response.status}: ${response.statusText}`);
+		}
+
+		const data = (await response.json()) as {
+			data: Array<{
+				id: string;
+				name: string;
+				context_length?: number;
+				top_provider?: { max_completion_tokens?: number };
+				pricing?: { prompt: string; completion: string };
+			}>;
+		};
+
+		return (data.data ?? []).map((m) => {
+			const cost =
+				m.pricing?.prompt !== undefined && m.pricing?.completion !== undefined
+					? {
+							input: parseFloat(m.pricing.prompt) * 1_000_000,
+							output: parseFloat(m.pricing.completion) * 1_000_000,
+							cacheRead: 0,
+							cacheWrite: 0,
+						}
+					: undefined;
+
+			return {
+				id: m.id,
+				name: m.name,
+				contextWindow: m.context_length,
+				maxTokens: m.top_provider?.max_completion_tokens,
+				cost,
+				input: ["text" as const, "image" as const],
+			};
+		});
+	}
+}
+
+// ─── Google/Gemini Adapter ───────────────────────────────────────────────────
+
+class GoogleDiscoveryAdapter implements ProviderDiscoveryAdapter {
+	provider = "google";
+	supportsDiscovery = true;
+
+	async fetchModels(apiKey: string, baseUrl?: string): Promise<DiscoveredModel[]> {
+		const url = `${baseUrl ?? "https://generativelanguage.googleapis.com"}/v1beta/models?key=${apiKey}`;
+		const response = await fetchWithTimeout(url);
+
+		if (!response.ok) {
+			throw new Error(`Google models API returned ${response.status}: ${response.statusText}`);
+		}
+
+		const data = (await response.json()) as {
+			models: Array<{
+				name: string;
+				displayName: string;
+				supportedGenerationMethods?: string[];
+				inputTokenLimit?: number;
+				outputTokenLimit?: number;
+			}>;
+		};
+
+		return (data.models ?? [])
+			.filter((m) => m.supportedGenerationMethods?.includes("generateContent"))
+			.map((m) => ({
+				id: m.name.replace("models/", ""),
+				name: m.displayName,
+				contextWindow: m.inputTokenLimit,
+				maxTokens: m.outputTokenLimit,
+				input: ["text" as const, "image" as const],
+			}));
+	}
+}
+
+// ─── Static Adapter (no discovery) ───────────────────────────────────────────
+
+class StaticDiscoveryAdapter implements ProviderDiscoveryAdapter {
+	provider: string;
+	supportsDiscovery = false;
+
+	constructor(provider: string) {
+		this.provider = provider;
+	}
+
+	async fetchModels(): Promise<DiscoveredModel[]> {
+		return [];
+	}
+}
+
+// ─── Registry ────────────────────────────────────────────────────────────────
+
+const adapters: Record<string, ProviderDiscoveryAdapter> = {
+	openai: new OpenAIDiscoveryAdapter(),
+	ollama: new OllamaDiscoveryAdapter(),
+	openrouter: new OpenRouterDiscoveryAdapter(),
+	google: new GoogleDiscoveryAdapter(),
+	anthropic: new StaticDiscoveryAdapter("anthropic"),
+	bedrock: new StaticDiscoveryAdapter("bedrock"),
+	"azure-openai": new StaticDiscoveryAdapter("azure-openai"),
+	groq: new StaticDiscoveryAdapter("groq"),
+	cerebras: new StaticDiscoveryAdapter("cerebras"),
+	xai: new StaticDiscoveryAdapter("xai"),
+	mistral: new StaticDiscoveryAdapter("mistral"),
+};
+
+export function getDiscoveryAdapter(provider: string): ProviderDiscoveryAdapter {
+	return adapters[provider] ?? new StaticDiscoveryAdapter(provider);
+}
+
+export function getDiscoverableProviders(): string[] {
+	return Object.entries(adapters)
+		.filter(([, adapter]) => adapter.supportsDiscovery)
+		.map(([name]) => name);
+}

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

@@ -0,0 +1,135 @@
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+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";
+
+let testDir: string;
+
+beforeEach(() => {
+	testDir = join(tmpdir(), `model-registry-discovery-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+	mkdirSync(testDir, { recursive: true });
+});
+
+afterEach(() => {
+	try {
+		rmSync(testDir, { recursive: true, force: true });
+	} catch {
+		// Cleanup best-effort
+	}
+});
+
+// ─── discovery cache integration ─────────────────────────────────────────────
+
+describe("ModelDiscoveryCache — integration with discovery", () => {
+	it("cache respects provider-specific TTLs", () => {
+		const cachePath = join(testDir, "cache.json");
+		const cache = new ModelDiscoveryCache(cachePath);
+
+		cache.set("ollama", [{ id: "llama2" }]);
+		const entry = cache.get("ollama");
+		assert.ok(entry);
+		assert.equal(entry.ttlMs, getDefaultTTL("ollama"));
+	});
+
+	it("cache uses custom TTL when provided", () => {
+		const cachePath = join(testDir, "cache.json");
+		const cache = new ModelDiscoveryCache(cachePath);
+
+		cache.set("openai", [{ id: "gpt-4o" }], 999);
+		const entry = cache.get("openai");
+		assert.ok(entry);
+		assert.equal(entry.ttlMs, 999);
+	});
+});
+
+// ─── adapter resolution ─────────────────────────────────────────────────────
+
+describe("Discovery adapter resolution", () => {
+	it("all discoverable providers have adapters", () => {
+		const providers = getDiscoverableProviders();
+		for (const provider of providers) {
+			const adapter = getDiscoveryAdapter(provider);
+			assert.equal(adapter.supportsDiscovery, true, `${provider} should support discovery`);
+		}
+	});
+
+	it("static adapters return empty model lists", async () => {
+		const staticProviders = ["anthropic", "bedrock", "azure-openai", "groq", "cerebras"];
+		for (const provider of staticProviders) {
+			const adapter = getDiscoveryAdapter(provider);
+			assert.equal(adapter.supportsDiscovery, false, `${provider} should not support discovery`);
+			const models = await adapter.fetchModels("dummy-key");
+			assert.deepEqual(models, [], `${provider} should return empty models`);
+		}
+	});
+});
+
+// ─── AuthStorage hasAuth for discovery ───────────────────────────────────────
+
+describe("AuthStorage — hasAuth for discovery providers", () => {
+	it("returns false for providers without auth", () => {
+		const storage = AuthStorage.inMemory({});
+		assert.equal(storage.hasAuth("openai"), false);
+		assert.equal(storage.hasAuth("ollama"), false);
+	});
+
+	it("returns true for providers with stored keys", () => {
+		const storage = AuthStorage.inMemory({
+			openai: { type: "api_key" as const, key: "sk-test" },
+		});
+		assert.equal(storage.hasAuth("openai"), true);
+		assert.equal(storage.hasAuth("ollama"), false);
+	});
+});
+
+// ─── cache persistence across instances ──────────────────────────────────────
+
+describe("ModelDiscoveryCache — persistence", () => {
+	it("data survives across cache instances", () => {
+		const cachePath = join(testDir, "persist.json");
+
+		const cache1 = new ModelDiscoveryCache(cachePath);
+		cache1.set("openai", [
+			{ id: "gpt-4o", name: "GPT-4o", contextWindow: 128000 },
+			{ id: "gpt-4o-mini", name: "GPT-4o Mini" },
+		]);
+
+		const cache2 = new ModelDiscoveryCache(cachePath);
+		const entry = cache2.get("openai");
+		assert.ok(entry);
+		assert.equal(entry.models.length, 2);
+		assert.equal(entry.models[0].contextWindow, 128000);
+	});
+
+	it("clear persists across instances", () => {
+		const cachePath = join(testDir, "clear.json");
+
+		const cache1 = new ModelDiscoveryCache(cachePath);
+		cache1.set("openai", [{ id: "gpt-4o" }]);
+		cache1.clear("openai");
+
+		const cache2 = new ModelDiscoveryCache(cachePath);
+		assert.equal(cache2.get("openai"), undefined);
+	});
+});
+
+// ─── discovery TTL values ────────────────────────────────────────────────────
+
+describe("Discovery TTL configuration", () => {
+	it("ollama has shortest TTL (local models change often)", () => {
+		const ollamaTTL = getDefaultTTL("ollama");
+		const openaiTTL = getDefaultTTL("openai");
+		assert.ok(ollamaTTL < openaiTTL, "ollama TTL should be shorter than openai");
+	});
+
+	it("unknown providers get default TTL", () => {
+		const customTTL = getDefaultTTL("my-custom-provider");
+		const defaultTTL = getDefaultTTL("default");
+		// Unknown providers should get the same TTL as the explicit "default" key
+		assert.equal(customTTL, defaultTTL);
+	});
+});

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

@@ -24,6 +24,9 @@ import { existsSync, readFileSync } from "fs";
 import { join } from "path";
 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 { clearConfigValueCache, resolveConfigValue, resolveHeaders } from "./resolve-config-value.js";
 
 const Ajv = (AjvModule as any).default || AjvModule;
@@ -221,6 +224,8 @@ export const clearApiKeyCache = clearConfigValueCache;
  */
 export class ModelRegistry {
 	private models: Model<Api>[] = [];
+	private discoveredModels: Model<Api>[] = [];
+	private discoveryCache: ModelDiscoveryCache;
 	private customProviderApiKeys: Map<string, string> = new Map();
 	private registeredProviders: Map<string, ProviderConfigInput> = new Map();
 	private loadError: string | undefined = undefined;
@@ -229,6 +234,8 @@ export class ModelRegistry {
 		readonly authStorage: AuthStorage,
 		private modelsJsonPath: string | undefined = join(getAgentDir(), "models.json"),
 	) {
+		this.discoveryCache = new ModelDiscoveryCache();
+
 		// Set up fallback resolver for custom provider API keys
 		this.authStorage.setFallbackResolver((provider) => {
 			const keyConfig = this.customProviderApiKeys.get(provider);
@@ -666,6 +673,106 @@ export class ModelRegistry {
 			});
 		}
 	}
+
+	/**
+	 * Discover models from all providers that support discovery.
+	 * Results are cached and merged into the registry (never overrides existing models).
+	 */
+	async discoverModels(providers?: string[]): Promise<DiscoveryResult[]> {
+		const targetProviders = providers ?? getDiscoverableProviders();
+		const results: DiscoveryResult[] = [];
+
+		for (const providerName of targetProviders) {
+			const adapter = getDiscoveryAdapter(providerName);
+			if (!adapter.supportsDiscovery) continue;
+
+			// Skip if cache is still fresh
+			if (!this.discoveryCache.isStale(providerName)) {
+				const cached = this.discoveryCache.get(providerName);
+				if (cached) {
+					results.push({
+						provider: providerName,
+						models: cached.models,
+						fetchedAt: cached.fetchedAt,
+					});
+					continue;
+				}
+			}
+
+			try {
+				const apiKey = await this.authStorage.getApiKey(providerName);
+				if (!apiKey && providerName !== "ollama") continue;
+
+				const models = await adapter.fetchModels(apiKey ?? "", undefined);
+				this.discoveryCache.set(providerName, models);
+				results.push({
+					provider: providerName,
+					models,
+					fetchedAt: Date.now(),
+				});
+			} catch (error) {
+				results.push({
+					provider: providerName,
+					models: [],
+					fetchedAt: Date.now(),
+					error: error instanceof Error ? error.message : String(error),
+				});
+			}
+		}
+
+		// Convert and merge discovered models
+		this.discoveredModels = this.convertDiscoveredModels(results);
+		return results;
+	}
+
+	/**
+	 * Get all models including discovered ones.
+	 * Discovered models are appended but never override existing models.
+	 */
+	getAllWithDiscovered(): Model<Api>[] {
+		const existingIds = new Set(this.models.map((m) => `${m.provider}/${m.id}`));
+		const unique = this.discoveredModels.filter((m) => !existingIds.has(`${m.provider}/${m.id}`));
+		return [...this.models, ...unique];
+	}
+
+	/**
+	 * Check if a model was added via discovery (not built-in or custom).
+	 */
+	isDiscovered(model: Model<Api>): boolean {
+		return this.discoveredModels.some((m) => m.provider === model.provider && m.id === model.id);
+	}
+
+	/**
+	 * Get the discovery cache instance.
+	 */
+	getDiscoveryCache(): ModelDiscoveryCache {
+		return this.discoveryCache;
+	}
+
+	/**
+	 * Convert DiscoveryResult[] into Model<Api>[] with default values.
+	 */
+	private convertDiscoveredModels(results: DiscoveryResult[]): Model<Api>[] {
+		const converted: Model<Api>[] = [];
+		for (const result of results) {
+			if (result.error) continue;
+			for (const dm of result.models) {
+				converted.push({
+					id: dm.id,
+					name: dm.name ?? dm.id,
+					api: "openai" as Api,
+					provider: result.provider,
+					baseUrl: "",
+					reasoning: dm.reasoning ?? false,
+					input: dm.input ?? ["text"],
+					cost: dm.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+					contextWindow: dm.contextWindow ?? 128000,
+					maxTokens: dm.maxTokens ?? 16384,
+				} as Model<Api>);
+			}
+		}
+		return converted;
+	}
 }
 
 /**

package/packages/pi-coding-agent/src/core/models-json-writer.test.ts

@@ -0,0 +1,145 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { ModelsJsonWriter } from "./models-json-writer.js";
+
+let testDir: string;
+let modelsJsonPath: string;
+
+beforeEach(() => {
+	testDir = join(tmpdir(), `models-json-writer-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+	mkdirSync(testDir, { recursive: true });
+	modelsJsonPath = join(testDir, "models.json");
+});
+
+afterEach(() => {
+	try {
+		rmSync(testDir, { recursive: true, force: true });
+	} catch {
+		// Cleanup best-effort
+	}
+});
+
+function readModels(): Record<string, unknown> {
+	return JSON.parse(readFileSync(modelsJsonPath, "utf-8"));
+}
+
+// ─── addModel ────────────────────────────────────────────────────────────────
+
+describe("ModelsJsonWriter — addModel", () => {
+	it("creates file and adds model to new provider", () => {
+		const writer = new ModelsJsonWriter(modelsJsonPath);
+		writer.addModel("openai", { id: "gpt-4o", name: "GPT-4o" }, { baseUrl: "https://api.openai.com", apiKey: "env:OPENAI_API_KEY", api: "openai" });
+
+		const config = readModels() as any;
+		assert.ok(config.providers.openai);
+		assert.equal(config.providers.openai.models.length, 1);
+		assert.equal(config.providers.openai.models[0].id, "gpt-4o");
+	});
+
+	it("appends model to existing provider", () => {
+		const writer = new ModelsJsonWriter(modelsJsonPath);
+		writer.addModel("openai", { id: "gpt-4o" }, { baseUrl: "https://api.openai.com", apiKey: "env:OPENAI_API_KEY", api: "openai" });
+		writer.addModel("openai", { id: "gpt-4o-mini" });
+
+		const config = readModels() as any;
+		assert.equal(config.providers.openai.models.length, 2);
+	});
+
+	it("replaces model with same id", () => {
+		const writer = new ModelsJsonWriter(modelsJsonPath);
+		writer.addModel("openai", { id: "gpt-4o", name: "Old" }, { baseUrl: "https://api.openai.com", apiKey: "env:OPENAI_API_KEY", api: "openai" });
+		writer.addModel("openai", { id: "gpt-4o", name: "New" });
+
+		const config = readModels() as any;
+		assert.equal(config.providers.openai.models.length, 1);
+		assert.equal(config.providers.openai.models[0].name, "New");
+	});
+});
+
+// ─── removeModel ─────────────────────────────────────────────────────────────
+
+describe("ModelsJsonWriter — removeModel", () => {
+	it("removes a model from provider", () => {
+		const writer = new ModelsJsonWriter(modelsJsonPath);
+		writer.addModel("openai", { id: "gpt-4o" }, { baseUrl: "https://api.openai.com", apiKey: "env:OPENAI_API_KEY", api: "openai" });
+		writer.addModel("openai", { id: "gpt-4o-mini" });
+
+		writer.removeModel("openai", "gpt-4o");
+
+		const config = readModels() as any;
+		assert.equal(config.providers.openai.models.length, 1);
+		assert.equal(config.providers.openai.models[0].id, "gpt-4o-mini");
+	});
+
+	it("removes provider when last model is removed", () => {
+		const writer = new ModelsJsonWriter(modelsJsonPath);
+		writer.addModel("openai", { id: "gpt-4o" }, { baseUrl: "https://api.openai.com", apiKey: "env:OPENAI_API_KEY", api: "openai" });
+
+		writer.removeModel("openai", "gpt-4o");
+
+		const config = readModels() as any;
+		assert.equal(config.providers.openai, undefined);
+	});
+
+	it("handles removing from nonexistent provider", () => {
+		const writer = new ModelsJsonWriter(modelsJsonPath);
+		// Should not throw
+		writer.removeModel("nonexistent", "model-id");
+	});
+});
+
+// ─── setProvider / removeProvider ────────────────────────────────────────────
+
+describe("ModelsJsonWriter — provider operations", () => {
+	it("sets a provider configuration", () => {
+		const writer = new ModelsJsonWriter(modelsJsonPath);
+		writer.setProvider("custom", {
+			baseUrl: "http://localhost:8080",
+			apiKey: "test-key",
+			api: "openai",
+			models: [{ id: "local-model" }],
+		});
+
+		const config = readModels() as any;
+		assert.ok(config.providers.custom);
+		assert.equal(config.providers.custom.baseUrl, "http://localhost:8080");
+	});
+
+	it("removes a provider", () => {
+		const writer = new ModelsJsonWriter(modelsJsonPath);
+		writer.setProvider("custom", { baseUrl: "http://localhost:8080" });
+		writer.removeProvider("custom");
+
+		const config = readModels() as any;
+		assert.equal(config.providers.custom, undefined);
+	});
+
+	it("handles removing nonexistent provider", () => {
+		const writer = new ModelsJsonWriter(modelsJsonPath);
+		writer.removeProvider("nonexistent");
+		// Should not throw
+	});
+});
+
+// ─── listProviders ───────────────────────────────────────────────────────────
+
+describe("ModelsJsonWriter — listProviders", () => {
+	it("returns empty config when file does not exist", () => {
+		const writer = new ModelsJsonWriter(join(testDir, "nonexistent.json"));
+		const config = writer.listProviders();
+		assert.deepEqual(config, { providers: {} });
+	});
+
+	it("returns current provider config", () => {
+		const writer = new ModelsJsonWriter(modelsJsonPath);
+		writer.setProvider("openai", { baseUrl: "https://api.openai.com" });
+		writer.setProvider("ollama", { baseUrl: "http://localhost:11434" });
+
+		const config = writer.listProviders();
+		assert.ok(config.providers.openai);
+		assert.ok(config.providers.ollama);
+	});
+});