gsd-pi 2.17.0 → 2.19.0

package/packages/pi-coding-agent/src/cli/args.ts

@@ -38,6 +38,11 @@ export interface Args {
 	themes?: string[];
 	noThemes?: boolean;
 	listModels?: string | true;
+	discover?: boolean;
+	addProvider?: string;
+	addProviderBaseUrl?: string;
+	addProviderApiKey?: string;
+	discoverModels?: string | true;
 	offline?: boolean;
 	verbose?: boolean;
 	messages: string[];
@@ -150,6 +155,18 @@ export function parseArgs(args: string[], extensionFlags?: Map<string, { type: "
 			} else {
 				result.listModels = true;
 			}
+		} else if (arg === "--discover") {
+			result.discover = true;
+		} else if (arg === "--add-provider" && i + 1 < args.length) {
+			result.addProvider = args[++i];
+		} else if (arg === "--base-url" && i + 1 < args.length) {
+			result.addProviderBaseUrl = args[++i];
+		} else if (arg === "--discover-models") {
+			if (i + 1 < args.length && !args[i + 1].startsWith("-") && !args[i + 1].startsWith("@")) {
+				result.discoverModels = args[++i];
+			} else {
+				result.discoverModels = true;
+			}
 		} else if (arg === "--verbose") {
 			result.verbose = true;
 		} else if (arg === "--offline") {
@@ -219,6 +236,10 @@ ${chalk.bold("Options:")}
   --no-themes                    Disable theme discovery and loading
   --export <file>                Export session file to HTML and exit
   --list-models [search]         List available models (with optional fuzzy search)
+  --discover                     Include discovered models in --list-models output
+  --discover-models [provider]   Discover models from provider APIs (all or specific)
+  --add-provider <name>          Add a provider to models.json (use with --base-url, --api-key)
+  --base-url <url>               Base URL for --add-provider
   --verbose                      Force verbose startup (overrides quietStartup setting)
   --offline                      Disable startup network operations (same as PI_OFFLINE=1)
   --help, -h                     Show this help

package/packages/pi-coding-agent/src/cli/list-models.ts

@@ -1,11 +1,18 @@
 /**
- * List available models with optional fuzzy search
+ * List available models with optional fuzzy search and discovery support
  */
 
 import type { Api, Model } from "@gsd/pi-ai";
 import { fuzzyFilter } from "@gsd/pi-tui";
 import type { ModelRegistry } from "../core/model-registry.js";
 
+export interface ListModelsOptions {
+	/** Include discovered models in output */
+	discover?: boolean;
+	/** Search pattern for fuzzy filtering */
+	searchPattern?: string;
+}
+
 /**
  * Format a number as human-readable (e.g., 200000 -> "200K", 1000000 -> "1M")
  */
@@ -22,10 +29,48 @@ function formatTokenCount(count: number): string {
 }
 
 /**
- * List available models, optionally filtered by search pattern
+ * Discover models from provider APIs and print results.
  */
-export async function listModels(modelRegistry: ModelRegistry, searchPattern?: string): Promise<void> {
-	const models = modelRegistry.getAvailable();
+export async function discoverAndPrintModels(
+	modelRegistry: ModelRegistry,
+	provider?: string,
+): Promise<void> {
+	const providers = provider ? [provider] : undefined;
+
+	console.log("Discovering models...");
+	const results = await modelRegistry.discoverModels(providers);
+
+	for (const result of results) {
+		if (result.error) {
+			console.log(`  ${result.provider}: error - ${result.error}`);
+		} else {
+			console.log(`  ${result.provider}: ${result.models.length} models found`);
+		}
+	}
+}
+
+/**
+ * List available models, optionally filtered by search pattern.
+ * Accepts either a string (backward compat) or ListModelsOptions.
+ */
+export async function listModels(
+	modelRegistry: ModelRegistry,
+	optionsOrSearch?: string | ListModelsOptions,
+): Promise<void> {
+	const options: ListModelsOptions =
+		typeof optionsOrSearch === "string"
+			? { searchPattern: optionsOrSearch }
+			: optionsOrSearch ?? {};
+
+	// If discover flag is set, run discovery first
+	if (options.discover) {
+		await modelRegistry.discoverModels();
+	}
+
+	// Get models — include discovered if discovery was run
+	const models = options.discover
+		? modelRegistry.getAllWithDiscovered()
+		: modelRegistry.getAvailable();
 
 	if (models.length === 0) {
 		console.log("No models available. Set API keys in environment variables.");
@@ -34,12 +79,12 @@ export async function listModels(modelRegistry: ModelRegistry, searchPattern?: s
 
 	// Apply fuzzy filter if search pattern provided
 	let filteredModels: Model<Api>[] = models;
-	if (searchPattern) {
-		filteredModels = fuzzyFilter(models, searchPattern, (m) => `${m.provider} ${m.id}`);
+	if (options.searchPattern) {
+		filteredModels = fuzzyFilter(models, options.searchPattern, (m) => `${m.provider} ${m.id}`);
 	}
 
 	if (filteredModels.length === 0) {
-		console.log(`No models matching "${searchPattern}"`);
+		console.log(`No models matching "${options.searchPattern}"`);
 		return;
 	}
 
@@ -53,15 +98,19 @@ export async function listModels(modelRegistry: ModelRegistry, searchPattern?: s
 	});
 
 	// Calculate column widths
-	const rows = filteredModels.map((m) => ({
-		provider: m.provider,
-		model: m.id,
-		name: m.name,
-		context: formatTokenCount(m.contextWindow),
-		maxOut: formatTokenCount(m.maxTokens),
-		thinking: m.reasoning ? "yes" : "no",
-		images: m.input.includes("image") ? "yes" : "no",
-	}));
+	const rows = filteredModels.map((m) => {
+		const isDiscovered = options.discover && modelRegistry.isDiscovered(m);
+		return {
+			provider: m.provider,
+			model: m.id,
+			name: m.name,
+			context: formatTokenCount(m.contextWindow),
+			maxOut: formatTokenCount(m.maxTokens),
+			thinking: m.reasoning ? "yes" : "no",
+			images: m.input.includes("image") ? "yes" : "no",
+			badge: isDiscovered ? "[discovered]" : "",
+		};
+	});
 
 	const headers = {
 		provider: "provider",
@@ -71,6 +120,7 @@ export async function listModels(modelRegistry: ModelRegistry, searchPattern?: s
 		maxOut: "max-out",
 		thinking: "thinking",
 		images: "images",
+		badge: "",
 	};
 
 	const widths = {
@@ -105,7 +155,10 @@ export async function listModels(modelRegistry: ModelRegistry, searchPattern?: s
 			row.maxOut.padEnd(widths.maxOut),
 			row.thinking.padEnd(widths.thinking),
 			row.images.padEnd(widths.images),
-		].join("  ");
+			row.badge,
+		]
+			.join("  ")
+			.trimEnd();
 		console.log(line);
 	}
 }

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

@@ -0,0 +1,170 @@
+import assert from "node:assert/strict";
+import { existsSync, 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 { ModelDiscoveryCache } from "./discovery-cache.js";
+
+let testDir: string;
+let cachePath: string;
+
+beforeEach(() => {
+	testDir = join(tmpdir(), `discovery-cache-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+	mkdirSync(testDir, { recursive: true });
+	cachePath = join(testDir, "discovery-cache.json");
+});
+
+afterEach(() => {
+	try {
+		rmSync(testDir, { recursive: true, force: true });
+	} catch {
+		// Cleanup best-effort
+	}
+});
+
+// ─── basic operations ────────────────────────────────────────────────────────
+
+describe("ModelDiscoveryCache — basic operations", () => {
+	it("starts with no entries", () => {
+		const cache = new ModelDiscoveryCache(cachePath);
+		assert.equal(cache.get("openai"), undefined);
+	});
+
+	it("stores and retrieves models", () => {
+		const cache = new ModelDiscoveryCache(cachePath);
+		const models = [{ id: "gpt-4o", name: "GPT-4o" }];
+		cache.set("openai", models);
+
+		const entry = cache.get("openai");
+		assert.ok(entry);
+		assert.deepEqual(entry.models, models);
+		assert.ok(entry.fetchedAt > 0);
+		assert.ok(entry.ttlMs > 0);
+	});
+
+	it("persists to disk and reloads", () => {
+		const cache1 = new ModelDiscoveryCache(cachePath);
+		cache1.set("openai", [{ id: "gpt-4o" }]);
+
+		const cache2 = new ModelDiscoveryCache(cachePath);
+		const entry = cache2.get("openai");
+		assert.ok(entry);
+		assert.equal(entry.models[0].id, "gpt-4o");
+	});
+
+	it("clear removes a specific provider", () => {
+		const cache = new ModelDiscoveryCache(cachePath);
+		cache.set("openai", [{ id: "gpt-4o" }]);
+		cache.set("google", [{ id: "gemini-pro" }]);
+
+		cache.clear("openai");
+		assert.equal(cache.get("openai"), undefined);
+		assert.ok(cache.get("google"));
+	});
+
+	it("clear without provider removes all entries", () => {
+		const cache = new ModelDiscoveryCache(cachePath);
+		cache.set("openai", [{ id: "gpt-4o" }]);
+		cache.set("google", [{ id: "gemini-pro" }]);
+
+		cache.clear();
+		assert.equal(cache.get("openai"), undefined);
+		assert.equal(cache.get("google"), undefined);
+	});
+});
+
+// ─── staleness ───────────────────────────────────────────────────────────────
+
+describe("ModelDiscoveryCache — staleness", () => {
+	it("newly set entries are not stale", () => {
+		const cache = new ModelDiscoveryCache(cachePath);
+		cache.set("openai", [{ id: "gpt-4o" }]);
+		assert.equal(cache.isStale("openai"), false);
+	});
+
+	it("missing providers are stale", () => {
+		const cache = new ModelDiscoveryCache(cachePath);
+		assert.equal(cache.isStale("unknown"), true);
+	});
+
+	it("entries with expired TTL are stale", () => {
+		const cache = new ModelDiscoveryCache(cachePath);
+		cache.set("openai", [{ id: "gpt-4o" }], 1); // 1ms TTL
+
+		// Wait for TTL to expire
+		const start = Date.now();
+		while (Date.now() - start < 5) {
+			// busy wait
+		}
+
+		assert.equal(cache.isStale("openai"), true);
+	});
+});
+
+// ─── getAll ──────────────────────────────────────────────────────────────────
+
+describe("ModelDiscoveryCache — getAll", () => {
+	it("returns non-stale entries by default", () => {
+		const cache = new ModelDiscoveryCache(cachePath);
+		cache.set("openai", [{ id: "gpt-4o" }]);
+		cache.set("stale", [{ id: "old" }], 1);
+
+		// Wait for stale TTL
+		const start = Date.now();
+		while (Date.now() - start < 5) {
+			// busy wait
+		}
+
+		const all = cache.getAll();
+		assert.ok(all.has("openai"));
+		assert.ok(!all.has("stale"));
+	});
+
+	it("returns all entries when includeStale is true", () => {
+		const cache = new ModelDiscoveryCache(cachePath);
+		cache.set("openai", [{ id: "gpt-4o" }]);
+		cache.set("stale", [{ id: "old" }], 1);
+
+		// Wait for stale TTL
+		const start = Date.now();
+		while (Date.now() - start < 5) {
+			// busy wait
+		}
+
+		const all = cache.getAll(true);
+		assert.ok(all.has("openai"));
+		assert.ok(all.has("stale"));
+	});
+});
+
+// ─── edge cases ──────────────────────────────────────────────────────────────
+
+describe("ModelDiscoveryCache — edge cases", () => {
+	it("handles corrupted cache file gracefully", () => {
+		writeFileSync(cachePath, "not valid json", "utf-8");
+		const cache = new ModelDiscoveryCache(cachePath);
+		assert.equal(cache.get("openai"), undefined);
+	});
+
+	it("handles wrong version gracefully", () => {
+		writeFileSync(cachePath, JSON.stringify({ version: 99, entries: {} }), "utf-8");
+		const cache = new ModelDiscoveryCache(cachePath);
+		assert.equal(cache.get("openai"), undefined);
+	});
+
+	it("handles missing cache file", () => {
+		const cache = new ModelDiscoveryCache(join(testDir, "nonexistent", "cache.json"));
+		assert.equal(cache.get("openai"), undefined);
+	});
+
+	it("overwrites existing entry for same provider", () => {
+		const cache = new ModelDiscoveryCache(cachePath);
+		cache.set("openai", [{ id: "gpt-4o" }]);
+		cache.set("openai", [{ id: "gpt-4o-mini" }]);
+
+		const entry = cache.get("openai");
+		assert.ok(entry);
+		assert.equal(entry.models.length, 1);
+		assert.equal(entry.models[0].id, "gpt-4o-mini");
+	});
+});

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

@@ -0,0 +1,97 @@
+/**
+ * Disk-based cache for discovered models.
+ * Stores results at {agentDir}/discovery-cache.json with per-provider TTLs.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { getAgentDir } from "../config.js";
+import { type DiscoveredModel, getDefaultTTL } from "./model-discovery.js";
+
+export interface DiscoveryCacheEntry {
+	models: DiscoveredModel[];
+	fetchedAt: number;
+	ttlMs: number;
+}
+
+export interface DiscoveryCacheData {
+	version: 1;
+	entries: Record<string, DiscoveryCacheEntry>;
+}
+
+export class ModelDiscoveryCache {
+	private data: DiscoveryCacheData;
+	private cachePath: string;
+
+	constructor(cachePath?: string) {
+		this.cachePath = cachePath ?? join(getAgentDir(), "discovery-cache.json");
+		this.data = { version: 1, entries: {} };
+		this.load();
+	}
+
+	get(provider: string): DiscoveryCacheEntry | undefined {
+		const entry = this.data.entries[provider];
+		return entry;
+	}
+
+	set(provider: string, models: DiscoveredModel[], ttlMs?: number): void {
+		this.data.entries[provider] = {
+			models,
+			fetchedAt: Date.now(),
+			ttlMs: ttlMs ?? getDefaultTTL(provider),
+		};
+		this.save();
+	}
+
+	isStale(provider: string): boolean {
+		const entry = this.data.entries[provider];
+		if (!entry) return true;
+		return Date.now() - entry.fetchedAt > entry.ttlMs;
+	}
+
+	clear(provider?: string): void {
+		if (provider) {
+			delete this.data.entries[provider];
+		} else {
+			this.data.entries = {};
+		}
+		this.save();
+	}
+
+	getAll(includeStale = false): Map<string, DiscoveryCacheEntry> {
+		const result = new Map<string, DiscoveryCacheEntry>();
+		for (const [provider, entry] of Object.entries(this.data.entries)) {
+			if (includeStale || !this.isStale(provider)) {
+				result.set(provider, entry);
+			}
+		}
+		return result;
+	}
+
+	load(): void {
+		try {
+			if (existsSync(this.cachePath)) {
+				const content = readFileSync(this.cachePath, "utf-8");
+				const parsed = JSON.parse(content) as DiscoveryCacheData;
+				if (parsed.version === 1 && parsed.entries) {
+					this.data = parsed;
+				}
+			}
+		} catch {
+			// Corrupted or unreadable cache — start fresh
+			this.data = { version: 1, entries: {} };
+		}
+	}
+
+	save(): void {
+		try {
+			const dir = dirname(this.cachePath);
+			if (!existsSync(dir)) {
+				mkdirSync(dir, { recursive: true });
+			}
+			writeFileSync(this.cachePath, JSON.stringify(this.data, null, 2), "utf-8");
+		} catch {
+			// Silently ignore write failures (read-only FS, permissions, etc.)
+		}
+	}
+}

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

@@ -0,0 +1,125 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	DISCOVERY_TTLS,
+	getDefaultTTL,
+	getDiscoverableProviders,
+	getDiscoveryAdapter,
+} from "./model-discovery.js";
+
+// ─── getDiscoveryAdapter ─────────────────────────────────────────────────────
+
+describe("getDiscoveryAdapter", () => {
+	it("returns an adapter for openai", () => {
+		const adapter = getDiscoveryAdapter("openai");
+		assert.equal(adapter.provider, "openai");
+		assert.equal(adapter.supportsDiscovery, true);
+	});
+
+	it("returns an adapter for ollama", () => {
+		const adapter = getDiscoveryAdapter("ollama");
+		assert.equal(adapter.provider, "ollama");
+		assert.equal(adapter.supportsDiscovery, true);
+	});
+
+	it("returns an adapter for openrouter", () => {
+		const adapter = getDiscoveryAdapter("openrouter");
+		assert.equal(adapter.provider, "openrouter");
+		assert.equal(adapter.supportsDiscovery, true);
+	});
+
+	it("returns an adapter for google", () => {
+		const adapter = getDiscoveryAdapter("google");
+		assert.equal(adapter.provider, "google");
+		assert.equal(adapter.supportsDiscovery, true);
+	});
+
+	it("returns a static adapter for anthropic", () => {
+		const adapter = getDiscoveryAdapter("anthropic");
+		assert.equal(adapter.provider, "anthropic");
+		assert.equal(adapter.supportsDiscovery, false);
+	});
+
+	it("returns a static adapter for bedrock", () => {
+		const adapter = getDiscoveryAdapter("bedrock");
+		assert.equal(adapter.provider, "bedrock");
+		assert.equal(adapter.supportsDiscovery, false);
+	});
+
+	it("returns a static adapter for unknown providers", () => {
+		const adapter = getDiscoveryAdapter("unknown-provider");
+		assert.equal(adapter.provider, "unknown-provider");
+		assert.equal(adapter.supportsDiscovery, false);
+	});
+
+	it("static adapter fetchModels returns empty array", async () => {
+		const adapter = getDiscoveryAdapter("anthropic");
+		const models = await adapter.fetchModels("key");
+		assert.deepEqual(models, []);
+	});
+});
+
+// ─── getDiscoverableProviders ────────────────────────────────────────────────
+
+describe("getDiscoverableProviders", () => {
+	it("returns only providers that support discovery", () => {
+		const providers = getDiscoverableProviders();
+		assert.ok(providers.includes("openai"));
+		assert.ok(providers.includes("ollama"));
+		assert.ok(providers.includes("openrouter"));
+		assert.ok(providers.includes("google"));
+		assert.ok(!providers.includes("anthropic"));
+		assert.ok(!providers.includes("bedrock"));
+	});
+
+	it("returns an array of strings", () => {
+		const providers = getDiscoverableProviders();
+		assert.ok(Array.isArray(providers));
+		for (const p of providers) {
+			assert.equal(typeof p, "string");
+		}
+	});
+});
+
+// ─── getDefaultTTL ───────────────────────────────────────────────────────────
+
+describe("getDefaultTTL", () => {
+	it("returns 5 minutes for ollama", () => {
+		assert.equal(getDefaultTTL("ollama"), 5 * 60 * 1000);
+	});
+
+	it("returns 1 hour for openai", () => {
+		assert.equal(getDefaultTTL("openai"), 60 * 60 * 1000);
+	});
+
+	it("returns 1 hour for google", () => {
+		assert.equal(getDefaultTTL("google"), 60 * 60 * 1000);
+	});
+
+	it("returns 1 hour for openrouter", () => {
+		assert.equal(getDefaultTTL("openrouter"), 60 * 60 * 1000);
+	});
+
+	it("returns 24 hours for unknown providers", () => {
+		assert.equal(getDefaultTTL("some-custom"), 24 * 60 * 60 * 1000);
+	});
+});
+
+// ─── DISCOVERY_TTLS ──────────────────────────────────────────────────────────
+
+describe("DISCOVERY_TTLS", () => {
+	it("has expected keys", () => {
+		assert.ok("ollama" in DISCOVERY_TTLS);
+		assert.ok("openai" in DISCOVERY_TTLS);
+		assert.ok("google" in DISCOVERY_TTLS);
+		assert.ok("openrouter" in DISCOVERY_TTLS);
+		assert.ok("default" in DISCOVERY_TTLS);
+	});
+
+	it("all values are positive numbers", () => {
+		for (const [, value] of Object.entries(DISCOVERY_TTLS)) {
+			assert.equal(typeof value, "number");
+			assert.ok(value > 0);
+		}
+	});
+});