gsd-pi 2.16.0 → 2.18.0

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

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