gsd-pi 2.76.0 → 2.77.0-dev.2daa994b6

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-auth-header.test.ts

@@ -0,0 +1,44 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { AuthStorage } from "./auth-storage.js";
+import { ModelRegistry } from "./model-registry.js";
+
+function createRegistry(): ModelRegistry {
+	const authStorage = {
+		setFallbackResolver: () => {},
+		onCredentialChange: () => {},
+		getOAuthProviders: () => [],
+		get: () => undefined,
+		hasAuth: () => false,
+		getApiKey: async () => undefined,
+	} as unknown as AuthStorage;
+
+	return new ModelRegistry(authStorage, undefined);
+}
+
+describe("ModelRegistry authHeader wiring (#3874)", () => {
+	it("adds Authorization bearer header for custom providers with authHeader enabled", () => {
+		const registry = createRegistry();
+		registry.registerProvider("bigmodel", {
+			baseUrl: "https://open.bigmodel.cn/api/anthropic",
+			api: "anthropic-messages",
+			apiKey: "bigmodel-test-key",
+			authHeader: true,
+			models: [
+				{
+					id: "glm-5.1",
+					name: "glm-5.1",
+					reasoning: false,
+					input: ["text"],
+					cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+					contextWindow: 200000,
+					maxTokens: 128000,
+				},
+			],
+		});
+
+		const model = registry.getAll().find((m) => m.provider === "bigmodel" && m.id === "glm-5.1");
+		assert.ok(model, "custom provider model should be registered");
+		assert.equal(model.headers?.Authorization, "Bearer bigmodel-test-key");
+	});
+});

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

@@ -15,11 +15,11 @@ function createRegistry(hasAuthFn?: (provider: string) => boolean): ModelRegistr
 		getApiKey: async () => undefined,
 	} as unknown as AuthStorage;
 
-	return new ModelRegistry(authStorage, undefined);
+	return new ModelRegistry(authStorage, "");
 }
 
 function createInMemoryRegistry(data: AuthStorageData = {}): ModelRegistry {
-	return new ModelRegistry(AuthStorage.inMemory(data), undefined);
+	return new ModelRegistry(AuthStorage.inMemory(data), "");
 }
 
 function createProviderModel(id: string, api?: string): NonNullable<Parameters<ModelRegistry["registerProvider"]>[1]["models"]>[number] {
@@ -39,6 +39,10 @@ function findModel(registry: ModelRegistry, provider: string, id: string): Model
 	return registry.getAvailable().find((m) => m.provider === provider && m.id === id);
 }
 
+function availableModelIds(registry: ModelRegistry): Set<string> {
+	return new Set(registry.getAvailable().map((model) => `${model.provider}/${model.id}`));
+}
+
 function makeModel(provider: string, id: string, api: string): Model<Api> {
 	return {
 		id,
@@ -93,6 +97,22 @@ function createStreamSpy(): {
 // ─── Registration ─────────────────────────────────────────────────────────────
 
 describe("ModelRegistry authMode — registration", () => {
+	it("includes GPT-5.5 in the authenticated all-models menu backing list", () => {
+		const registry = createInMemoryRegistry({
+			openai: { type: "api_key", key: "sk-test" },
+			"openai-codex": {
+				type: "oauth",
+				access: "codex-access",
+				refresh: "codex-refresh",
+				expires: Date.now() + 60_000,
+			},
+		});
+
+		const ids = availableModelIds(registry);
+		assert.ok(ids.has("openai/gpt-5.5"), "all-models menu backing list should include openai/gpt-5.5");
+		assert.ok(ids.has("openai-codex/gpt-5.5"), "all-models menu backing list should include openai-codex/gpt-5.5");
+	});
+
 	it("registers externalCli provider with streamSimple and without apiKey/oauth", () => {
 		const registry = createRegistry();
 		const spy = createStreamSpy();

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

@@ -0,0 +1,245 @@
+/**
+ * Regression tests for #4563:
+ *   Bug 1 — custom/Anthropic-compatible models were hard-capped to 32 k output tokens
+ *   Bug 2 — custom models in models.json could not declare capabilities.supportsXhigh
+ */
+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 { ModelRegistry } from "./model-registry.js";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+let testDir: string;
+
+beforeEach(() => {
+	testDir = join(
+		tmpdir(),
+		`model-registry-custom-caps-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+	);
+	mkdirSync(testDir, { recursive: true });
+});
+
+afterEach(() => {
+	try {
+		rmSync(testDir, { recursive: true, force: true });
+	} catch {
+		// best-effort cleanup
+	}
+});
+
+function createRegistry(modelsJson: object): ModelRegistry {
+	const path = join(testDir, "models.json");
+	writeFileSync(path, JSON.stringify(modelsJson));
+	return new ModelRegistry(AuthStorage.inMemory(), path);
+}
+
+function writeModelsJson(obj: object): string {
+	const path = join(testDir, "models.json");
+	writeFileSync(path, JSON.stringify(obj));
+	return path;
+}
+
+// ─── Bug 1: 32 k cap must not apply to custom/OpenAI-compatible models ────────
+
+describe("Bug 1 — maxTokens cap (#4563)", () => {
+	it("custom openai-completions model with maxTokens > 32 k is not capped", () => {
+		const registry = createRegistry({
+			providers: {
+				"kimi-custom": {
+					baseUrl: "https://api.example.com/v1",
+					apiKey: "sk-test",
+					api: "openai-completions",
+					models: [
+						{
+							id: "kimi-k2.6-code-preview",
+							name: "Kimi K2.6 Code Preview",
+							maxTokens: 131072,
+							contextWindow: 262144,
+						},
+					],
+				},
+			},
+		});
+
+		const model = registry.getAll().find((m) => m.id === "kimi-k2.6-code-preview");
+		assert.ok(model, "model should be registered");
+		assert.equal(
+			model.maxTokens,
+			131072,
+			"maxTokens must be preserved as declared — not capped to 32 000",
+		);
+	});
+
+	it("custom model with maxTokens exactly 32 k is not affected", () => {
+		const registry = createRegistry({
+			providers: {
+				"custom-provider": {
+					baseUrl: "https://api.example.com/v1",
+					apiKey: "sk-test",
+					api: "openai-completions",
+					models: [{ id: "model-32k", maxTokens: 32000, contextWindow: 128000 }],
+				},
+			},
+		});
+
+		const model = registry.getAll().find((m) => m.id === "model-32k");
+		assert.ok(model);
+		assert.equal(model.maxTokens, 32000);
+	});
+
+	it("custom model with maxTokens 65 k is stored at full value", () => {
+		const registry = createRegistry({
+			providers: {
+				"dashscope-custom": {
+					baseUrl: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
+					apiKey: "sk-test",
+					api: "openai-completions",
+					models: [
+						{
+							id: "qwen3.5-plus",
+							name: "Qwen3.5 Plus",
+							maxTokens: 65536,
+							contextWindow: 1000000,
+						},
+					],
+				},
+			},
+		});
+
+		const model = registry.getAll().find((m) => m.id === "qwen3.5-plus" && m.provider === "dashscope-custom");
+		assert.ok(model);
+		assert.equal(model.maxTokens, 65536);
+	});
+});
+
+// ─── Bug 2: capabilities.supportsXhigh must be declarable in models.json ──────
+
+describe("Bug 2 — capabilities.supportsXhigh in models.json (#4563)", () => {
+	it("model with capabilities.supportsXhigh: true surfaces the flag", () => {
+		const registry = createRegistry({
+			providers: {
+				"kimi-custom": {
+					baseUrl: "https://api.example.com/v1",
+					apiKey: "sk-test",
+					api: "anthropic-messages",
+					models: [
+						{
+							id: "kimi-k2.6-code-preview",
+							name: "Kimi K2.6 Code Preview",
+							maxTokens: 131072,
+							contextWindow: 262144,
+							capabilities: { supportsXhigh: true },
+						},
+					],
+				},
+			},
+		});
+
+		const model = registry.getAll().find((m) => m.id === "kimi-k2.6-code-preview");
+		assert.ok(model, "model should be registered");
+		assert.equal(
+			model.capabilities?.supportsXhigh,
+			true,
+			"supportsXhigh must be true as declared in models.json",
+		);
+	});
+
+	it("model without capabilities declaration has no supportsXhigh", () => {
+		const registry = createRegistry({
+			providers: {
+				"plain-provider": {
+					baseUrl: "https://api.example.com/v1",
+					apiKey: "sk-test",
+					api: "openai-completions",
+					models: [{ id: "plain-model", maxTokens: 16384, contextWindow: 128000 }],
+				},
+			},
+		});
+
+		const model = registry.getAll().find((m) => m.id === "plain-model");
+		assert.ok(model);
+		// supportsXhigh should be absent or explicitly false — never implicitly true
+		assert.ok(
+			!model.capabilities?.supportsXhigh,
+			"supportsXhigh must not be set for models that don't declare it",
+		);
+	});
+
+	it("capabilities.supportsXhigh: false is respected", () => {
+		const registry = createRegistry({
+			providers: {
+				"explicit-provider": {
+					baseUrl: "https://api.example.com/v1",
+					apiKey: "sk-test",
+					api: "openai-completions",
+					models: [
+						{
+							id: "no-xhigh-model",
+							capabilities: { supportsXhigh: false },
+						},
+					],
+				},
+			},
+		});
+
+		const model = registry.getAll().find((m) => m.id === "no-xhigh-model");
+		assert.ok(model);
+		assert.equal(model.capabilities?.supportsXhigh, false);
+	});
+
+	it("supportsXhigh declared in models.json is not overwritten by capability patches", () => {
+		// The capability-patches system must not overwrite an explicit declaration in models.json.
+		// applyCapabilityPatches uses spread: { ...patch.caps, ...model.capabilities }
+		// so model.capabilities wins. This test verifies the precedence end-to-end.
+		const registry = createRegistry({
+			providers: {
+				"compat-provider": {
+					baseUrl: "https://api.example.com/v1",
+					apiKey: "sk-test",
+					api: "openai-completions",
+					models: [
+						{
+							id: "custom-xhigh-model",
+							capabilities: { supportsXhigh: true },
+						},
+					],
+				},
+			},
+		});
+
+		const model = registry.getAll().find((m) => m.id === "custom-xhigh-model");
+		assert.ok(model);
+		assert.equal(model.capabilities?.supportsXhigh, true);
+	});
+
+	it("modelOverrides can set capabilities.supportsXhigh on built-in models", () => {
+		// A user-facing override in models.json should be able to add supportsXhigh
+		// to a built-in model that doesn't declare it.
+		const path = writeModelsJson({
+			providers: {
+				anthropic: {
+					modelOverrides: {
+						"claude-3-5-haiku-20241022": {
+							capabilities: { supportsXhigh: true },
+						},
+					},
+				},
+			},
+		});
+
+		const registry = new ModelRegistry(AuthStorage.inMemory(), path);
+		const model = registry.getAll().find(
+			(m) => m.provider === "anthropic" && m.id === "claude-3-5-haiku-20241022",
+		);
+		assert.ok(model, "built-in model must still be present");
+		assert.equal(
+			model.capabilities?.supportsXhigh,
+			true,
+			"modelOverrides must be able to set capabilities.supportsXhigh",
+		);
+	});
+});

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