fix(ai): clamp MiniMax shared budget max tokens

closes #6061

packages/ai/src/api/anthropic-messages.ts

@@ -29,6 +29,7 @@ import type {
 	ToolCall,
 	ToolResultMessage,
 } from "../types.ts";
+import { estimateContextTokens } from "../utils/estimate.ts";
 import { AssistantMessageEventStream } from "../utils/event-stream.ts";
 import { headersToRecord } from "../utils/headers.ts";
 import { parseJsonWithRepair, parseStreamingJson } from "../utils/json-parse.ts";
@@ -177,9 +178,12 @@ function getAnthropicCompat(
 		supportsCacheControlOnTools: model.compat?.supportsCacheControlOnTools ?? true,
 		supportsTemperature: model.compat?.supportsTemperature ?? true,
 		allowEmptySignature: model.compat?.allowEmptySignature ?? false,
+		maxTokensSharesContextWindow: model.compat?.maxTokensSharesContextWindow ?? false,
 	};
 }
 
+const SHARED_BUDGET_MIN_OUTPUT_TOKENS = 1024;
+
 export interface AnthropicOptions extends StreamOptions {
 	/**
 	 * Enable extended thinking.
@@ -998,6 +1002,18 @@ function buildParams(
 		}
 	}
 
+	if (compat.maxTokensSharesContextWindow && model.contextWindow > 0) {
+		const estimatedInput = estimateContextTokens(context).tokens;
+		const available = Math.max(SHARED_BUDGET_MIN_OUTPUT_TOKENS, model.contextWindow - estimatedInput);
+		const clamped = Math.min(params.max_tokens, available);
+		if (clamped < params.max_tokens) {
+			params.max_tokens = clamped;
+			if (params.thinking?.type === "enabled" && params.thinking.budget_tokens >= clamped) {
+				params.thinking.budget_tokens = Math.max(0, clamped - SHARED_BUDGET_MIN_OUTPUT_TOKENS);
+			}
+		}
+	}
+
 	return params;
 }
 

packages/ai/src/index.ts

@@ -27,6 +27,7 @@ export * from "./providers/faux.ts";
 export * from "./session-resources.ts";
 export * from "./types.ts";
 export * from "./utils/diagnostics.ts";
+export * from "./utils/estimate.ts";
 export * from "./utils/event-stream.ts";
 export * from "./utils/json-parse.ts";
 export type {

packages/ai/src/types.ts

@@ -573,6 +573,14 @@ export interface AnthropicMessagesCompat {
 	forceAdaptiveThinking?: boolean;
 	/** Whether to replay empty thinking signatures as `signature: ""` instead of converting thinking to text. Default: false. */
 	allowEmptySignature?: boolean;
+	/**
+	 * Whether the provider counts `input + max_tokens` against a single shared
+	 * budget (the model's `contextWindow`) instead of Anthropic's independent
+	 * input and output limits. When true, Anthropic Messages requests clamp
+	 * `max_tokens` to leave room for the estimated context tokens.
+	 * Default: false.
+	 */
+	maxTokensSharesContextWindow?: boolean;
 }
 
 /**

packages/ai/src/utils/estimate.ts

@@ -0,0 +1,127 @@
+import type { AssistantMessage, Context, ImageContent, Message, TextContent, Usage } from "../types.ts";
+
+export interface ContextUsageEstimate {
+	/** Estimated total context tokens. */
+	tokens: number;
+	/** Tokens reported by the most recent assistant usage block. */
+	usageTokens: number;
+	/** Estimated tokens after the most recent assistant usage block. */
+	trailingTokens: number;
+	/** Index of the message that provided usage, or null when none exists. */
+	lastUsageIndex: number | null;
+}
+
+const CHARS_PER_TOKEN = 4;
+const ESTIMATED_IMAGE_CHARS = 4800;
+
+export function calculateContextTokens(usage: Usage): number {
+	return usage.totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+}
+
+function safeJsonStringify(value: unknown): string {
+	try {
+		return JSON.stringify(value) ?? "undefined";
+	} catch {
+		return "[unserializable]";
+	}
+}
+
+function estimateTextAndImageContentChars(content: string | Array<TextContent | ImageContent>): number {
+	if (typeof content === "string") return content.length;
+
+	let chars = 0;
+	for (const block of content) {
+		chars += block.type === "text" ? block.text.length : ESTIMATED_IMAGE_CHARS;
+	}
+	return chars;
+}
+
+export function estimateTextTokens(text: string): number {
+	return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+
+export function estimateTextAndImageContentTokens(content: string | Array<TextContent | ImageContent>): number {
+	return Math.ceil(estimateTextAndImageContentChars(content) / CHARS_PER_TOKEN);
+}
+
+export function estimateMessageTokens(message: Message): number {
+	let chars = 0;
+
+	switch (message.role) {
+		case "user":
+			return estimateTextAndImageContentTokens(message.content);
+		case "assistant":
+			for (const block of message.content) {
+				if (block.type === "text") {
+					chars += block.text.length;
+				} else if (block.type === "thinking") {
+					chars += block.thinking.length;
+				} else {
+					chars += block.name.length + safeJsonStringify(block.arguments).length;
+				}
+			}
+			break;
+		case "toolResult":
+			chars = estimateTextAndImageContentChars(message.content);
+			break;
+	}
+
+	return Math.ceil(chars / CHARS_PER_TOKEN);
+}
+
+function getLastAssistantUsageInfo(messages: readonly Message[]): { usage: Usage; index: number } | undefined {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const message = messages[i];
+		if (message.role !== "assistant") continue;
+		const assistant = message as AssistantMessage;
+		if (assistant.stopReason === "aborted" || assistant.stopReason === "error") continue;
+		if (calculateContextTokens(assistant.usage) > 0) return { usage: assistant.usage, index: i };
+	}
+	return undefined;
+}
+
+function estimateMessages(messages: readonly Message[]): ContextUsageEstimate {
+	const usageInfo = getLastAssistantUsageInfo(messages);
+
+	if (!usageInfo) {
+		let estimated = 0;
+		for (const message of messages) estimated += estimateMessageTokens(message);
+		return { tokens: estimated, usageTokens: 0, trailingTokens: estimated, lastUsageIndex: null };
+	}
+
+	const usageTokens = calculateContextTokens(usageInfo.usage);
+	let trailingTokens = 0;
+	for (let i = usageInfo.index + 1; i < messages.length; i++) {
+		trailingTokens += estimateMessageTokens(messages[i]);
+	}
+
+	return {
+		tokens: usageTokens + trailingTokens,
+		usageTokens,
+		trailingTokens,
+		lastUsageIndex: usageInfo.index,
+	};
+}
+
+function isMessageArray(value: Context | readonly Message[]): value is readonly Message[] {
+	return Array.isArray(value);
+}
+
+export function estimateContextTokens(context: Context | readonly Message[]): ContextUsageEstimate {
+	if (isMessageArray(context)) return estimateMessages(context);
+
+	const estimate = estimateMessages(context.messages);
+	if (estimate.lastUsageIndex !== null) return estimate;
+
+	let prefixTokens = context.systemPrompt ? estimateTextTokens(context.systemPrompt) : 0;
+	if (context.tools && context.tools.length > 0) {
+		prefixTokens += estimateTextTokens(safeJsonStringify(context.tools));
+	}
+
+	return {
+		tokens: estimate.tokens + prefixTokens,
+		usageTokens: estimate.usageTokens,
+		trailingTokens: estimate.trailingTokens + prefixTokens,
+		lastUsageIndex: estimate.lastUsageIndex,
+	};
+}