gsd-pi 2.76.0-dev.fe143342a → 2.77.0-dev.1594b263e

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-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

@@ -110,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");
@@ -123,7 +129,7 @@ async function createClient(
 	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}"`,
+						);
+					}
+				}
+			}
+		}
+	});
+});

package/packages/pi-ai/src/providers/simple-options.ts

@@ -1,9 +1,25 @@
 import type { Api, Model, SimpleStreamOptions, StreamOptions, ThinkingBudgets, ThinkingLevel } from "../types.js";
 
+/**
+ * Compute the default maxTokens for a model when no explicit value is provided.
+ *
+ * The 32 k cap is retained only for native Anthropic models (api === "anthropic-messages")
+ * where the Anthropic API historically rejected higher values. Custom and
+ * Anthropic-compatible models (e.g. OpenAI-completions, Vertex, etc.) use their
+ * declared model.maxTokens directly so that providers with larger output windows
+ * (131 072 tokens, etc.) are not silently capped.
+ */
+export function defaultMaxTokens(model: Model<Api>): number {
+	if (model.api === "anthropic-messages") {
+		return Math.min(model.maxTokens, 32000);
+	}
+	return model.maxTokens;
+}
+
 export function buildBaseOptions(model: Model<Api>, options?: SimpleStreamOptions, apiKey?: string): StreamOptions {
 	return {
 		temperature: options?.temperature,
-		maxTokens: options?.maxTokens || Math.min(model.maxTokens, 32000),
+		maxTokens: options?.maxTokens || defaultMaxTokens(model),
 		signal: options?.signal,
 		apiKey: apiKey || options?.apiKey,
 		cacheRetention: options?.cacheRetention,