gsd-pi 2.76.0 → 2.77.0

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/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}"`,
+						);
+					}
+				}
+			}
+		}
+	});
+});

package/packages/pi-ai/src/providers/openai-completions.ts

@@ -39,6 +39,7 @@ import {
 	finalizeStream,
 	handleStreamError,
 } from "./openai-shared.js";
+import { ThinkTagParser } from "./think-tag-parser.js";
 import { transformMessagesWithReport } from "./transform-messages.js";
 
 /**
@@ -91,6 +92,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions", OpenA
 			stream.push({ type: "start", partial: output });
 
 			let currentBlock: TextContent | ThinkingContent | (ToolCall & { partialArgs?: string }) | null = null;
+			const thinkTagParser = new ThinkTagParser();
 			const blocks = output.content;
 			const blockIndex = () => blocks.length - 1;
 			const finishCurrentBlock = (block?: typeof currentBlock) => {
@@ -121,6 +123,55 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions", OpenA
 					}
 				}
 			};
+			const appendTextDelta = (delta: string) => {
+				if (!delta) return;
+				if (!currentBlock || currentBlock.type !== "text") {
+					finishCurrentBlock(currentBlock);
+					currentBlock = { type: "text", text: "" };
+					output.content.push(currentBlock);
+					stream.push({ type: "text_start", contentIndex: blockIndex(), partial: output });
+				}
+
+				if (currentBlock.type === "text") {
+					currentBlock.text += delta;
+					stream.push({
+						type: "text_delta",
+						contentIndex: blockIndex(),
+						delta,
+						partial: output,
+					});
+				}
+			};
+			const appendThinkingDelta = (delta: string) => {
+				if (!delta) return;
+				if (!currentBlock || currentBlock.type !== "thinking") {
+					finishCurrentBlock(currentBlock);
+					currentBlock = {
+						type: "thinking",
+						thinking: "",
+						thinkingSignature: "think-tag",
+					};
+					output.content.push(currentBlock);
+					stream.push({ type: "thinking_start", contentIndex: blockIndex(), partial: output });
+				}
+
+				if (currentBlock.type === "thinking") {
+					currentBlock.thinking += delta;
+					stream.push({
+						type: "thinking_delta",
+						contentIndex: blockIndex(),
+						delta,
+						partial: output,
+					});
+				}
+			};
+			const appendContentDelta = (delta: string) => {
+				const segments = thinkTagParser.consume(delta);
+				for (const segment of segments) {
+					if (segment.type === "thinking") appendThinkingDelta(segment.text);
+					else appendTextDelta(segment.text);
+				}
+			};
 
 			for await (const chunk of openaiStream) {
 				if (chunk.usage) {
@@ -161,22 +212,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions", OpenA
 						choice.delta.content !== undefined &&
 						choice.delta.content.length > 0
 					) {
-						if (!currentBlock || currentBlock.type !== "text") {
-							finishCurrentBlock(currentBlock);
-							currentBlock = { type: "text", text: "" };
-							output.content.push(currentBlock);
-							stream.push({ type: "text_start", contentIndex: blockIndex(), partial: output });
-						}
-
-						if (currentBlock.type === "text") {
-							currentBlock.text += choice.delta.content;
-							stream.push({
-								type: "text_delta",
-								contentIndex: blockIndex(),
-								delta: choice.delta.content,
-								partial: output,
-							});
-						}
+						appendContentDelta(choice.delta.content);
 					}
 
 					// Some endpoints return reasoning in reasoning_content (llama.cpp),
@@ -276,6 +312,11 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions", OpenA
 				}
 			}
 
+			for (const segment of thinkTagParser.flush()) {
+				if (segment.type === "thinking") appendThinkingDelta(segment.text);
+				else appendTextDelta(segment.text);
+			}
+
 			finishCurrentBlock(currentBlock);
 			assertStreamSuccess(output, options?.signal);
 			finalizeStream(stream, output);

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,

package/packages/pi-ai/src/providers/think-tag-parser.test.ts

@@ -0,0 +1,44 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { ThinkTagParser } from "./think-tag-parser.js";
+
+describe("ThinkTagParser", () => {
+	it("keeps plain text untouched", () => {
+		const parser = new ThinkTagParser();
+		assert.deepEqual(parser.consume("hello world"), [{ type: "text", text: "hello world" }]);
+		assert.deepEqual(parser.flush(), []);
+	});
+
+	it("splits inline think tags into thinking segments", () => {
+		const parser = new ThinkTagParser();
+		const out = parser.consume("A<think>B</think>C");
+		assert.deepEqual(out, [
+			{ type: "text", text: "A" },
+			{ type: "thinking", text: "B" },
+			{ type: "text", text: "C" },
+		]);
+	});
+
+	it("handles tag boundaries across deltas", () => {
+		const parser = new ThinkTagParser();
+		const out1 = parser.consume("A<th");
+		const out2 = parser.consume("ink>B</thi");
+		const out3 = parser.consume("nk>C");
+		const out4 = parser.flush();
+		assert.deepEqual([...out1, ...out2, ...out3, ...out4], [
+			{ type: "text", text: "A" },
+			{ type: "thinking", text: "B" },
+			{ type: "text", text: "C" },
+		]);
+	});
+
+	it("flushes unclosed think blocks as thinking", () => {
+		const parser = new ThinkTagParser();
+		const out1 = parser.consume("A<think>partial");
+		const out2 = parser.flush();
+		assert.deepEqual([...out1, ...out2], [
+			{ type: "text", text: "A" },
+			{ type: "thinking", text: "partial" },
+		]);
+	});
+});

package/packages/pi-ai/src/providers/think-tag-parser.ts

@@ -0,0 +1,94 @@
+export type ThinkSegmentType = "text" | "thinking";
+
+export interface ThinkSegment {
+	type: ThinkSegmentType;
+	text: string;
+}
+
+interface ThinkTagParserState {
+	mode: ThinkSegmentType;
+	pending: string;
+}
+
+const OPEN_TAG = "<think>";
+const CLOSE_TAG = "</think>";
+
+function trailingPartialLength(text: string, token: string): number {
+	const max = Math.min(text.length, token.length - 1);
+	for (let len = max; len > 0; len--) {
+		if (token.startsWith(text.slice(-len))) return len;
+	}
+	return 0;
+}
+
+/**
+ * Stateful parser for streaming `<think>...</think>` wrappers emitted by some
+ * OpenAI-compatible providers. Converts tagged sections into logical
+ * text/thinking segments while handling chunk boundaries safely.
+ */
+export class ThinkTagParser {
+	private state: ThinkTagParserState = { mode: "text", pending: "" };
+
+	consume(delta: string): ThinkSegment[] {
+		this.state.pending += delta;
+		return this.drain(false);
+	}
+
+	flush(): ThinkSegment[] {
+		return this.drain(true);
+	}
+
+	private drain(flushAll: boolean): ThinkSegment[] {
+		const out: ThinkSegment[] = [];
+		const push = (type: ThinkSegmentType, text: string) => {
+			if (!text) return;
+			out.push({ type, text });
+		};
+
+		while (this.state.pending.length > 0) {
+			if (this.state.mode === "text") {
+				const openIdx = this.state.pending.indexOf(OPEN_TAG);
+				if (openIdx >= 0) {
+					push("text", this.state.pending.slice(0, openIdx));
+					this.state.pending = this.state.pending.slice(openIdx + OPEN_TAG.length);
+					this.state.mode = "thinking";
+					continue;
+				}
+
+				if (flushAll) {
+					push("text", this.state.pending);
+					this.state.pending = "";
+					break;
+				}
+
+				const keep = trailingPartialLength(this.state.pending, OPEN_TAG);
+				const safeEnd = Math.max(0, this.state.pending.length - keep);
+				push("text", this.state.pending.slice(0, safeEnd));
+				this.state.pending = this.state.pending.slice(safeEnd);
+				break;
+			}
+
+			const closeIdx = this.state.pending.indexOf(CLOSE_TAG);
+			if (closeIdx >= 0) {
+				push("thinking", this.state.pending.slice(0, closeIdx));
+				this.state.pending = this.state.pending.slice(closeIdx + CLOSE_TAG.length);
+				this.state.mode = "text";
+				continue;
+			}
+
+			if (flushAll) {
+				push("thinking", this.state.pending);
+				this.state.pending = "";
+				break;
+			}
+
+			const keep = trailingPartialLength(this.state.pending, CLOSE_TAG);
+			const safeEnd = Math.max(0, this.state.pending.length - keep);
+			push("thinking", this.state.pending.slice(0, safeEnd));
+			this.state.pending = this.state.pending.slice(safeEnd);
+			break;
+		}
+
+		return out;
+	}
+}