gsd-pi 2.16.0 → 2.18.0

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);
+	});
+});

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

@@ -0,0 +1,188 @@
+/**
+ * Safe read-modify-write for models.json with file locking.
+ * Prevents concurrent writes from corrupting the config file.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import lockfile from "proper-lockfile";
+import { getAgentDir } from "../config.js";
+
+interface ModelDefinition {
+	id: string;
+	name?: string;
+	api?: string;
+	baseUrl?: string;
+	reasoning?: boolean;
+	input?: ("text" | "image")[];
+	cost?: { input: number; output: number; cacheRead: number; cacheWrite: number };
+	contextWindow?: number;
+	maxTokens?: number;
+}
+
+interface ProviderConfig {
+	baseUrl?: string;
+	apiKey?: string;
+	api?: string;
+	headers?: Record<string, string>;
+	authHeader?: boolean;
+	models?: ModelDefinition[];
+	modelOverrides?: Record<string, Record<string, unknown>>;
+}
+
+interface ModelsConfig {
+	providers: Record<string, ProviderConfig>;
+}
+
+export class ModelsJsonWriter {
+	private modelsJsonPath: string;
+
+	constructor(modelsJsonPath?: string) {
+		this.modelsJsonPath = modelsJsonPath ?? join(getAgentDir(), "models.json");
+	}
+
+	/**
+	 * Add a model to a provider. Creates the provider if it doesn't exist.
+	 */
+	addModel(provider: string, model: ModelDefinition, providerConfig?: Partial<ProviderConfig>): void {
+		this.withLock((config) => {
+			if (!config.providers[provider]) {
+				config.providers[provider] = {
+					...providerConfig,
+					models: [],
+				};
+			}
+
+			const providerEntry = config.providers[provider];
+			if (!providerEntry.models) {
+				providerEntry.models = [];
+			}
+
+			// Replace existing model with same id, or append
+			const existingIndex = providerEntry.models.findIndex((m) => m.id === model.id);
+			if (existingIndex >= 0) {
+				providerEntry.models[existingIndex] = model;
+			} else {
+				providerEntry.models.push(model);
+			}
+
+			return config;
+		});
+	}
+
+	/**
+	 * Remove a model from a provider. Removes the provider if no models remain.
+	 */
+	removeModel(provider: string, modelId: string): void {
+		this.withLock((config) => {
+			const providerEntry = config.providers[provider];
+			if (!providerEntry?.models) return config;
+
+			providerEntry.models = providerEntry.models.filter((m) => m.id !== modelId);
+
+			// Clean up empty provider (no models and no overrides)
+			if (providerEntry.models.length === 0 && !providerEntry.modelOverrides) {
+				delete config.providers[provider];
+			}
+
+			return config;
+		});
+	}
+
+	/**
+	 * Set or update an entire provider configuration.
+	 */
+	setProvider(provider: string, providerConfig: ProviderConfig): void {
+		this.withLock((config) => {
+			config.providers[provider] = providerConfig;
+			return config;
+		});
+	}
+
+	/**
+	 * Remove a provider and all its models.
+	 */
+	removeProvider(provider: string): void {
+		this.withLock((config) => {
+			delete config.providers[provider];
+			return config;
+		});
+	}
+
+	/**
+	 * List all providers and their configurations.
+	 */
+	listProviders(): ModelsConfig {
+		return this.readConfig();
+	}
+
+	private readConfig(): ModelsConfig {
+		if (!existsSync(this.modelsJsonPath)) {
+			return { providers: {} };
+		}
+		try {
+			const content = readFileSync(this.modelsJsonPath, "utf-8");
+			return JSON.parse(content) as ModelsConfig;
+		} catch {
+			return { providers: {} };
+		}
+	}
+
+	private writeConfig(config: ModelsConfig): void {
+		const dir = dirname(this.modelsJsonPath);
+		if (!existsSync(dir)) {
+			mkdirSync(dir, { recursive: true });
+		}
+		writeFileSync(this.modelsJsonPath, JSON.stringify(config, null, 2), "utf-8");
+	}
+
+	private acquireLockWithRetry(): () => void {
+		const maxAttempts = 10;
+		const delayMs = 20;
+		let lastError: unknown;
+
+		// Ensure file exists for locking
+		const dir = dirname(this.modelsJsonPath);
+		if (!existsSync(dir)) {
+			mkdirSync(dir, { recursive: true });
+		}
+		if (!existsSync(this.modelsJsonPath)) {
+			writeFileSync(this.modelsJsonPath, JSON.stringify({ providers: {} }, null, 2), "utf-8");
+		}
+
+		for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+			try {
+				return lockfile.lockSync(this.modelsJsonPath, { realpath: false });
+			} catch (error) {
+				const code =
+					typeof error === "object" && error !== null && "code" in error
+						? String((error as { code?: unknown }).code)
+						: undefined;
+				if (code !== "ELOCKED" || attempt === maxAttempts) {
+					throw error;
+				}
+				lastError = error;
+				const start = Date.now();
+				while (Date.now() - start < delayMs) {
+					// Busy-wait (same pattern as auth-storage.ts)
+				}
+			}
+		}
+
+		throw (lastError as Error) ?? new Error("Failed to acquire models.json lock");
+	}
+
+	private withLock(fn: (config: ModelsConfig) => ModelsConfig): void {
+		let release: (() => void) | undefined;
+		try {
+			release = this.acquireLockWithRetry();
+			const config = this.readConfig();
+			const updated = fn(config);
+			this.writeConfig(updated);
+		} finally {
+			if (release) {
+				release();
+			}
+		}
+	}
+}

package/packages/pi-coding-agent/src/core/settings-manager.ts

@@ -79,6 +79,13 @@ export interface FallbackSettings {
 	chains?: Record<string, FallbackChainEntry[]>; // keyed by chain name
 }
 
+export interface ModelDiscoverySettings {
+	enabled?: boolean; // default: false
+	providers?: string[]; // limit discovery to specific providers
+	ttlMinutes?: number; // override default TTLs (in minutes)
+	autoRefreshOnModelSelect?: boolean; // default: false - refresh discovery when opening model selector
+}
+
 export type TransportSetting = Transport;
 
 /**
@@ -134,6 +141,7 @@ export interface Settings {
 	bashInterceptor?: BashInterceptorSettings;
 	taskIsolation?: TaskIsolationSettings;
 	fallback?: FallbackSettings;
+	modelDiscovery?: ModelDiscoverySettings;
 }
 
 /** Deep merge settings: project/overrides take precedence, nested objects merge recursively */
@@ -1076,4 +1084,17 @@ export class SettingsManager {
 			chains: this.getFallbackChains(),
 		};
 	}
+
+	getModelDiscoverySettings(): ModelDiscoverySettings {
+		return this.settings.modelDiscovery ?? {};
+	}
+
+	setModelDiscoveryEnabled(enabled: boolean): void {
+		if (!this.globalSettings.modelDiscovery) {
+			this.globalSettings.modelDiscovery = {};
+		}
+		this.globalSettings.modelDiscovery.enabled = enabled;
+		this.markModified("modelDiscovery", "enabled");
+		this.save();
+	}
 }

package/packages/pi-coding-agent/src/core/slash-commands.ts

@@ -28,6 +28,7 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 	{ name: "hotkeys", description: "Show all keyboard shortcuts" },
 	{ name: "fork", description: "Create a new fork from a previous message" },
 	{ name: "tree", description: "Navigate session tree (switch branches)" },
+	{ name: "provider", description: "Manage provider configuration" },
 	{ name: "login", description: "Login with OAuth provider" },
 	{ name: "logout", description: "Logout from OAuth provider" },
 	{ name: "new", description: "Start a new session" },