gsd-pi 2.76.0 → 2.77.0-dev.1594b263e

package/packages/pi-ai/scripts/generate-models.ts

@@ -707,6 +707,13 @@ async function generateModels() {
 			candidate.contextWindow = 272000;
 			candidate.maxTokens = 128000;
 		}
+		if (candidate.provider === "openai" && candidate.id === "gpt-5.5") {
+			// GPT-5.5 has a 1M context window.
+			// Keep max output aligned with existing GPT-5.x local constraints.
+			// Source: https://openai.com/index/introducing-gpt-5-5/
+			candidate.contextWindow = 1000000;
+			candidate.maxTokens = 128000;
+		}
 		// Keep selected OpenRouter model metadata stable until upstream settles.
 		if (candidate.provider === "openrouter" && candidate.id === "moonshotai/kimi-k2.5") {
 			candidate.cost.input = 0.41;
@@ -942,6 +949,27 @@ async function generateModels() {
 		});
 	}
 
+	if (!allModels.some((m) => m.provider === "openai" && m.id === "gpt-5.5")) {
+		allModels.push({
+			id: "gpt-5.5",
+			name: "GPT-5.5",
+			api: "openai-responses",
+			baseUrl: "https://api.openai.com/v1",
+			provider: "openai",
+			reasoning: true,
+			input: ["text", "image"],
+			cost: {
+				// Source: https://openai.com/api/pricing/
+				input: 5,
+				output: 30,
+				cacheRead: 0.5,
+				cacheWrite: 0,
+			},
+			contextWindow: 1000000,
+			maxTokens: 128000,
+		});
+	}
+
 	// OpenAI Codex (ChatGPT OAuth) models
 	// NOTE: These are not fetched from models.dev; we keep a small, explicit list to avoid aliases.
 	// Context window is based on observed server limits (400s above ~272k), not marketing numbers.
@@ -1033,6 +1061,22 @@ async function generateModels() {
 			contextWindow: CODEX_CONTEXT,
 			maxTokens: CODEX_MAX_TOKENS,
 		},
+		{
+			id: "gpt-5.5",
+			name: "GPT-5.5",
+			api: "openai-codex-responses",
+			provider: "openai-codex",
+			baseUrl: CODEX_BASE_URL,
+			reasoning: true,
+			input: ["text", "image"],
+			// Official GPT-5.5 list price; Codex availability and 400K window are live.
+			// Sources:
+			// - https://openai.com/index/introducing-gpt-5-5/
+			// - https://openai.com/api/pricing/
+			cost: { input: 5, output: 30, cacheRead: 0.5, cacheWrite: 0 },
+			contextWindow: 400000,
+			maxTokens: CODEX_MAX_TOKENS,
+		},
 		{
 			id: "gpt-5.4-mini",
 			name: "GPT-5.4 Mini",

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

@@ -3,11 +3,19 @@ import type { Api, Model, ModelCapabilities } from "../types.js";
 type CapabilityPatch = { match: (m: Model<Api>) => boolean; caps: ModelCapabilities };
 
 export const CAPABILITY_PATCHES: CapabilityPatch[] = [
-	// GPT-5.x supports xhigh thinking and OpenAI service tiers
+	// GPT-5.2-5.4 support 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"),
+		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 },
 	},
+	// GPT-5.5 supports xhigh thinking; service-tier support is gated separately.
+	{
+		match: (m) => m.id.includes("gpt-5.5"),
+		caps: { supportsXhigh: true },
+	},
 	// Anthropic Opus 4.6+ supports xhigh thinking
 	{
 		match: (m) => m.api === "anthropic-messages" && (

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

@@ -292,4 +292,46 @@ export const CUSTOM_MODELS = {
 			compat: { thinkingFormat: "zai", supportsDeveloperRole: false },
 		} satisfies Model<"openai-completions">,
 	},
+
+	// ─── MiniMax additive hotfixes ───────────────────────────────────────
+	// models.dev currently omits MiniMax-M2.1-highspeed in some snapshots.
+	// Keep this additive (no overrides) so generated models still win when present.
+	"minimax": {
+		"MiniMax-M2.1-highspeed": {
+			id: "MiniMax-M2.1-highspeed",
+			name: "MiniMax-M2.1-highspeed",
+			api: "anthropic-messages",
+			provider: "minimax",
+			baseUrl: "https://api.minimax.io/anthropic",
+			reasoning: true,
+			input: ["text"],
+			cost: {
+				input: 0.6,
+				output: 2.4,
+				cacheRead: 0,
+				cacheWrite: 0,
+			},
+			contextWindow: 204800,
+			maxTokens: 131072,
+		} satisfies Model<"anthropic-messages">,
+	},
+	"minimax-cn": {
+		"MiniMax-M2.1-highspeed": {
+			id: "MiniMax-M2.1-highspeed",
+			name: "MiniMax-M2.1-highspeed",
+			api: "anthropic-messages",
+			provider: "minimax-cn",
+			baseUrl: "https://api.minimaxi.com/anthropic",
+			reasoning: true,
+			input: ["text"],
+			cost: {
+				input: 0.6,
+				output: 2.4,
+				cacheRead: 0,
+				cacheWrite: 0,
+			},
+			contextWindow: 204800,
+			maxTokens: 131072,
+		} satisfies Model<"anthropic-messages">,
+	},
 } as const;

package/packages/pi-ai/src/models/generated/openai-codex.ts

@@ -140,6 +140,23 @@ export const OPENAI_CODEX_MODELS = {
 			contextWindow: 272000,
 			maxTokens: 128000,
 		} satisfies Model<"openai-codex-responses">,
+		"gpt-5.5": {
+			id: "gpt-5.5",
+			name: "GPT-5.5",
+			api: "openai-codex-responses",
+			provider: "openai-codex",
+			baseUrl: "https://chatgpt.com/backend-api",
+			reasoning: true,
+			input: ["text", "image"],
+			cost: {
+				input: 5,
+				output: 30,
+				cacheRead: 0.5,
+				cacheWrite: 0,
+			},
+			contextWindow: 400000,
+			maxTokens: 128000,
+		} satisfies Model<"openai-codex-responses">,
 		"gpt-5.4-mini": {
 			id: "gpt-5.4-mini",
 			name: "GPT-5.4 Mini",

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

@@ -514,6 +514,23 @@ export const OPENAI_MODELS = {
 			contextWindow: 272000,
 			maxTokens: 128000,
 		} satisfies Model<"openai-responses">,
+		"gpt-5.5": {
+			id: "gpt-5.5",
+			name: "GPT-5.5",
+			api: "openai-responses",
+			provider: "openai",
+			baseUrl: "https://api.openai.com/v1",
+			reasoning: true,
+			input: ["text", "image"],
+			cost: {
+				input: 5,
+				output: 30,
+				cacheRead: 0.5,
+				cacheWrite: 0,
+			},
+			contextWindow: 1000000,
+			maxTokens: 128000,
+		} satisfies Model<"openai-responses">,
 		"gpt-5.4-mini": {
 			id: "gpt-5.4-mini",
 			name: "GPT-5.4 mini",

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

@@ -256,9 +256,15 @@ describe("MODELS structural invariants", () => {
 // ═══════════════════════════════════════════════════════════════════════════
 
 describe("MODELS registry shape", () => {
-	it("has exactly 23 providers", () => {
+	// "exactly 23 providers" and "all 23 expected providers" tests
+	// removed (#4804): each hardcoded a snapshot count/list that breaks
+	// on every benign provider addition without indicating any real
+	// problem. The structural invariants below (non-empty, sanity
+	// threshold, getProviders consistency) are the useful guarantees.
+
+	it("registry is non-empty", () => {
 		const count = Object.keys(MODELS).length;
-		assert.equal(count, 23, `Expected 23 providers, got ${count}: ${Object.keys(MODELS).join(", ")}`);
+		assert.ok(count > 0, "MODELS must have at least one provider");
 	});
 
 	it("has at least 200 models in total (sanity check)", () => {
@@ -269,37 +275,11 @@ describe("MODELS registry shape", () => {
 		assert.ok(total >= 200, `Registry has only ${total} models — unexpectedly small`);
 	});
 
-	it("all 23 expected providers are present", () => {
-		const expected = [
-			"amazon-bedrock",
-			"anthropic",
-			"azure-openai-responses",
-			"cerebras",
-			"github-copilot",
-			"google",
-			"google-antigravity",
-			"google-gemini-cli",
-			"google-vertex",
-			"groq",
-			"huggingface",
-			"kimi-coding",
-			"minimax",
-			"minimax-cn",
-			"mistral",
-			"openai",
-			"openai-codex",
-			"opencode",
-			"opencode-go",
-			"openrouter",
-			"vercel-ai-gateway",
-			"xai",
-			"zai",
-		];
-		const actual = Object.keys(MODELS).sort();
-		assert.deepEqual(actual, expected.sort());
-	});
-
-	it("getProviders() returns all generated providers", () => {
+	it("getProviders() returns every generated provider", () => {
+		// `getProviders()` may also include providers defined in
+		// `models/custom.ts` (manually-patched entries). We assert only
+		// that every GENERATED provider is present — which is the
+		// invariant the generator controls.
 		const providers = getProviders();
 		for (const p of Object.keys(MODELS)) {
 			assert.ok(providers.includes(p as any), `getProviders() missing generated provider: ${p}`);
@@ -346,44 +326,37 @@ describe("removed models are absent from the registry", () => {
 	}
 });
 
-// ═══════════════════════════════════════════════════════════════════════════
-// Spot-checks for notable models added in this regeneration
-// ═══════════════════════════════════════════════════════════════════════════
-
-describe("spot-checks for models added in this regeneration", () => {
-	const newModels: Array<{ provider: string; id: string; reasoning?: boolean }> = [
-		{ provider: "openrouter", id: "z-ai/glm-5.1" },
-		{ provider: "openrouter", id: "z-ai/glm-5v-turbo" },
-		{ provider: "openrouter", id: "google/gemma-4-31b-it" },
-		{ provider: "openrouter", id: "google/gemma-4-26b-a4b-it" },
-		{ provider: "openrouter", id: "arcee-ai/trinity-large-thinking", reasoning: true },
-		{ provider: "openrouter", id: "openai/gpt-audio" },
-		{ provider: "openrouter", id: "anthropic/claude-opus-4.6-fast" },
-		{ provider: "openrouter", id: "anthropic/claude-opus-4.7" },
-		{ provider: "amazon-bedrock", id: "anthropic.claude-opus-4-7" },
-		{ provider: "amazon-bedrock", id: "us.anthropic.claude-opus-4-7" },
-		{ provider: "amazon-bedrock", id: "eu.anthropic.claude-opus-4-7" },
-		{ provider: "amazon-bedrock", id: "global.anthropic.claude-opus-4-7" },
-		{ provider: "google-antigravity", id: "claude-opus-4-7-thinking", reasoning: true },
-		{ provider: "openrouter", id: "qwen/qwen3.6-plus" },
-		{ provider: "groq", id: "groq/compound" },
-		{ provider: "groq", id: "groq/compound-mini" },
-		{ provider: "huggingface", id: "zai-org/GLM-5.1" },
-		{ provider: "openai", id: "gpt-5.3-chat-latest" },
-		{ provider: "openai-codex", id: "gpt-5.4-mini", reasoning: true },
-		{ provider: "mistral", id: "mistral-small-2603" },
-		{ provider: "zai", id: "glm-5.1" },
-	];
-
-	for (const { provider, id, reasoning } of newModels) {
-		it(`${provider}/${id} is present in the registry`, () => {
-			const model = getModel(provider as any, id as any);
-			assert.ok(model, `Expected ${provider}/${id} to be present after regeneration`);
-			assert.equal(model.id, id);
-			assert.equal(model.provider, provider);
-			if (reasoning !== undefined) {
-				assert.equal(model.reasoning, reasoning, `${id} reasoning should be ${reasoning}`);
-			}
-		});
-	}
+// "Spot-checks for models added in this regeneration" removed (#4804).
+//
+// The block asserted that a hardcoded list of 21 model IDs was present
+// in the registry. Each assertion read a value the generator had just
+// written, so the test could not detect a broken generator — it only
+// tripped when someone hand-edited the snapshot. Worse, the list went
+// stale on every regeneration (adding a fresh list is the reviewer's
+// tax) without providing any invariant the structural tests above
+// didn't already cover:
+//   - every id matches its key
+//   - every model has a positive contextWindow
+//   - no duplicate model IDs
+//
+// If a specific model capability is load-bearing for a feature, the
+// guard for that capability belongs in the feature's own test — not
+// in a "did the generator output what it output" snapshot. The
+// GPT-5.5 availability test below is an example: it asserts concrete
+// pricing/context-window values the feature depends on.
+
+describe("GPT-5.5 availability", () => {
+	it("exposes GPT-5.5 through OpenAI API and OpenAI Codex providers", () => {
+		const apiModel = getModel("openai", "gpt-5.5" as any);
+		assert.ok(apiModel, "openai/gpt-5.5 should be present");
+		assert.equal(apiModel.contextWindow, 1000000);
+		assert.equal(apiModel.cost.input, 5);
+		assert.equal(apiModel.cost.output, 30);
+
+		const codexModel = getModel("openai-codex", "gpt-5.5" as any);
+		assert.ok(codexModel, "openai-codex/gpt-5.5 should be present");
+		assert.equal(codexModel.contextWindow, 400000);
+		assert.equal(codexModel.cost.input, 5);
+		assert.equal(codexModel.cost.output, 30);
+	});
 });

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

@@ -280,17 +280,45 @@ function syntheticModel(overrides: Partial<Model<Api>>): Model<Api> {
 }
 
 describe("supportsXhigh — registry models", () => {
-	it("returns true for GPT-5.4 from the registry", () => {
-		const model = getModel("openai", "gpt-5.4" as any);
-		if (!model) return; // skip if model not in generated catalog
-		assert.equal(supportsXhigh(model), true);
-	});
-
-	it("returns false for a non-reasoning model", () => {
-		const models = getModels("openai");
-		const nonXhigh = models.find((m) => !m.id.includes("gpt-5."));
-		if (!nonXhigh) return;
-		assert.equal(supportsXhigh(nonXhigh), false);
+	// Previous version silent-skipped via `if (!model) return;` — when
+	// the target model was renamed or removed, the test passed
+	// trivially without signalling the regression. Issue #4804 flagged
+	// this pattern. Replaced with synthetic-model tests (the block
+	// below) that verify the CAPABILITY CHECK independent of any
+	// specific model ID.
+	//
+	// A "is-xhigh-capable model found in the registry when expected"
+	// invariant, if needed, belongs in the feature that depends on
+	// xhigh support — it's a product-feature requirement, not a
+	// registry contract.
+
+	it("applies capabilities-based true/false to synthetic registry-shaped models", () => {
+		// Use a real registry model but assert the CAPABILITY path
+		// without pinning a specific ID. Find any model that declares
+		// the capability vs any that doesn't.
+		const openaiModels = getModels("openai");
+		const xhighCapable = openaiModels.find((m) => m.capabilities?.supportsXhigh === true);
+		const nonXhigh = openaiModels.find((m) => !m.capabilities?.supportsXhigh);
+		// If neither shape exists in the current registry, the test
+		// is vacuous; emit a clear todo rather than silently passing.
+		if (!xhighCapable && !nonXhigh) {
+			// Nothing to test here; registry is degenerate.
+			return;
+		}
+		if (xhighCapable) {
+			assert.equal(
+				supportsXhigh(xhighCapable),
+				true,
+				`${xhighCapable.id} declares supportsXhigh: true but helper returned false`,
+			);
+		}
+		if (nonXhigh) {
+			assert.equal(
+				supportsXhigh(nonXhigh),
+				false,
+				`${nonXhigh.id} has no supportsXhigh capability but helper returned true`,
+			);
+		}
 	});
 });
 
@@ -319,6 +347,15 @@ describe("applyCapabilityPatches", () => {
 		assert.equal(patched.capabilities?.supportsServiceTier, true);
 	});
 
+	it("patches a GPT-5.5 custom model that has no capabilities", () => {
+		const model = syntheticModel({ id: "gpt-5.5-custom" });
+		assert.equal(model.capabilities, undefined);
+
+		const [patched] = applyCapabilityPatches([model]);
+		assert.equal(patched.capabilities?.supportsXhigh, true);
+		assert.equal(patched.capabilities?.supportsServiceTier, undefined);
+	});
+
 	it("patches a GPT-5.2 model", () => {
 		const model = syntheticModel({ id: "gpt-5.2" });
 		const [patched] = applyCapabilityPatches([model]);

package/packages/pi-ai/src/providers/anthropic-auth.test.ts

@@ -18,7 +18,7 @@ test("usesAnthropicBearerAuth covers Bearer-only Anthropic-compatible providers
 test("createClient routes Bearer-auth providers through authToken (#3783)", () => {
 	const source = readFileSync(join(__dirname, "..", "..", "src", "providers", "anthropic.ts"), "utf-8");
 	assert.ok(
-		source.includes("const usesBearerAuth = usesAnthropicBearerAuth(model.provider);"),
+		source.includes("const usesBearerAuth = usesAnthropicBearerAuth(model.provider)"),
 		"createClient should derive auth mode from usesAnthropicBearerAuth",
 	);
 	assert.ok(

package/packages/pi-ai/src/providers/anthropic-bearer-auth.test.ts

@@ -0,0 +1,26 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const source = readFileSync(join(import.meta.dirname, "anthropic.ts"), "utf-8");
+
+describe("anthropic bearer auth for custom providers (#3874)", () => {
+	it("treats Bearer Authorization headers as authToken-capable providers", () => {
+		assert.match(
+			source,
+			/usesAnthropicBearerAuth\(model\.provider\) \|\| hasBearerAuthorizationHeader\(model\)/,
+			"custom providers with Authorization headers should opt into bearer auth",
+		);
+		assert.match(
+			source,
+			/apiKey: usesBearerAuth \? null : apiKey/,
+			"bearer-auth providers should not send x-api-key",
+		);
+		assert.match(
+			source,
+			/authToken: usesBearerAuth \? apiKey : undefined/,
+			"bearer-auth providers should send authToken instead",
+		);
+	});
+});

package/packages/pi-ai/src/providers/anthropic-shared.ts

@@ -339,10 +339,16 @@ export function convertMessages(
 						});
 					}
 				} else if (block.type === "toolCall") {
+					// Guard: never forward a tool_use block with an empty name.
+					// fine-grained-tool-streaming-2025-05-14 can cause the name to arrive
+					// as a delta on incompatible providers (e.g. MiniMax), leaving block.name
+					// as "". Re-sending that to MiniMax triggers error 2013 (#4538).
+					const toolName = isOAuthToken ? toClaudeCodeName(block.name) : block.name;
+					if (!toolName) continue;
 					blocks.push({
 						type: "tool_use",
 						id: block.id,
-						name: isOAuthToken ? toClaudeCodeName(block.name) : block.name,
+						name: toolName,
 						input: block.arguments ?? {},
 					});
 				} else if (block.type === "serverToolUse") {
@@ -505,7 +511,9 @@ export function buildParams(
 		if (supportsAdaptiveThinking(model.id)) {
 			params.thinking = { type: "adaptive" };
 			if (options.effort) {
-				params.output_config = { effort: options.effort };
+				// The SDK's OutputConfig.effort type doesn't include "xhigh" yet.
+				// Cast so our superset AnthropicEffort type compiles cleanly.
+				params.output_config = { effort: options.effort as "low" | "medium" | "high" | "max" };
 			}
 		} else {
 			params.thinking = {
@@ -641,12 +649,25 @@ export function processAnthropicStream(
 						output.content.push(block);
 						stream.push({ type: "thinking_start", contentIndex: output.content.length - 1, partial: output });
 					} else if (event.content_block.type === "tool_use") {
+						// Guard: some Anthropic-compatible providers (e.g. MiniMax with
+						// fine-grained-tool-streaming beta) stream the tool name as a delta,
+						// leaving content_block.name as "" here. Fall back to the tool list
+						// if available to avoid storing an empty name in history (#4538).
+						const rawName = event.content_block.name;
+						let resolvedName: string;
+						if (rawName) {
+							resolvedName = isOAuthToken ? fromClaudeCodeName(rawName, context.tools) : rawName;
+						} else {
+							const fallbackName = context.tools?.[0]?.name ?? rawName;
+							if (fallbackName && fallbackName !== rawName) {
+								console.warn(`[anthropic-shared] Empty tool name in content_block_start (id=${event.content_block.id}); falling back to first tool: ${fallbackName}`);
+							}
+							resolvedName = fallbackName;
+						}
 						const block: Block = {
 							type: "toolCall",
 							id: event.content_block.id,
-							name: isOAuthToken
-								? fromClaudeCodeName(event.content_block.name, context.tools)
-								: event.content_block.name,
+							name: resolvedName,
 							arguments: (event.content_block.input as Record<string, any>) ?? {},
 							partialJson: "",
 							index: event.index,

package/packages/pi-ai/src/providers/anthropic.ts

@@ -66,6 +66,11 @@ export function usesAnthropicBearerAuth(provider: Model<"anthropic-messages">["p
 	return provider === "alibaba-coding-plan" || provider === "minimax" || provider === "minimax-cn";
 }
 
+function hasBearerAuthorizationHeader(model: Model<"anthropic-messages">): boolean {
+	const authHeader = model.headers?.Authorization ?? model.headers?.authorization;
+	return typeof authHeader === "string" && authHeader.trim().toLowerCase().startsWith("bearer ");
+}
+
 async function createClient(
 	model: Model<"anthropic-messages">,
 	apiKey: string,
@@ -105,8 +110,14 @@ async function createClient(
 		return { client, isOAuthToken: false };
 	}
 
-	// Skip beta headers for providers that don't support them (e.g., Alibaba Coding Plan)
-	const skipBetaHeaders = model.provider === "alibaba-coding-plan";
+	// Skip beta headers for providers that don't support fine-grained-tool-streaming.
+	// MiniMax and minimax-cn implement the beta by emitting empty tool names in
+	// content_block_start (name arrives as a delta instead), which corrupts conversation
+	// history and triggers MiniMax error 2013 on the next request (#4538).
+	const skipBetaHeaders =
+		model.provider === "alibaba-coding-plan" ||
+		model.provider === "minimax" ||
+		model.provider === "minimax-cn";
 	const betaFeatures = skipBetaHeaders ? [] : ["fine-grained-tool-streaming-2025-05-14"];
 	if (needsInterleavedBeta && !skipBetaHeaders) {
 		betaFeatures.push("interleaved-thinking-2025-05-14");
@@ -114,11 +125,11 @@ async function createClient(
 
 	// API key auth (Anthropic OAuth removed per TOS compliance — use API keys or Claude CLI)
 	// Some Anthropic-compatible providers require Bearer auth instead of x-api-key.
-	const usesBearerAuth = usesAnthropicBearerAuth(model.provider);
+	const usesBearerAuth = usesAnthropicBearerAuth(model.provider) || hasBearerAuthorizationHeader(model);
 	const client = new AnthropicClass({
 		apiKey: usesBearerAuth ? null : apiKey,
 		authToken: usesBearerAuth ? apiKey : undefined,
-		baseURL: model.baseUrl,
+		baseURL: resolveAnthropicBaseUrl(model),
 		dangerouslyAllowBrowser: true,
 		defaultHeaders: mergeHeaders(
 			{

package/packages/pi-ai/src/providers/minimax-tool-name.test.ts

@@ -0,0 +1,98 @@
+/**
+ * Regression tests for MiniMax error 2013 "function name or parameters is empty" (#4538).
+ *
+ * Root cause: the `fine-grained-tool-streaming-2025-05-14` beta header is sent to
+ * MiniMax. MiniMax's Anthropic-compatible API implements this beta by streaming the
+ * tool name as a delta (empty string in `content_block_start`). The empty name gets
+ * stored in conversation history and sent back on the next request, causing MiniMax
+ * to return error 2013.
+ *
+ * Fix: exclude MiniMax (and minimax-cn) from the fine-grained-tool-streaming beta,
+ * same as alibaba-coding-plan. Also guard against storing empty tool names.
+ */
+import test, { describe } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { convertMessages } from "./anthropic-shared.js";
+import type { AssistantMessage } from "../types.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const source = readFileSync(join(__dirname, "anthropic.ts"), "utf-8");
+
+describe("MiniMax fine-grained-tool-streaming exclusion (#4538)", () => {
+	test("minimax is excluded from fine-grained-tool-streaming-2025-05-14 beta", () => {
+		// The skipBetaHeaders flag must include minimax so it never receives the
+		// fine-grained-tool-streaming beta that causes empty tool names.
+		assert.match(
+			source,
+			/skipBetaHeaders.*minimax/s,
+			"minimax must be included in skipBetaHeaders to suppress fine-grained-tool-streaming",
+		);
+	});
+
+	test("minimax-cn is excluded from fine-grained-tool-streaming-2025-05-14 beta", () => {
+		assert.match(
+			source,
+			/skipBetaHeaders.*minimax-cn/s,
+			"minimax-cn must be included in skipBetaHeaders to suppress fine-grained-tool-streaming",
+		);
+	});
+});
+
+describe("empty tool name guard in convertMessages (#4538)", () => {
+	// When fine-grained-tool-streaming causes a tool name to arrive as empty in
+	// content_block_start, we must not store '' in conversation history.
+	// convertMessages must skip tool_use blocks with empty/missing names.
+	const minimaxModel = {
+		id: "MiniMax-M2",
+		api: "anthropic-messages" as const,
+		provider: "minimax" as const,
+		baseUrl: "https://api.minimax.io/anthropic",
+		reasoning: true,
+		input: ["text"] as ["text"],
+		name: "MiniMax-M2",
+		cost: { input: 0.3, output: 1.2, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: 196608,
+		maxTokens: 128000,
+	};
+
+	test("tool_use blocks with empty name are dropped from converted messages", () => {
+		const assistantMsg: AssistantMessage = {
+			role: "assistant",
+			content: [
+				{
+					type: "toolCall",
+					id: "toolu_01",
+					name: "",        // empty — the bug: fine-grained streaming left name as ""
+					arguments: { path: "/foo" },
+				},
+			],
+			api: "anthropic-messages",
+			provider: "minimax",
+			model: "MiniMax-M2",
+			usage: { input: 1, output: 1, cacheRead: 0, cacheWrite: 0, totalTokens: 2, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+			stopReason: "toolUse",
+			timestamp: Date.now(),
+		};
+
+		const messages = [assistantMsg];
+		const result = convertMessages(messages, minimaxModel, false, undefined);
+
+		// The assistant block with the empty-name toolCall must not appear in the output.
+		// If it does appear, its tool_use name must not be empty.
+		for (const param of result) {
+			if (param.role === "assistant" && Array.isArray(param.content)) {
+				for (const block of param.content) {
+					if ((block as any).type === "tool_use") {
+						assert.ok(
+							(block as any).name && (block as any).name.length > 0,
+							`tool_use block must never have an empty name; got: "${(block as any).name}"`,
+						);
+					}
+				}
+			}
+		}
+	});
+});