@codeworksh/aikit 0.7.2 → 0.8.0-dev.20260905193244

package/index.mjs

@@ -1,349 +1,15 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { c as FailureSchema, r as normalize, t as failure_exports } from "./failure-xra3YPdY.mjs";
-import { E as NamedError, _ as getProviders, c as APIMethodEnumSchema, d as KnownProviderEnumSchema, f as ProviderInfo, g as getModels, h as getModel, i as packageForModel, l as ActiveThinkingLevel, m as clampThinkingLevel, o as resolveLanguageModel, p as calculateCost, r as loadProviderFactory, u as KnownProviderEnum, v as model_exports, x as registry, y as modelsAreEqual } from "./registry-DHskX4NP.mjs";
-import { g as shortHash, n as createOpenAICodex, r as openaiCodex, v as openAICodexTools, x as resolveOpenAICodexToolConstraint } from "./openai-codex-_3XkJ4bs.mjs";
+import { S as NamedError, _ as registry, a as KnownProviderEnumSchema, c as calculateCost, d as getModels, f as getProviders, g as optionsKey, i as KnownProviderEnum, l as clampThinkingLevel, m as modelsAreEqual, n as APIMethodEnumSchema, p as model_exports, r as ActiveThinkingLevel, s as ThinkingBudgets$1, u as getModel, v as thinkingTokenBudgetField } from "./model-CBnredXj.mjs";
+import { C as ToolCallSchema, D as transformMessages, E as resolveJsonSchemaConstraint, S as AssistantMessageSchema, T as message_exports, g as shortHash, n as createOpenAICodex, r as openaiCodex, v as openAICodexTools, w as createAssistantMessage$1, x as resolveOpenAICodexToolConstraint } from "./openai-codex-t4B7g-gv.mjs";
+import { r as normalize, t as failure_exports } from "./failure-SAPyG-w2.mjs";
+import { i as packageForModel, o as resolveLanguageModel, r as loadProviderFactory } from "./registry-DYdYTwFt.mjs";
 import Type$2, { Type, Type as Type$1 } from "typebox";
-import { uuidv7 } from "uuidv7";
-import Value from "typebox/value";
 import { jsonSchema, streamText } from "ai";
 import { parse } from "partial-json";
 import Schema from "typebox/schema";
-//#region src/message/message.ts
-var message_exports = /* @__PURE__ */ __exportAll({
-	AssistantMessageSchema: () => AssistantMessageSchema,
-	ConstrainedSamplingSchema: () => ConstrainedSamplingSchema,
-	ContextSchema: () => ContextSchema,
-	GrammarVariantsSchema: () => GrammarVariantsSchema,
-	ImageContentSchema: () => ImageContentSchema,
-	MessageSchema: () => MessageSchema,
-	StopReasonSchema: () => StopReasonSchema,
-	TextContentSchema: () => TextContentSchema,
-	ThinkingContentSchema: () => ThinkingContentSchema,
-	ToolAbortedSchema: () => ToolAbortedSchema,
-	ToolCallAbortedPartSchema: () => ToolCallAbortedPartSchema,
-	ToolCallBaseSchema: () => ToolCallBaseSchema,
-	ToolCallCompletedPartSchema: () => ToolCallCompletedPartSchema,
-	ToolCallErrorPartSchema: () => ToolCallErrorPartSchema,
-	ToolCallInFlightSchema: () => ToolCallInFlightSchema,
-	ToolCallPendingPartSchema: () => ToolCallPendingPartSchema,
-	ToolCallRunningPartSchema: () => ToolCallRunningPartSchema,
-	ToolCallSchema: () => ToolCallSchema,
-	ToolCallSkippedPartSchema: () => ToolCallSkippedPartSchema,
-	ToolCallTerminalPartSchema: () => ToolCallTerminalPartSchema,
-	ToolCompletedSchema: () => ToolCompletedSchema,
-	ToolErrorResult: () => ToolErrorResult,
-	ToolErrorSchema: () => ToolErrorSchema,
-	ToolRunningPartial: () => ToolRunningPartial,
-	ToolRunningSchema: () => ToolRunningSchema,
-	ToolSchema: () => ToolSchema,
-	ToolSkippedSchema: () => ToolSkippedSchema,
-	ToolStatusEnum: () => ToolStatusEnum,
-	ToolSuccessResult: () => ToolSuccessResult,
-	UsageSchema: () => UsageSchema,
-	UserMessageSchema: () => UserMessageSchema,
-	createAssistantMessage: () => createAssistantMessage$1,
-	createMessageId: () => createMessageId,
-	createUserMessage: () => createUserMessage,
-	defineTool: () => defineTool,
-	transformMessages: () => transformMessages
-});
-const TextContentSchema = Type$2.Object({
-	type: Type$2.Literal("text"),
-	text: Type$2.String(),
-	textSignature: Type$2.Optional(Type$2.String())
-});
-const ImageContentSchema = Type$2.Object({
-	type: Type$2.Literal("image"),
-	data: Type$2.String(),
-	mimeType: Type$2.String()
-});
-const ThinkingContentSchema = Type$2.Object({
-	type: Type$2.Literal("thinking"),
-	thinking: Type$2.String(),
-	thinkingSignature: Type$2.Optional(Type$2.String()),
-	/** When true, the thinking content was redacted by safety filters. The opaque
-	*  encrypted payload is stored in `thinkingSignature` so it can be passed back
-	*  to the API for multi-turn continuity. */
-	redacted: Type$2.Optional(Type$2.Boolean())
-});
-const ToolCallBaseSchema = Type$2.Object({
-	type: Type$2.Literal("toolCall"),
-	callID: Type$2.String(),
-	name: Type$2.String(),
-	arguments: Type$2.Record(Type$2.String(), Type$2.Any()),
-	thoughtSignature: Type$2.Optional(Type$2.String()),
-	namespace: Type$2.Optional(Type$2.String()),
-	/** Names from Context.tools that became available after this tool result. */
-	addedToolNames: Type$2.Optional(Type$2.Array(Type$2.String())),
-	time: Type$2.Object({
-		start: Type$2.Number(),
-		end: Type$2.Number()
-	})
-});
-const ToolSuccessResult = Type$2.Object({
-	content: Type$2.Array(Type$2.Union([TextContentSchema, ImageContentSchema])),
-	details: Type$2.Optional(Type$2.Any()),
-	isError: Type$2.Literal(false)
-});
-const ToolErrorResult = Type$2.Object({
-	content: Type$2.Array(Type$2.Union([TextContentSchema, ImageContentSchema])),
-	details: Type$2.Optional(Type$2.Any()),
-	isError: Type$2.Literal(true)
-});
-const ToolRunningPartial = Type$2.Object({
-	content: Type$2.Optional(Type$2.Array(Type$2.Union([TextContentSchema, ImageContentSchema]))),
-	details: Type$2.Optional(Type$2.Any())
-});
-const ToolStatusEnum = {
-	pending: "pending",
-	running: "running",
-	completed: "completed",
-	error: "error",
-	skipped: "skipped",
-	aborted: "aborted"
-};
-const ToolRunningSchema = Type$2.Object({
-	status: Type$2.Literal(ToolStatusEnum.running),
-	partial: Type$2.Optional(ToolRunningPartial)
-});
-const ToolCompletedSchema = Type$2.Object({
-	status: Type$2.Literal(ToolStatusEnum.completed),
-	result: ToolSuccessResult
-});
-const ToolErrorSchema = Type$2.Object({
-	status: Type$2.Literal(ToolStatusEnum.error),
-	result: ToolErrorResult
-});
-const ToolSkippedSchema = Type$2.Object({
-	status: Type$2.Literal(ToolStatusEnum.skipped),
-	result: ToolErrorResult
-});
-const ToolAbortedSchema = Type$2.Object({
-	status: Type$2.Literal(ToolStatusEnum.aborted),
-	result: ToolErrorResult
-});
-const ToolCallPendingPartSchema = Type$2.Intersect([ToolCallBaseSchema, Type$2.Object({ status: Type$2.Literal(ToolStatusEnum.pending) })]);
-const ToolCallRunningPartSchema = Type$2.Evaluate(Type$2.Intersect([ToolCallBaseSchema, ToolRunningSchema]));
-const ToolCallCompletedPartSchema = Type$2.Evaluate(Type$2.Intersect([ToolCallBaseSchema, ToolCompletedSchema]));
-const ToolCallErrorPartSchema = Type$2.Evaluate(Type$2.Intersect([ToolCallBaseSchema, ToolErrorSchema]));
-const ToolCallSkippedPartSchema = Type$2.Evaluate(Type$2.Intersect([ToolCallBaseSchema, ToolSkippedSchema]));
-const ToolCallAbortedPartSchema = Type$2.Evaluate(Type$2.Intersect([ToolCallBaseSchema, ToolAbortedSchema]));
-const ToolCallTerminalPartSchema = Type$2.Union([
-	ToolCallCompletedPartSchema,
-	ToolCallErrorPartSchema,
-	ToolCallSkippedPartSchema,
-	ToolCallAbortedPartSchema
-]);
-const ToolCallInFlightSchema = Type$2.Object({
-	callID: Type$2.String(),
-	name: Type$2.String(),
-	rawArgs: Type$2.Record(Type$2.String(), Type$2.Unknown()),
-	args: Type$2.Optional(Type$2.Unknown())
-});
-const ToolCallSchema = Type$2.Union([
-	ToolCallPendingPartSchema,
-	ToolCallRunningPartSchema,
-	ToolCallTerminalPartSchema
-]);
-const UsageSchema = Type$2.Object({
-	input: Type$2.Number(),
-	output: Type$2.Number(),
-	cacheRead: Type$2.Number(),
-	cacheWrite: Type$2.Number(),
-	reasoning: Type$2.Optional(Type$2.Number()),
-	totalTokens: Type$2.Number(),
-	cost: Type$2.Object({
-		input: Type$2.Number(),
-		output: Type$2.Number(),
-		cacheRead: Type$2.Number(),
-		cacheWrite: Type$2.Number(),
-		total: Type$2.Number()
-	})
-});
-const StopReasonSchema = Type$2.Union([
-	Type$2.Literal("stop"),
-	Type$2.Literal("length"),
-	Type$2.Literal("toolUse"),
-	Type$2.Literal("error"),
-	Type$2.Literal("aborted")
-]);
-const UserMessageSchema = Type$2.Object({
-	messageId: Type$2.String(),
-	role: Type$2.Literal("user"),
-	time: Type$2.Object({ created: Type$2.Number() }),
-	parts: Type$2.Array(Type$2.Union([TextContentSchema, ImageContentSchema]))
-});
-const AssistantMessageSchema = Type$2.Object({
-	role: Type$2.Literal("assistant"),
-	protocol: KnownProviderEnumSchema,
-	provider: ProviderInfo,
-	model: Type$2.String(),
-	usage: UsageSchema,
-	stopReason: StopReasonSchema,
-	errorMessage: Type$2.Optional(Type$2.String()),
-	/** Structured, provider-independent details for a failed request. */
-	failure: Type$2.Optional(FailureSchema),
-	time: Type$2.Object({
-		created: Type$2.Number(),
-		completed: Type$2.Number()
-	}),
-	parts: Type$2.Array(Type$2.Union([
-		TextContentSchema,
-		ImageContentSchema,
-		ThinkingContentSchema,
-		ToolCallSchema
-	])),
-	responseId: Type$2.Optional(Type$2.String()),
-	responseModel: Type$2.Optional(Type$2.String()),
-	messageId: Type$2.String()
-});
-const MessageSchema = Type$2.Union([UserMessageSchema, AssistantMessageSchema]);
-function createMessageId() {
-	return uuidv7();
-}
-function createUserMessage(message) {
-	const { messageId = createMessageId(), ...rest } = message;
-	return {
-		messageId,
-		...rest
-	};
-}
-function createAssistantMessage$1(message) {
-	const { messageId = createMessageId(), ...rest } = message;
-	return {
-		messageId,
-		...rest
-	};
-}
-const GrammarVariantsSchema = Type$2.Partial(Type$2.Object({
-	openai_lark: Type$2.String(),
-	openai_regex: Type$2.String()
-}));
-const ConstrainedSamplingSchema = Type$2.Union([Type$2.Object({
-	type: Type$2.Literal("json_schema"),
-	strict: Type$2.Union([Type$2.Literal("prefer"), Type$2.Literal("require")])
-}), Type$2.Object({
-	type: Type$2.Literal("grammar"),
-	variants: GrammarVariantsSchema
-})]);
-/**
-* Generic tool definition with typed parameter schema.
-* Usage:
-*
-* const search = Message.defineTool({
-*   name: "search",
-*   description: "Search documents",
-*   parameters: Type.Object({
-*     query: Type.String(),
-*     limit: Type.Optional(Type.Number()),
-*   }),
-* });
-*
-* type SearchParams = Static<typeof search.parameters>;
-*/
-const ToolSchema = Type$2.Object({
-	name: Type$2.String(),
-	description: Type$2.String(),
-	parameters: Type$2.Unsafe({}),
-	constrainedSampling: Type$2.Optional(Type$2.Union([Type$2.Literal(false), ConstrainedSamplingSchema]))
-});
-function defineTool(tool) {
-	return tool;
-}
-const ContextSchema = Type$2.Object({
-	systemPrompt: Type$2.Optional(Type$2.String()),
-	messages: Type$2.Array(MessageSchema),
-	tools: Type$2.Optional(Type$2.Array(ToolSchema))
-});
-function isUnresolvedToolCall(toolCall) {
-	return toolCall.status === ToolStatusEnum.pending || toolCall.status === ToolStatusEnum.running;
-}
-function syntheticSkippedToolCall(toolCall) {
-	const { status: _status, partial: _partial, ...base } = toolCall;
-	return {
-		...base,
-		status: ToolStatusEnum.skipped,
-		result: {
-			content: [{
-				type: "text",
-				text: "No result provided"
-			}],
-			isError: true
-		},
-		time: {
-			...toolCall.time,
-			end: Math.max(toolCall.time.end, Date.now())
-		}
-	};
-}
-function transformMessages(messages, model, normalizeToolCallId) {
-	const toolCallIDMap = /* @__PURE__ */ new Map();
-	const transformed = [];
-	for (const msg of messages) {
-		if (msg.role === "user") {
-			transformed.push(msg);
-			continue;
-		}
-		const assistantMsg = msg;
-		const isSameModel = assistantMsg.provider.id === model.provider.id && assistantMsg.protocol === model.protocol && assistantMsg.model === model.id;
-		const parts = assistantMsg.parts.flatMap((block) => {
-			if (block.type === "thinking") {
-				if (isSameModel && block.thinkingSignature) return block;
-				if (!block.thinking || block.thinking.trim() === "") return [];
-				if (isSameModel) return block;
-				return {
-					type: "text",
-					text: block.thinking
-				};
-			}
-			if (block.type === "text") {
-				if (isSameModel) return block;
-				return {
-					type: "text",
-					text: block.text
-				};
-			}
-			if (block.type === "toolCall") {
-				const toolCall = block;
-				let normalizedToolCall = toolCall;
-				if (!isSameModel && toolCall.thoughtSignature) {
-					normalizedToolCall = { ...toolCall };
-					delete normalizedToolCall.thoughtSignature;
-				}
-				const normalizedID = toolCallIDMap.get(block.callID);
-				if (normalizedID && normalizedID !== block.callID) normalizedToolCall = {
-					...normalizedToolCall,
-					callID: normalizedID
-				};
-				else if (!isSameModel && normalizeToolCallId) {
-					const nextID = normalizeToolCallId(toolCall.callID, model, assistantMsg);
-					if (nextID !== toolCall.callID) {
-						toolCallIDMap.set(toolCall.callID, nextID);
-						normalizedToolCall = {
-							...normalizedToolCall,
-							callID: nextID
-						};
-					}
-				}
-				return normalizedToolCall;
-			}
-			return block;
-		}).map((block) => {
-			if (block.type === "toolCall" && isUnresolvedToolCall(block)) return syntheticSkippedToolCall(block);
-			return block;
-		});
-		transformed.push({
-			...assistantMsg,
-			parts
-		});
-	}
-	return transformed;
-}
-//#endregion
+import Value from "typebox/value";
 //#region src/event/event.ts
 var event_exports = /* @__PURE__ */ __exportAll({
-	AgentEventSchema: () => AgentEventSchema,
-	AgentEventType: () => AgentEventType,
 	LLMMessageEventSchema: () => LLMMessageEventSchema,
 	LLMMessageEventType: () => LLMMessageEventType
 });
@@ -447,122 +113,10 @@ const LLMMessageEventSchema = Type$2.Union([
 		error: AssistantMessageSchema
 	})
 ]);
-const AgentEventType = {
-	agentStart: "agent.start",
-	agentEnd: "agent.end",
-	turnStart: "turn.start",
-	turnEnd: "turn.end",
-	messageStart: "message.start",
-	messagePartStart: "message.part.start",
-	messagePartUpdate: "message.part.update",
-	messagePartEnd: "message.part.end",
-	messageUpdate: "message.update",
-	messageEnd: "message.end",
-	toolExecutionStart: "tool.execution.start",
-	toolExecutionUpdate: "tool.execution.update",
-	toolExecutionEnd: "tool.execution.end"
-};
-const UserMessagePart = Type$2.Union([TextContentSchema, ImageContentSchema]);
-const AssistantMessagePart = Type$2.Union([
-	TextContentSchema,
-	ImageContentSchema,
-	ThinkingContentSchema,
-	ToolCallSchema
-]);
-const UserMessagePartStart = Type$2.Object({
-	type: Type$2.Literal(AgentEventType.messagePartStart),
-	message: UserMessageSchema,
-	partIndex: Type$2.Number(),
-	part: UserMessagePart
-});
-const UserMessagePartEnd = Type$2.Object({
-	type: Type$2.Literal(AgentEventType.messagePartEnd),
-	message: UserMessageSchema,
-	partIndex: Type$2.Number(),
-	part: UserMessagePart
-});
-const AssistantMessagePartStart = Type$2.Object({
-	type: Type$2.Literal(AgentEventType.messagePartStart),
-	message: AssistantMessageSchema,
-	partIndex: Type$2.Number(),
-	part: AssistantMessagePart
-});
-const AssistantMessagePartLLMUpdate = Type$2.Object({
-	type: Type$2.Literal(AgentEventType.messagePartUpdate),
-	message: AssistantMessageSchema,
-	partIndex: Type$2.Number(),
-	part: AssistantMessagePart,
-	source: Type$2.Literal("llm")
-});
-const AssistantMessagePartToolUpdate = Type$2.Object({
-	type: Type$2.Literal(AgentEventType.messagePartUpdate),
-	message: AssistantMessageSchema,
-	partIndex: Type$2.Number(),
-	part: AssistantMessagePart,
-	source: Type$2.Literal("tool")
-});
-const AssistantMessagePartEnd = Type$2.Object({
-	type: Type$2.Literal(AgentEventType.messagePartEnd),
-	message: AssistantMessageSchema,
-	partIndex: Type$2.Number(),
-	part: AssistantMessagePart
-});
-const ToolExecutionStartSchema = Type$2.Object({
-	type: Type$2.Literal(AgentEventType.toolExecutionStart),
-	messageId: Type$2.String(),
-	partIndex: Type$2.Number(),
-	toolCall: ToolCallPendingPartSchema
-});
-const ToolExecutionUpdateSchema = Type$2.Object({
-	type: Type$2.Literal(AgentEventType.toolExecutionUpdate),
-	messageId: Type$2.String(),
-	partIndex: Type$2.Number(),
-	toolCall: ToolCallRunningPartSchema
-});
-const ToolExecutionEndSchema = Type$2.Object({
-	type: Type$2.Literal(AgentEventType.toolExecutionEnd),
-	messageId: Type$2.String(),
-	partIndex: Type$2.Number(),
-	toolCall: ToolCallTerminalPartSchema
-});
 /**
 * Events emitted by the Agent lifecycle
 * These events provide fine-grained lifecycle information for messages, turns, and tool execution.
 */
-const AgentEventSchema = Type$2.Union([
-	Type$2.Object({ type: Type$2.Literal(AgentEventType.agentStart) }),
-	Type$2.Object({
-		type: Type$2.Literal(AgentEventType.agentEnd),
-		messages: Type$2.Array(MessageSchema)
-	}),
-	Type$2.Object({ type: Type$2.Literal(AgentEventType.turnStart) }),
-	Type$2.Object({
-		type: Type$2.Literal(AgentEventType.turnEnd),
-		message: AssistantMessageSchema
-	}),
-	Type$2.Object({
-		type: Type$2.Literal(AgentEventType.messageStart),
-		message: MessageSchema
-	}),
-	Type$2.Union([UserMessagePartStart, UserMessagePartEnd]),
-	Type$2.Union([
-		AssistantMessagePartStart,
-		AssistantMessagePartLLMUpdate,
-		AssistantMessagePartToolUpdate,
-		AssistantMessagePartEnd
-	]),
-	Type$2.Object({
-		type: Type$2.Literal(AgentEventType.messageUpdate),
-		message: MessageSchema
-	}),
-	Type$2.Object({
-		type: Type$2.Literal(AgentEventType.messageEnd),
-		message: MessageSchema
-	}),
-	ToolExecutionStartSchema,
-	ToolExecutionUpdateSchema,
-	ToolExecutionEndSchema
-]);
 //#endregion
 //#region src/llm.ts
 const llmImpl = async (provider, model, overrides) => getModel(provider, model, overrides);
@@ -641,6 +195,137 @@ function clearProtocolProviders() {
 	protocolRegistry.clear();
 }
 //#endregion
+//#region src/utils/estimate.ts
+/** Rough characters-per-token ratio across the tokenizers in use. */
+const CHARS_PER_TOKEN = 4;
+/** A base64 image costs far more than its own text length; this is a flat stand-in. */
+const ESTIMATED_IMAGE_CHARS = 4800;
+function calculateContextTokens(usage) {
+	return usage.totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+}
+function safeJsonStringify(value) {
+	try {
+		return JSON.stringify(value) ?? "undefined";
+	} catch {
+		return "[unserializable]";
+	}
+}
+function estimateTextTokens(text) {
+	return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function contentChars(content) {
+	let chars = 0;
+	for (const block of content) chars += block.type === "text" ? block.text.length : ESTIMATED_IMAGE_CHARS;
+	return chars;
+}
+function estimateContentTokens(content) {
+	return Math.ceil(contentChars(content) / CHARS_PER_TOKEN);
+}
+/**
+* A tool call costs its name, its arguments, and -- unlike providers that carry
+* results in their own messages -- the result it already holds.
+*/
+function toolCallChars(part) {
+	return part.name.length + safeJsonStringify(part.arguments).length + toolResultChars(part);
+}
+function toolResultChars(part) {
+	return "result" in part && part.result ? contentChars(part.result.content) : 0;
+}
+function estimateMessageTokens(message) {
+	if (message.role === "user") return estimateContentTokens(message.parts);
+	let chars = 0;
+	for (const part of message.parts) switch (part.type) {
+		case "text":
+			chars += part.text.length;
+			break;
+		case "image":
+			chars += ESTIMATED_IMAGE_CHARS;
+			break;
+		case "thinking":
+			chars += part.thinking.length;
+			break;
+		case "toolCall": chars += toolCallChars(part);
+	}
+	return Math.ceil(chars / CHARS_PER_TOKEN);
+}
+function lastAssistantUsage(messages) {
+	let latestPrefixTime = Number.NEGATIVE_INFINITY;
+	let found;
+	for (let i = 0; i < messages.length; i++) {
+		const message = messages[i];
+		if (message.role === "assistant") {
+			if (message.time.created >= latestPrefixTime && message.stopReason !== "aborted" && message.stopReason !== "error" && calculateContextTokens(message.usage) > 0) found = {
+				usage: message.usage,
+				index: i
+			};
+		}
+		latestPrefixTime = Math.max(latestPrefixTime, message.time.created);
+	}
+	return found;
+}
+function estimateMessages(messages) {
+	const usage = lastAssistantUsage(messages);
+	if (usage) {
+		const usageTokens = calculateContextTokens(usage.usage);
+		const latest = messages[usage.index];
+		let resultChars = 0;
+		for (const part of latest.parts) if (part.type === "toolCall") resultChars += toolResultChars(part);
+		let trailingTokens = Math.ceil(resultChars / CHARS_PER_TOKEN);
+		for (let i = usage.index + 1; i < messages.length; i++) trailingTokens += estimateMessageTokens(messages[i]);
+		return {
+			tokens: usageTokens + trailingTokens,
+			usageTokens,
+			trailingTokens,
+			lastUsageIndex: usage.index
+		};
+	}
+	let tokens = 0;
+	for (const message of messages) tokens += estimateMessageTokens(message);
+	return {
+		tokens,
+		usageTokens: 0,
+		trailingTokens: tokens,
+		lastUsageIndex: null
+	};
+}
+function estimateToolsTokens(tools) {
+	if (!tools || tools.length === 0) return 0;
+	return estimateTextTokens(safeJsonStringify(tools));
+}
+/** Tools discovered by execution of the given assistant turn or later turns. */
+function toolNamesAddedAfter(messages, index) {
+	const names = /* @__PURE__ */ new Set();
+	for (let i = index; i < messages.length; i++) {
+		const message = messages[i];
+		if (message.role !== "assistant") continue;
+		for (const part of message.parts) {
+			if (part.type !== "toolCall") continue;
+			for (const name of part.addedToolNames ?? []) names.add(name);
+		}
+	}
+	return names;
+}
+function estimateContextTokens(context) {
+	const estimate = estimateMessages(context.messages);
+	if (estimate.lastUsageIndex !== null) {
+		const added = toolNamesAddedAfter(context.messages, estimate.lastUsageIndex);
+		const addedTokens = estimateToolsTokens(context.tools?.filter((tool) => added.has(tool.name)));
+		return {
+			tokens: estimate.tokens + addedTokens,
+			usageTokens: estimate.usageTokens,
+			trailingTokens: estimate.trailingTokens + addedTokens,
+			lastUsageIndex: estimate.lastUsageIndex
+		};
+	}
+	const prefixTokens = (context.systemPrompt ? estimateTextTokens(context.systemPrompt) : 0) + estimateToolsTokens(context.tools);
+	return {
+		tokens: estimate.tokens + prefixTokens,
+		usageTokens: estimate.usageTokens,
+		trailingTokens: estimate.trailingTokens + prefixTokens,
+		lastUsageIndex: estimate.lastUsageIndex
+	};
+}
+//#endregion
 //#region src/llm/shared.ts
 const CacheRetention = Type$1.Union([
 	Type$1.Literal("none"),
@@ -662,22 +347,76 @@ const HelperOptions = Type$1.Object({
 	onPayload: Type$1.Optional(Type$1.Unsafe({})),
 	metadata: Type$1.Optional(Type$1.Record(Type$1.String(), Type$1.Unknown()))
 });
-const ThinkingBudgets = Type$1.Object({
-	minimal: Type$1.Optional(Type$1.Number()),
-	low: Type$1.Optional(Type$1.Number()),
-	medium: Type$1.Optional(Type$1.Number()),
-	high: Type$1.Optional(Type$1.Number()),
-	xhigh: Type$1.Optional(Type$1.Number()),
-	max: Type$1.Optional(Type$1.Number())
-});
+const ThinkingBudgets = ThinkingBudgets$1;
 const SharedOptions = Type$1.Evaluate(Type$1.Intersect([GenerationOptions, HelperOptions]));
-const DEFAULT_MAX_OUTPUT_TOKENS = 32e3;
-const CONTEXT_WINDOW_OUTPUT_TOLERANCE = 1024;
+/** Headroom left for the prompt when sizing a response against the context window. */
+const CONTEXT_SAFETY_TOKENS = 4096;
+const MIN_MAX_TOKENS = 1;
+/**
+* The model's own ceiling, unless the caller named a smaller one.
+*
+* No heuristic cap here: a catalog whose `maxTokens` spans the whole context
+* window is handled by {@link clampMaxTokensToContext}, which knows what the
+* prompt actually costs and does not have to guess.
+*/
 function applyDefaultMaxTokens(model, options) {
-	const defaultMaxTokens = model.maxTokens > 0 ? model.maxTokens >= model.contextWindow - CONTEXT_WINDOW_OUTPUT_TOLERANCE ? Math.min(model.maxTokens, DEFAULT_MAX_OUTPUT_TOKENS) : model.maxTokens : void 0;
 	return {
 		...options,
-		maxTokens: options?.maxTokens ?? defaultMaxTokens
+		maxTokens: options?.maxTokens ?? (model.maxTokens > 0 ? model.maxTokens : void 0)
+	};
+}
+/**
+* Shrink a response ceiling to what is left of the context window.
+*
+* Without this a long session asks for an answer that cannot fit and takes a
+* provider overflow error instead of a shorter answer.
+*/
+function clampMaxTokensToContext(model, context, maxTokens) {
+	if (model.contextWindow <= 0) return Math.max(MIN_MAX_TOKENS, maxTokens);
+	const available = model.contextWindow - estimateContextTokens(context).tokens - CONTEXT_SAFETY_TOKENS;
+	return Math.min(maxTokens, Math.max(MIN_MAX_TOKENS, available));
+}
+/** Tokens always left for the answer when a thinking budget shares the response ceiling. */
+const MIN_ANSWER_TOKENS = 1024;
+/**
+* Default thinking budget per level, in tokens.
+*
+* Absolute rather than a fraction of `model.maxTokens`: a fraction turns one
+* "medium" setting into wildly different budgets across models, and a budget is
+* a property of how hard the task is, not of how large the model's ceiling is.
+*/
+const DEFAULT_THINKING_BUDGETS = {
+	minimal: 1024,
+	low: 2048,
+	medium: 8192,
+	high: 16384
+};
+/** `xhigh` and `max` fall back to `high`'s budget unless one is configured for them. */
+function baseThinkingLevel(level) {
+	return level === "xhigh" || level === "max" ? "high" : level;
+}
+function thinkingBudgetForLevel(level, budgets) {
+	const base = baseThinkingLevel(level);
+	return budgets?.[level] ?? budgets?.[base] ?? DEFAULT_THINKING_BUDGETS[base];
+}
+/** Cap a thinking budget so at least {@link MIN_ANSWER_TOKENS} remain under a shared response ceiling. */
+function clampThinkingBudgetToAnswerRoom(thinkingBudget, ceiling) {
+	return Math.min(thinkingBudget, Math.max(0, ceiling - MIN_ANSWER_TOKENS));
+}
+/**
+* Fit a thinking budget and an answer inside one response ceiling.
+*
+* The caller's `maxTokens` is the room they want for the *answer*, so thinking is
+* added on top and the total is clamped to the model's ceiling. When even that
+* does not fit, the budget gives way -- never the answer.
+*/
+function adjustMaxTokensForThinking(baseMaxTokens, modelMaxTokens, level, budgets) {
+	let thinkingBudget = thinkingBudgetForLevel(level, budgets);
+	const maxTokens = baseMaxTokens === void 0 ? modelMaxTokens : Math.min(baseMaxTokens + thinkingBudget, modelMaxTokens);
+	if (maxTokens <= thinkingBudget) thinkingBudget = clampThinkingBudgetToAnswerRoom(thinkingBudget, maxTokens);
+	return {
+		maxTokens,
+		thinkingBudget
 	};
 }
 Type$1.Evaluate(Type$1.Intersect([SharedOptions, Type$1.Object({
@@ -747,7 +486,7 @@ var AssistantMessageEventStream = class extends EventStream {
 		super((event) => event.type === "done" || event.type === "error", (event) => {
 			if (event.type === "done") return event.message;
 			else if (event.type === "error") return event.error;
-			throw new Error("Unexpected event type for final result");
+			throw new Error("unexpected event type for final result");
 		});
 	}
 };
@@ -771,6 +510,53 @@ function compact(value) {
 	return result;
 }
 //#endregion
+//#region src/llm/pricing.ts
+/** Protocols that price a request by the OpenAI service tier it was served at. */
+const SERVICE_TIER_KEYS = /* @__PURE__ */ new Set(["openai", "openai-codex"]);
+function asString(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function bag(value, key) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const nested = value[key];
+	return typeof nested === "object" && nested !== null ? nested : void 0;
+}
+/** The tier the request asked for, before the provider says which one it used. */
+function requestedServiceTier(model, options, providerOptions) {
+	const key = optionsKey(model);
+	if (!SERVICE_TIER_KEYS.has(key)) return void 0;
+	return asString(providerOptions[key]?.serviceTier ?? options.factoryOptions?.serviceTier ?? model.options?.serviceTier);
+}
+/**
+* The tier the response was actually served at, which is what gets billed.
+*
+* A `"default"` response to an explicit flex or priority request still bills at
+* the requested tier: the Codex backend reports the fallback it used, not the
+* rate it charged.
+*/
+function servedServiceTier(model, requested, providerMetadata) {
+	const key = optionsKey(model);
+	if (!SERVICE_TIER_KEYS.has(key)) return void 0;
+	const served = asString(bag(providerMetadata, key)?.serviceTier);
+	if (key === "openai-codex" && served === "default" && (requested === "flex" || requested === "priority")) return requested;
+	return served ?? requested;
+}
+function serviceTierCostMultiplier(model, serviceTier) {
+	return serviceTier === void 0 ? 1 : model.cost.serviceTierMultipliers?.[serviceTier] ?? 1;
+}
+/**
+* Tokens Anthropic wrote with 1h retention, out of the total cache write.
+*
+* The AI SDK does not model the split, but it passes Anthropic's raw usage object
+* through untouched, so read it from there.
+*/
+function cacheWrite1hTokens(providerMetadata) {
+	for (const key of ["anthropic", "google-vertex-anthropic"]) {
+		const tokens = bag(bag(bag(providerMetadata, key), "usage"), "cache_creation")?.ephemeral_1h_input_tokens;
+		if (typeof tokens === "number") return tokens;
+	}
+}
+//#endregion
 //#region src/llm/runtime.ts
 function mergeHeaders(...headerSources) {
 	const merged = {};
@@ -804,7 +590,23 @@ function cleanHeaders(headers) {
 function resolveBaseURL(model, options) {
 	return (options.baseURL ?? model.api?.url ?? model.baseUrl) || void 0;
 }
-async function resolveAISDKLanguageModel(model, options) {
+/**
+* Inject a thinking-token budget the AI SDK has no field for.
+*
+* `@ai-sdk/openai-compatible` validates provider options against a closed schema,
+* so an endpoint-specific budget field cannot travel that way. `transformRequestBody`
+* is the SDK's own hook for exactly this: the last edit before the body is sent.
+*/
+function thinkingTokenBudgetTransform(field, budget, existing) {
+	const chain = typeof existing === "function" ? existing : void 0;
+	return (body) => {
+		return {
+			...chain ? chain(body) : body,
+			[field]: budget
+		};
+	};
+}
+async function resolveAISDKLanguageModel(model, options, thinkingTokenBudget) {
 	const npm = packageForModel(model);
 	const createProvider = await loadProviderFactory(npm);
 	const apiKey = options.apiKey ?? getEnvApiKey(model.provider);
@@ -824,19 +626,171 @@ async function resolveAISDKLanguageModel(model, options) {
 		});
 		factoryOptions.name ??= model.provider.id;
 		factoryOptions.includeUsage ??= true;
+		const budgetField = thinkingTokenBudgetField(model);
+		if (budgetField && thinkingTokenBudget !== void 0 && thinkingTokenBudget > 0) factoryOptions.transformRequestBody = thinkingTokenBudgetTransform(budgetField, thinkingTokenBudget, factoryOptions.transformRequestBody);
 	}
 	if (npm === "@codeworksh/ai-sdk-openai-codex") {
 		const cacheDisabled = options.cacheRetention === "none" || typeof process !== "undefined" && process.env.CODEWORK_CACHE_RETENTION === "none";
 		if (options.sessionId && !cacheDisabled) factoryOptions.sessionId ??= options.sessionId;
-		factoryOptions.compat ??= {
+		factoryOptions.compat = {
 			...model.compat,
-			supportsImages: model.input.includes("image")
+			supportsImages: model.input.includes("image"),
+			...typeof factoryOptions.compat === "object" && factoryOptions.compat !== null ? factoryOptions.compat : {}
 		};
 	}
 	const provider = createProvider(factoryOptions);
 	return resolveLanguageModel(provider, model, options.method);
 }
 //#endregion
+//#region src/llm/thinking.ts
+/** Anthropic rejects an enabled thinking block whose budget is under 1024 tokens. */
+const ANTHROPIC_MIN_THINKING_BUDGET = 1024;
+/**
+* The smallest budget this model will accept, for providers that take one at all.
+*
+* Adaptive models are exempt: they are sent an effort level and no budget, so
+* there is no floor to fall under.
+*/
+function minimumThinkingBudget(model) {
+	const key = optionsKey(model);
+	if (key !== "anthropic" && key !== "google-vertex-anthropic") return 0;
+	return model.compat?.forceAdaptiveThinking ? 0 : ANTHROPIC_MIN_THINKING_BUDGET;
+}
+function resolvePlan(model, context, options) {
+	const clampToContext = (maxTokens) => maxTokens === void 0 ? void 0 : clampMaxTokensToContext(model, context, maxTokens);
+	const requested = options.reasoning;
+	const level = requested ? clampThinkingLevel(model, requested) : "off";
+	if (level === "off") return {
+		level,
+		budget: 0,
+		maxTokens: clampToContext(options.maxTokens),
+		explicit: false
+	};
+	const budgets = {
+		...model.thinkingBudgets,
+		...options.thinkingBudgets
+	};
+	const explicit = options.thinkingBudgets?.[level] !== void 0;
+	const key = optionsKey(model);
+	const usesGoogleBudget = (key === "google" || key === "google-vertex") && !model.compat?.supportsThinkingLevel;
+	const requestedBudget = thinkingBudgetForLevel(level, budgets);
+	if (model.maxTokens <= 0) return {
+		level,
+		budget: requestedBudget,
+		maxTokens: clampToContext(options.maxTokens),
+		explicit
+	};
+	const dynamic = usesGoogleBudget && requestedBudget === -1;
+	const adjusted = adjustMaxTokensForThinking(options.maxTokens, model.maxTokens, level, { [level]: dynamic ? 0 : requestedBudget });
+	const maxTokens = clampMaxTokensToContext(model, context, adjusted.maxTokens);
+	const budget = maxTokens < adjusted.maxTokens ? clampThinkingBudgetToAnswerRoom(adjusted.thinkingBudget, maxTokens) : adjusted.thinkingBudget;
+	if (budget < minimumThinkingBudget(model)) return {
+		level: "off",
+		budget: 0,
+		maxTokens,
+		explicit
+	};
+	return {
+		level,
+		budget: dynamic ? -1 : budget,
+		maxTokens,
+		explicit
+	};
+}
+function googleThinkingLevel(mapped) {
+	return mapped === "xhigh" || mapped === "max" ? "high" : mapped;
+}
+/**
+* Turn thinking off, in the provider's own words.
+*
+* Several models reason by default, so declining to *ask* for thinking is not the
+* same as asking for none: the caller ends up paying output tokens for reasoning
+* they never requested.
+*
+* OpenRouter is deliberately left alone. It fronts hundreds of third-party
+* endpoints whose support varies per endpoint -- several reject the request
+* outright with "reasoning is mandatory for this endpoint and cannot be disabled"
+* -- so its reasoning stays pass-through.
+*/
+function disabledProviderOptions(model) {
+	if (!model.reasoning) return {};
+	const key = optionsKey(model);
+	if (key === "anthropic" || key === "google-vertex-anthropic") return { [key]: { thinking: { type: "disabled" } } };
+	if (key === "google" || key === "google-vertex") {
+		if (model.thinkingLevelMap?.off === null) return {};
+		return { [key]: { thinkingConfig: googleDisabledThinkingConfig(model) } };
+	}
+	if (key === "openai" || key === "xai" || key === "openai-codex") {
+		const off = model.thinkingLevelMap?.off;
+		if (off === null) return {};
+		return { [key]: { reasoningEffort: off ?? "none" } };
+	}
+	return {};
+}
+/**
+* Gemini 3 Pro cannot disable thinking, and Gemini 3 Flash and Gemma 4 cannot
+* fully disable it either. For those, ask for the lowest level and leave
+* `includeThoughts` off so the thinking stays hidden. Gemini 2.x takes a zero budget.
+*/
+function googleDisabledThinkingConfig(model) {
+	if (model.compat?.supportsThinkingLevel) return { thinkingLevel: model.thinkingLevelMap?.off ?? "minimal" };
+	return { thinkingBudget: 0 };
+}
+/**
+* The effort level an adaptive Claude model reasons at.
+*
+* A model's own `thinkingLevelMap` wins where it has an opinion -- that is where
+* per-model support for `xhigh` and `max` is recorded -- and the rest collapse onto
+* the three levels every adaptive model accepts.
+*/
+function anthropicEffort(model, level) {
+	const mapped = model.thinkingLevelMap?.[level];
+	if (typeof mapped === "string") return mapped;
+	switch (level) {
+		case "minimal":
+		case "low": return "low";
+		case "medium": return "medium";
+		case "xhigh": return "xhigh";
+		case "max": return "max";
+		default: return "high";
+	}
+}
+function reasoningProviderOptions(model, plan) {
+	const level = plan.level;
+	if (level === "off") return disabledProviderOptions(model);
+	const mapped = model.thinkingLevelMap?.[level] ?? level;
+	if (!mapped) return {};
+	const key = optionsKey(model);
+	const budget = plan.budget;
+	if (key === "openai" || key === "xai" || key === "openai-codex") return { [key]: { reasoningEffort: mapped } };
+	if (key === "openrouter") return { [key]: { reasoning: { effort: mapped === "off" ? "none" : mapped } } };
+	if (key === "google" || key === "google-vertex") {
+		const thinkingLevel = googleThinkingLevel(mapped);
+		if (model.compat?.supportsThinkingLevel) return { [key]: { thinkingConfig: {
+			thinkingLevel,
+			includeThoughts: true
+		} } };
+		return { [key]: { thinkingConfig: {
+			includeThoughts: true,
+			thinkingBudget: budget
+		} } };
+	}
+	if (key === "anthropic" || key === "google-vertex-anthropic") {
+		if (model.compat?.forceAdaptiveThinking) return { [key]: {
+			thinking: {
+				type: "adaptive",
+				display: "summarized"
+			},
+			effort: anthropicEffort(model, level)
+		} };
+		return { [key]: { thinking: {
+			type: "enabled",
+			budgetTokens: budget
+		} } };
+	}
+	return {};
+}
+//#endregion
 //#region src/utils/jsonparse.ts
 /**
 * @description Helper function to parse partial jsons during LLM streaming.
@@ -1011,7 +965,7 @@ function toolResultOutput(toolCall) {
 	const images = toolCall.result.content.filter((content) => content.type === "image");
 	if (toolCall.result.isError) return {
 		type: "error-text",
-		value: text || "Tool returned an error"
+		value: text || "tool returned an error"
 	};
 	if (images.length === 0) return {
 		type: "text",
@@ -1061,20 +1015,32 @@ function decodeOpenAIReasoningSignature(signature) {
 			itemId: parsed.itemId,
 			...typeof parsed.reasoningEncryptedContent === "string" || parsed.reasoningEncryptedContent === null ? { reasoningEncryptedContent: parsed.reasoningEncryptedContent } : {}
 		};
-	} catch {}
-	return { itemId: signature };
+	} catch {
+		return;
+	}
+}
+function googleThoughtSignature(metadata) {
+	if (!isRecord(metadata)) return;
+	for (const key of ["google", "google-vertex"]) {
+		const provider = metadata[key];
+		if (isRecord(provider) && typeof provider.thoughtSignature === "string") return provider.thoughtSignature;
+	}
 }
 function assistantMessages(message, model) {
 	if (message.stopReason === "error" || message.stopReason === "aborted") return [];
 	const assistantContent = [];
 	const toolResults = [];
+	const googleReplay = (model.protocol === "google" || model.protocol === "google-vertex") && message.protocol === model.protocol && message.provider.id === model.provider.id && message.model === model.id;
+	const googleOptions = (signature) => googleReplay && signature ? { [optionsKey(model)]: { thoughtSignature: signature } } : void 0;
 	for (const part of message.parts) {
+		const google = googleOptions(part.type === "text" ? part.textSignature : part.type === "thinking" ? part.thinkingSignature : part.type === "toolCall" ? part.thoughtSignature : void 0);
 		if (part.type === "text") {
 			const text = sanitizeSurrogates(part.text);
 			if (text.trim().length === 0) continue;
 			assistantContent.push({
 				type: "text",
 				text,
+				...google ? { providerOptions: google } : {},
 				...part.textSignature && message.protocol === KnownProviderEnum.openaiCodex ? { providerOptions: { "openai-codex": { messageId: part.textSignature } } } : {}
 			});
 			continue;
@@ -1088,8 +1054,11 @@ function assistantMessages(message, model) {
 			};
 			if (message.protocol === KnownProviderEnum.openai) {
 				if (!part.thinkingSignature) continue;
-				reasoning.providerOptions = { openai: decodeOpenAIReasoningSignature(part.thinkingSignature) };
-			} else if (part.thinkingSignature) reasoning.providerOptions = message.protocol === KnownProviderEnum.openaiCodex ? { "openai-codex": { reasoningItem: part.thinkingSignature } } : { anthropic: { signature: part.thinkingSignature } };
+				const openai = decodeOpenAIReasoningSignature(part.thinkingSignature);
+				if (!openai) continue;
+				reasoning.providerOptions = { openai };
+			} else if (google) reasoning.providerOptions = google;
+			else if (part.thinkingSignature && message.protocol !== "google" && message.protocol !== "google-vertex") reasoning.providerOptions = message.protocol === KnownProviderEnum.openaiCodex ? { "openai-codex": { reasoningItem: part.thinkingSignature } } : { anthropic: { signature: part.thinkingSignature } };
 			assistantContent.push(reasoning);
 			continue;
 		}
@@ -1102,6 +1071,7 @@ function assistantMessages(message, model) {
 			toolCallId: part.callID,
 			toolName: part.name,
 			input: sanitizeRecord(part.arguments ?? {}),
+			...google ? { providerOptions: google } : {},
 			...Object.keys(codexToolMetadata).length > 0 ? { providerOptions: { "openai-codex": codexToolMetadata } } : {}
 		});
 		const terminal = part.status === "pending" || part.status === "running" ? void 0 : part;
@@ -1112,7 +1082,7 @@ function assistantMessages(message, model) {
 			...terminal?.addedToolNames?.length ? { providerOptions: { "openai-codex": { addedToolNames: terminal.addedToolNames } } } : {},
 			output: terminal ? toolResultOutput(terminal) : {
 				type: "error-text",
-				value: "No result provided"
+				value: "no result provided"
 			}
 		});
 	}
@@ -1143,12 +1113,13 @@ function convertTools(tools, model) {
 	if (!tools || tools.length === 0) return;
 	const result = {};
 	for (const tool of tools) {
-		const constraint = model?.protocol === KnownProviderEnum.openaiCodex ? resolveOpenAICodexToolConstraint(tool, model.compat) : void 0;
+		const jsonSchemaConstraint = resolveJsonSchemaConstraint(tool, model?.compat);
+		const grammarConstraint = model?.protocol === KnownProviderEnum.openaiCodex ? resolveOpenAICodexToolConstraint(tool, model.compat) : void 0;
 		result[tool.name] = {
 			description: tool.description,
 			inputSchema: jsonSchema(tool.parameters),
-			...constraint?.type === "json_schema" ? { strict: true } : {},
-			...constraint?.type === "grammar" ? { providerOptions: { "openai-codex": { grammar: constraint } } } : {}
+			...jsonSchemaConstraint ? { strict: true } : {},
+			...grammarConstraint?.type === "grammar" ? { providerOptions: { "openai-codex": { grammar: grammarConstraint } } } : {}
 		};
 	}
 	return result;
@@ -1163,9 +1134,10 @@ function mapFinishReason(reason) {
 		default: return "stop";
 	}
 }
-function mapUsage(usage, model, costMultiplier = 1) {
+function mapUsage(usage, model, costMultiplier = 1, providerMetadata) {
 	const cacheRead = usage?.inputTokenDetails.cacheReadTokens ?? 0;
 	const cacheWrite = usage?.inputTokenDetails?.cacheWriteTokens ?? 0;
+	const cacheWrite1h = cacheWrite1hTokens(providerMetadata);
 	const input = usage?.inputTokenDetails?.noCacheTokens ?? Math.max((usage?.inputTokens ?? 0) - cacheRead - cacheWrite, 0);
 	const output = usage?.outputTokens ?? 0;
 	const totalTokens = usage?.totalTokens ?? input + cacheRead + cacheWrite + output;
@@ -1174,6 +1146,7 @@ function mapUsage(usage, model, costMultiplier = 1) {
 		output,
 		cacheRead,
 		cacheWrite,
+		...cacheWrite1h === void 0 ? {} : { cacheWrite1h },
 		...usage?.outputTokenDetails?.reasoningTokens !== void 0 ? { reasoning: usage.outputTokenDetails.reasoningTokens } : {},
 		totalTokens,
 		cost: {
@@ -1214,9 +1187,6 @@ function updateToolCallFromInput(block, partialJson) {
 }
 //#endregion
 //#region src/llm/stream.ts
-function providerOptionsKey(model) {
-	return model.providerOptionsKey ?? model.protocol;
-}
 function mergeProviderOptions(...sources) {
 	const result = {};
 	for (const source of sources) {
@@ -1238,7 +1208,7 @@ function configuredCacheRetention(options) {
 }
 function cacheProviderOptions(model, options) {
 	const retention = configuredCacheRetention(options);
-	const key = providerOptionsKey(model);
+	const key = optionsKey(model);
 	if (retention === "none") return {};
 	if (key === "openai") {
 		const openai = {};
@@ -1247,58 +1217,14 @@ function cacheProviderOptions(model, options) {
 		if (retention === "long") openai.promptCacheRetention = "24h";
 		return Object.keys(openai).length > 0 ? { [key]: openai } : {};
 	}
-	if (key === "openai-codex" && options.sessionId) return { [key]: { promptCacheKey: options.sessionId } };
 	if ((key === "anthropic" || key === "google-vertex-anthropic") && retention) return { [key]: { cacheControl: {
 		type: "ephemeral",
 		...retention === "long" ? { ttl: "1h" } : {}
 	} } };
 	return {};
 }
-const DEFAULT_THINKING_BUDGET_FRACTIONS = {
-	minimal: .05,
-	low: .1,
-	medium: .25,
-	high: .5,
-	xhigh: .8,
-	max: .95
-};
-const MIN_THINKING_BUDGET = 1024;
-function resolveThinkingBudget(model, options, level) {
-	const explicit = options.thinkingBudgets?.[level];
-	if (explicit !== void 0) return explicit;
-	const key = providerOptionsKey(model);
-	if (key === "anthropic" || key === "google-vertex-anthropic") {
-		const fraction = DEFAULT_THINKING_BUDGET_FRACTIONS[level];
-		return Math.max(Math.floor(model.maxTokens * fraction), MIN_THINKING_BUDGET);
-	}
-}
-function reasoningProviderOptions(model, options) {
-	const requestedLevel = options.reasoning;
-	if (!requestedLevel) return {};
-	const level = clampThinkingLevel(model, requestedLevel);
-	if (level === "off") return {};
-	const mapped = model.thinkingLevelMap?.[level] ?? level;
-	if (!mapped) return {};
-	const key = providerOptionsKey(model);
-	const budget = resolveThinkingBudget(model, options, level);
-	if (key === "openai" || key === "xai" || key === "openai-codex") return { [key]: { reasoningEffort: mapped } };
-	if (key === "openrouter") return { [key]: { reasoning: { effort: mapped === "off" ? "none" : mapped } } };
-	if (key === "google" || key === "google-vertex") {
-		const thinkingLevel = mapped === "xhigh" ? "high" : mapped;
-		return { [key]: { thinkingConfig: {
-			thinkingLevel,
-			includeThoughts: true,
-			...budget !== void 0 ? { thinkingBudget: budget } : {}
-		} } };
-	}
-	if (key === "anthropic" || key === "google-vertex-anthropic") return { [key]: { thinking: {
-		type: "enabled",
-		budgetTokens: budget ?? MIN_THINKING_BUDGET
-	} } };
-	return {};
-}
-function resolveProviderOptions(model, options) {
-	return mergeProviderOptions(model.providerOptions, cacheProviderOptions(model, options), reasoningProviderOptions(model, options), options.providerOptions);
+function resolveProviderOptions(model, options, plan) {
+	return mergeProviderOptions(model.providerOptions, cacheProviderOptions(model, options), reasoningProviderOptions(model, plan), options.providerOptions);
 }
 function partIndex(output, block) {
 	return output.parts.indexOf(block);
@@ -1410,6 +1336,8 @@ function finalizeToolCall(output, part, stream) {
 	block.name = part.toolName;
 	block.arguments = typeof part.input === "object" && part.input !== null ? part.input : {};
 	const namespace = openAICodexMetadata(part.providerMetadata)?.namespace;
+	const thoughtSignature = googleThoughtSignature(part.providerMetadata);
+	if (thoughtSignature) block.thoughtSignature = thoughtSignature;
 	if (typeof namespace === "string") block.namespace = namespace;
 	block.time.end = Date.now();
 	delete block.partialJson;
@@ -1422,13 +1350,15 @@ function finalizeToolCall(output, part, stream) {
 		partial: output
 	});
 }
-function handlePart(part, output, model, stream, costMultiplier) {
+function handlePart(part, output, model, stream, pricing) {
 	switch (part.type) {
 		case "text-start":
 			ensureTextBlock(output, part.id, stream);
 			break;
 		case "text-delta": {
 			const block = ensureTextBlock(output, part.id, stream);
+			const signature = googleThoughtSignature(part.providerMetadata);
+			if (signature) block.textSignature = signature;
 			block.text += part.text;
 			stream.push({
 				type: "text.delta",
@@ -1449,7 +1379,7 @@ function handlePart(part, output, model, stream, costMultiplier) {
 		case "reasoning-delta": {
 			const block = ensureThinkingBlock(output, part.id, stream);
 			block.thinking += part.text;
-			const sig = (part.providerMetadata?.anthropic)?.signature ?? (part.providerMetadata?.["google-vertex-anthropic"])?.signature;
+			const sig = (part.providerMetadata?.anthropic)?.signature ?? (part.providerMetadata?.["google-vertex-anthropic"])?.signature ?? googleThoughtSignature(part.providerMetadata);
 			if (typeof sig === "string") block.thinkingSignature = sig;
 			stream.push({
 				type: "thinking.delta",
@@ -1488,11 +1418,12 @@ function handlePart(part, output, model, stream, costMultiplier) {
 		case "finish-step":
 			output.responseId ||= part.response.id;
 			if (part.response.modelId && part.response.modelId !== model.id) output.responseModel ||= part.response.modelId;
-			output.usage = mapUsage(part.usage, model, costMultiplier);
+			pricing.providerMetadata = part.providerMetadata ?? pricing.providerMetadata;
+			output.usage = mapUsage(part.usage, model, resolvePricing(model, pricing), pricing.providerMetadata);
 			output.stopReason = mapFinishReason(part.finishReason);
 			break;
 		case "finish":
-			output.usage = mapUsage(part.totalUsage, model, costMultiplier);
+			output.usage = mapUsage(part.totalUsage, model, resolvePricing(model, pricing), pricing.providerMetadata);
 			output.stopReason = mapFinishReason(part.finishReason);
 			break;
 		case "abort":
@@ -1502,30 +1433,29 @@ function handlePart(part, output, model, stream, costMultiplier) {
 		case "error": throw part.error instanceof Error ? part.error : new Error(formatThrownError(part.error));
 	}
 }
-function resolveCostMultiplier(model, options, providerOptions) {
-	if (providerOptionsKey(model) !== "openai-codex") return 1;
-	const providerTier = providerOptions["openai-codex"]?.serviceTier;
-	const factoryTier = options.factoryOptions?.serviceTier;
-	const modelTier = model.options?.serviceTier;
-	const serviceTier = providerTier ?? factoryTier ?? modelTier;
-	if (serviceTier === "flex") return .5;
-	if (serviceTier === "priority") return model.id === "gpt-5.5" ? 2.5 : 2;
-	return 1;
+function resolvePricing(model, pricing) {
+	return serviceTierCostMultiplier(model, servedServiceTier(model, pricing.requestedServiceTier, pricing.providerMetadata));
 }
 /**
-* Resolve maxOutputTokens so that (maxOutputTokens + thinkingBudget) does not exceed model.maxTokens.
-* Without this adjustment @ai-sdk/anthropic logs a warning and silently caps the value.
+* The response ceiling to send, already fitted around the thinking budget by
+* {@link Thinking.resolvePlan}.
+*
+* `plan.maxTokens` is the whole response -- thinking and answer together, which is
+* what Anthropic's own `max_tokens` means. But `@ai-sdk/anthropic` treats
+* `maxOutputTokens` as the answer alone and adds the budget back on before sending
+* (`baseArgs.max_tokens = maxTokens + thinkingBudget`). Handing it the total there
+* would ask for the budget twice, so it gets the answer room and reconstructs the
+* total itself.
+*
+* That only applies when a budget is actually sent. An adaptive model is given an
+* effort level and no budget, so the SDK adds nothing and the total goes through
+* unchanged -- subtracting there would quietly under-ask by the whole budget.
 */
-function resolveMaxOutputTokens(model, options, providerOptions) {
-	const maxTokens = options.maxTokens;
-	if (maxTokens === void 0) return void 0;
-	const key = providerOptionsKey(model);
+function resolveMaxOutputTokens(model, plan) {
+	const key = optionsKey(model);
 	if (key === "openai-codex") return void 0;
-	if (key === "anthropic" || key === "google-vertex-anthropic") {
-		const budgetTokens = ((providerOptions?.[key])?.thinking)?.budgetTokens ?? 0;
-		if (budgetTokens > 0 && maxTokens + budgetTokens > model.maxTokens) return Math.max(model.maxTokens - budgetTokens, 1);
-	}
-	return maxTokens;
+	if (plan.maxTokens === void 0) return void 0;
+	return (key === "anthropic" || key === "google-vertex-anthropic") && !model.compat?.forceAdaptiveThinking ? plan.maxTokens - plan.budget : plan.maxTokens;
 }
 const stream$1 = (model, context, options) => {
 	const stream = new AssistantMessageEventStream();
@@ -1533,11 +1463,12 @@ const stream$1 = (model, context, options) => {
 	(async () => {
 		const output = createAssistantMessage(model);
 		try {
-			const languageModel = await resolveAISDKLanguageModel(model, runtimeOptions);
+			const plan = resolvePlan(model, context, runtimeOptions);
+			const languageModel = await resolveAISDKLanguageModel(model, runtimeOptions, plan.budget);
 			const tools = convertTools(context.tools, model);
 			const messages = convertMessages(context, model);
-			const providerOptions = resolveProviderOptions(model, runtimeOptions);
-			const costMultiplier = resolveCostMultiplier(model, runtimeOptions, providerOptions);
+			const providerOptions = resolveProviderOptions(model, runtimeOptions, plan);
+			const pricing = { requestedServiceTier: requestedServiceTier(model, runtimeOptions, providerOptions) };
 			const activeTools = runtimeOptions.activeTools?.filter((name) => !tools || name in tools);
 			let params = compact({
 				model: languageModel,
@@ -1546,7 +1477,7 @@ const stream$1 = (model, context, options) => {
 				tools,
 				toolChoice: runtimeOptions.toolChoice,
 				activeTools,
-				maxOutputTokens: resolveMaxOutputTokens(model, runtimeOptions, providerOptions),
+				maxOutputTokens: resolveMaxOutputTokens(model, plan),
 				temperature: runtimeOptions.temperature,
 				providerOptions,
 				abortSignal: runtimeOptions.signal,
@@ -1562,9 +1493,9 @@ const stream$1 = (model, context, options) => {
 				type: "start",
 				partial: output
 			});
-			for await (const part of result.fullStream) handlePart(part, output, model, stream, costMultiplier);
-			if (runtimeOptions.signal?.aborted || output.stopReason === "aborted") throw new Error(output.errorMessage || "Request was aborted");
-			if (output.stopReason === "error") throw new Error(output.errorMessage || "Provider returned an error stop reason");
+			for await (const part of result.fullStream) handlePart(part, output, model, stream, pricing);
+			if (runtimeOptions.signal?.aborted || output.stopReason === "aborted") throw new Error(output.errorMessage || "request was aborted");
+			if (output.stopReason === "error") throw new Error(output.errorMessage || "provider returned an error stop reason");
 			output.time.completed = Date.now();
 			stream.push({
 				type: "done",
@@ -1675,7 +1606,7 @@ function validateSchema(schema, value, label) {
 */
 function validateToolCall(tools, toolExecution) {
 	const tool = tools.find((t) => t.name === toolExecution.name);
-	if (!tool) throw new Error(`Tool "${toolExecution.name}" not found`);
+	if (!tool) throw new Error(`tool "${toolExecution.name}" not found`);
 	return validateToolArguments(tool, toolExecution);
 }
 /**