gsd-pi 2.73.1-dev.d987996 → 2.74.0-dev.0306a2e

package/packages/pi-ai/src/models/index.ts

@@ -0,0 +1,106 @@
+import { MODELS } from "./generated/index.js";
+import { CUSTOM_MODELS } from "./custom.js";
+import { CAPABILITY_PATCHES, applyCapabilityPatches } from "./capability-patches.js";
+import type { Api, KnownProvider, Model, Usage } from "../types.js";
+
+const modelRegistry: Map<string, Map<string, Model<Api>>> = new Map();
+
+// Initialize registry from auto-generated MODELS (models.dev catalog)
+for (const [provider, models] of Object.entries(MODELS)) {
+	const providerModels = new Map<string, Model<Api>>();
+	for (const [id, model] of Object.entries(models)) {
+		providerModels.set(id, model as Model<Api>);
+	}
+	modelRegistry.set(provider, providerModels);
+}
+
+// Merge manually-maintained custom providers that are NOT in models.dev.
+// Custom models are additive — they never overwrite generated entries.
+// See: https://github.com/gsd-build/gsd-2/issues/2339
+for (const [provider, models] of Object.entries(CUSTOM_MODELS)) {
+	if (!modelRegistry.has(provider)) {
+		modelRegistry.set(provider, new Map<string, Model<Api>>());
+	}
+	const providerModels = modelRegistry.get(provider)!;
+	for (const [id, model] of Object.entries(models)) {
+		if (!providerModels.has(id)) {
+			providerModels.set(id, model as Model<Api>);
+		}
+	}
+}
+
+// Apply patches to the static registry at module load
+for (const [, providerModels] of modelRegistry) {
+	for (const [id, model] of providerModels) {
+		for (const patch of CAPABILITY_PATCHES) {
+			if (patch.match(model)) {
+				providerModels.set(id, {
+					...model,
+					capabilities: { ...patch.caps, ...model.capabilities },
+				});
+				break;
+			}
+		}
+	}
+}
+
+/** Providers that have entries in the generated MODELS constant */
+type GeneratedProvider = keyof typeof MODELS & KnownProvider;
+
+type ModelApi<
+	TProvider extends GeneratedProvider,
+	TModelId extends keyof (typeof MODELS)[TProvider],
+> = (typeof MODELS)[TProvider][TModelId] extends { api: infer TApi } ? (TApi extends Api ? TApi : never) : never;
+
+export function getModel<TProvider extends GeneratedProvider, TModelId extends keyof (typeof MODELS)[TProvider]>(
+	provider: TProvider,
+	modelId: TModelId,
+): Model<ModelApi<TProvider, TModelId>> {
+	const providerModels = modelRegistry.get(provider);
+	return providerModels?.get(modelId as string) as Model<ModelApi<TProvider, TModelId>>;
+}
+
+export function getProviders(): KnownProvider[] {
+	return Array.from(modelRegistry.keys()) as KnownProvider[];
+}
+
+export function getModels<TProvider extends KnownProvider>(
+	provider: TProvider,
+): Model<Api>[] {
+	const models = modelRegistry.get(provider);
+	return models ? (Array.from(models.values()) as Model<Api>[]) : [];
+}
+
+export function calculateCost<TApi extends Api>(model: Model<TApi>, usage: Usage): Usage["cost"] {
+	usage.cost.input = (model.cost.input / 1000000) * usage.input;
+	usage.cost.output = (model.cost.output / 1000000) * usage.output;
+	usage.cost.cacheRead = (model.cost.cacheRead / 1000000) * usage.cacheRead;
+	usage.cost.cacheWrite = (model.cost.cacheWrite / 1000000) * usage.cacheWrite;
+	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+	return usage.cost;
+}
+
+/**
+ * Check if a model supports xhigh thinking level.
+ *
+ * Reads from `model.capabilities.supportsXhigh` — set via CAPABILITY_PATCHES
+ * for generated models or declared directly in custom model definitions.
+ * Do not add model-ID or provider-name checks here; update CAPABILITY_PATCHES instead.
+ */
+export function supportsXhigh<TApi extends Api>(model: Model<TApi>): boolean {
+	return model.capabilities?.supportsXhigh ?? false;
+}
+
+/**
+ * Check if two models are equal by comparing both their id and provider.
+ * Returns false if either model is null or undefined.
+ */
+export function modelsAreEqual<TApi extends Api>(
+	a: Model<TApi> | null | undefined,
+	b: Model<TApi> | null | undefined,
+): boolean {
+	if (!a || !b) return false;
+	return a.id === b.id && a.provider === b.provider;
+}
+
+export { MODELS, applyCapabilityPatches };

package/packages/pi-ai/src/models.generated.test.ts

@@ -1,7 +1,6 @@
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { MODELS } from "./models.generated.js";
-import { getModel, getModels, getProviders } from "./models.js";
+import { MODELS, getModel, getModels, getProviders } from "./models/index.js";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Regression: qwen/qwen3.6-plus missing from OpenRouter (issue #3582)

package/packages/pi-ai/src/models.test.ts

@@ -7,8 +7,8 @@ import type { Api, Model } from "./types.js";
 // Custom provider preservation (regression: #2339)
 //
 // Custom providers (like alibaba-coding-plan) are manually maintained and
-// NOT sourced from models.dev. They must survive models.generated.ts
-// regeneration by living in models.custom.ts.
+// NOT sourced from models.dev. They must survive generated catalog
+// regeneration by living in models/custom.ts.
 // ═══════════════════════════════════════════════════════════════════════════
 
 describe("model registry — custom providers", () => {
@@ -68,7 +68,7 @@ describe("model registry — custom providers", () => {
 	it("getModel retrieves alibaba-coding-plan models by provider+id", () => {
 		// Use type assertion to test runtime behavior — alibaba-coding-plan may come
 		// from custom models rather than the generated file, so the narrow
-		// GeneratedProvider type doesn't include it until models.custom.ts is merged.
+		// GeneratedProvider type doesn't include it until models/custom.ts is merged.
 		const model = getModel("alibaba-coding-plan" as any, "qwen3.5-plus" as any);
 		assert.ok(model, "Expected getModel to return a model for alibaba-coding-plan/qwen3.5-plus");
 		assert.equal(model.id, "qwen3.5-plus");
@@ -92,11 +92,12 @@ describe("model registry — custom zai provider (GLM-5.1)", () => {
 		assert.equal(model.api, "openai-completions");
 	});
 
-	it("glm-5.1 has reasoning enabled and correct context window", () => {
+	it("glm-5.1 has reasoning enabled and uses generated catalog precedence", () => {
 		const model = getModel("zai" as any, "glm-5.1" as any);
 		assert.ok(model);
 		assert.equal(model.reasoning, true);
-		assert.equal(model.contextWindow, 204800);
+		// Generated catalog entries are loaded first; custom models are additive-only.
+		assert.equal(model.contextWindow, 200000);
 		assert.equal(model.maxTokens, 131072);
 	});
 

package/packages/pi-ai/src/models.ts

@@ -1,153 +1,3 @@
-import { MODELS } from "./models.generated.js";
-import { CUSTOM_MODELS } from "./models.custom.js";
-import type { Api, KnownProvider, Model, ModelCapabilities, Usage } from "./types.js";
-
-const modelRegistry: Map<string, Map<string, Model<Api>>> = new Map();
-
-// Initialize registry from auto-generated MODELS (models.dev catalog)
-for (const [provider, models] of Object.entries(MODELS)) {
-	const providerModels = new Map<string, Model<Api>>();
-	for (const [id, model] of Object.entries(models)) {
-		providerModels.set(id, model as Model<Api>);
-	}
-	modelRegistry.set(provider, providerModels);
-}
-
-// Merge manually-maintained custom providers that are NOT in models.dev.
-// Custom models are additive — they never overwrite generated entries.
-// See: https://github.com/gsd-build/gsd-2/issues/2339
-for (const [provider, models] of Object.entries(CUSTOM_MODELS)) {
-	if (!modelRegistry.has(provider)) {
-		modelRegistry.set(provider, new Map<string, Model<Api>>());
-	}
-	const providerModels = modelRegistry.get(provider)!;
-	for (const [id, model] of Object.entries(models)) {
-		if (!providerModels.has(id)) {
-			providerModels.set(id, model as Model<Api>);
-		}
-	}
-}
-
-// ─── Capability Patches ───────────────────────────────────────────────────────
-//
-// Declare capabilities for models that pre-date the `capabilities` field or
-// that live in the auto-generated catalog (models.generated.ts) which we
-// cannot edit directly. Pattern-matching on model IDs is acceptable HERE
-// because this is the single source of truth — call sites must never repeat it.
-//
-// Add new entries as additional capabilities emerge. Existing models that
-// define `capabilities` in their model definition take precedence (the patch
-// only fills in fields that are not already set).
-
-type CapabilityPatch = { match: (m: Model<Api>) => boolean; caps: ModelCapabilities };
-
-const CAPABILITY_PATCHES: CapabilityPatch[] = [
-	// GPT-5.x supports xhigh thinking and OpenAI service tiers
-	{
-		match: (m) => m.id.includes("gpt-5.2") || m.id.includes("gpt-5.3") || m.id.includes("gpt-5.4"),
-		caps: { supportsXhigh: true, supportsServiceTier: true },
-	},
-	// Anthropic Opus 4.6 supports xhigh thinking
-	{
-		match: (m) => m.api === "anthropic-messages" && (m.id.includes("opus-4-6") || m.id.includes("opus-4.6")),
-		caps: { supportsXhigh: true },
-	},
-];
-
-/**
- * Apply capability patches to a list of models.
- *
- * Models constructed outside the static pi-ai registry (custom models from
- * models.json, extension-registered models, discovered models) do not pass
- * through the module-init patch loop. Call this function after assembling
- * any model list to ensure capabilities are set correctly.
- *
- * Explicit `capabilities` already set on a model take precedence over patches.
- */
-export function applyCapabilityPatches(models: Model<Api>[]): Model<Api>[] {
-	return models.map((model) => {
-		for (const patch of CAPABILITY_PATCHES) {
-			if (patch.match(model)) {
-				return {
-					...model,
-					capabilities: { ...patch.caps, ...model.capabilities },
-				};
-			}
-		}
-		return model;
-	});
-}
-
-// Apply patches to the static registry at module load
-for (const [, providerModels] of modelRegistry) {
-	for (const [id, model] of providerModels) {
-		for (const patch of CAPABILITY_PATCHES) {
-			if (patch.match(model)) {
-				providerModels.set(id, {
-					...model,
-					capabilities: { ...patch.caps, ...model.capabilities },
-				});
-				break;
-			}
-		}
-	}
-}
-
-/** Providers that have entries in the generated MODELS constant */
-type GeneratedProvider = keyof typeof MODELS & KnownProvider;
-
-type ModelApi<
-	TProvider extends GeneratedProvider,
-	TModelId extends keyof (typeof MODELS)[TProvider],
-> = (typeof MODELS)[TProvider][TModelId] extends { api: infer TApi } ? (TApi extends Api ? TApi : never) : never;
-
-export function getModel<TProvider extends GeneratedProvider, TModelId extends keyof (typeof MODELS)[TProvider]>(
-	provider: TProvider,
-	modelId: TModelId,
-): Model<ModelApi<TProvider, TModelId>> {
-	const providerModels = modelRegistry.get(provider);
-	return providerModels?.get(modelId as string) as Model<ModelApi<TProvider, TModelId>>;
-}
-
-export function getProviders(): KnownProvider[] {
-	return Array.from(modelRegistry.keys()) as KnownProvider[];
-}
-
-export function getModels<TProvider extends KnownProvider>(
-	provider: TProvider,
-): Model<Api>[] {
-	const models = modelRegistry.get(provider);
-	return models ? (Array.from(models.values()) as Model<Api>[]) : [];
-}
-
-export function calculateCost<TApi extends Api>(model: Model<TApi>, usage: Usage): Usage["cost"] {
-	usage.cost.input = (model.cost.input / 1000000) * usage.input;
-	usage.cost.output = (model.cost.output / 1000000) * usage.output;
-	usage.cost.cacheRead = (model.cost.cacheRead / 1000000) * usage.cacheRead;
-	usage.cost.cacheWrite = (model.cost.cacheWrite / 1000000) * usage.cacheWrite;
-	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
-	return usage.cost;
-}
-
-/**
- * Check if a model supports xhigh thinking level.
- *
- * Reads from `model.capabilities.supportsXhigh` — set via CAPABILITY_PATCHES
- * for generated models or declared directly in custom model definitions.
- * Do not add model-ID or provider-name checks here; update CAPABILITY_PATCHES instead.
- */
-export function supportsXhigh<TApi extends Api>(model: Model<TApi>): boolean {
-	return model.capabilities?.supportsXhigh ?? false;
-}
-
-/**
- * Check if two models are equal by comparing both their id and provider.
- * Returns false if either model is null or undefined.
- */
-export function modelsAreEqual<TApi extends Api>(
-	a: Model<TApi> | null | undefined,
-	b: Model<TApi> | null | undefined,
-): boolean {
-	if (!a || !b) return false;
-	return a.id === b.id && a.provider === b.provider;
-}
+// Backward-compatible entrypoint.
+// ADR-007 moved model registry internals to src/models/*.
+export * from "./models/index.js";

package/packages/pi-ai/src/utils/overflow.ts

@@ -104,6 +104,19 @@ export function isContextOverflow(message: AssistantMessage, contextWindow?: num
 		}
 	}
 
+	// Some providers surface overflow as assistant text while putting a generic
+	// classifier value in errorMessage (e.g. claude-code: errorMessage="success",
+	// text="Prompt is too long"). Check rendered text as a fallback.
+	if (message.stopReason === "error") {
+		const assistantText = message.content
+			.filter((block) => block.type === "text")
+			.map((block) => block.text)
+			.join("\n");
+		if (assistantText && OVERFLOW_PATTERNS.some((p) => p.test(assistantText))) {
+			return true;
+		}
+	}
+
 	// Case 2: Silent overflow (z.ai style) - successful but usage exceeds context
 	if (contextWindow && message.stopReason === "stop") {
 		const inputTokens = message.usage.input + message.usage.cacheRead;
@@ -113,4 +126,4 @@ export function isContextOverflow(message: AssistantMessage, contextWindow?: num
 	}
 
 	return false;
-}
+}

package/packages/pi-ai/src/utils/tests/overflow.test.ts

@@ -0,0 +1,58 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { isContextOverflow } from "../overflow.js";
+import type { AssistantMessage } from "../../types.js";
+
+function makeAssistantMessage(overrides: Partial<AssistantMessage> = {}): AssistantMessage {
+	return {
+		role: "assistant",
+		content: [],
+		api: "anthropic-messages",
+		provider: "anthropic",
+		model: "claude-sonnet-4-6",
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		stopReason: "error",
+		timestamp: Date.now(),
+		...overrides,
+	};
+}
+
+describe("isContextOverflow", () => {
+	test("detects overflow from provider errorMessage", () => {
+		const message = makeAssistantMessage({
+			errorMessage: "prompt is too long: 213462 tokens > 200000 maximum",
+		});
+
+		assert.equal(isContextOverflow(message, 200000), true);
+	});
+
+	test("detects claude-code overflow when text contains the error but errorMessage is generic (#3925)", () => {
+		const message = makeAssistantMessage({
+			provider: "claude-code",
+			api: "anthropic-messages",
+			model: "claude-sonnet-4-6",
+			errorMessage: "success",
+			content: [{ type: "text", text: "Prompt is too long" }],
+		});
+
+		assert.equal(isContextOverflow(message, 200000), true);
+	});
+
+	test("does not treat normal non-error text as overflow", () => {
+		const message = makeAssistantMessage({
+			stopReason: "stop",
+			errorMessage: undefined,
+			content: [{ type: "text", text: "Prompt is too long" }],
+		});
+
+		assert.equal(isContextOverflow(message, 200000), false);
+	});
+});

package/packages/pi-ai/tsconfig.json

@@ -6,6 +6,7 @@
     "strict": true,
     "esModuleInterop": true,
     "skipLibCheck": true,
+    "incremental": true,
     "forceConsistentCasingInFileNames": true,
     "declaration": true,
     "declarationMap": true,