@codeworksh/aikit 0.3.1 → 0.4.1-dev.20260530133305

package/index.mjs

@@ -1,391 +1,498 @@
-import { Filesystem, NamedError, lazy } from "@codeworksh/utils";
-import { Type, TypeGuard } from "@sinclair/typebox";
-import { capitalize, keys, mapValues, pick, pipe } from "remeda";
-import Ajv from "ajv";
-import addFormats from "ajv-formats";
+import { d as NamedError, i as packageForModel, o as resolveLanguageModel, r as loadProviderFactory, s as Model } from "./registry-CYfzJ6lk.mjs";
+import Type$1, { Type, Type as Type$2 } from "typebox";
 import { uuidv7 } from "uuidv7";
-import Anthropic from "@anthropic-ai/sdk";
+import Value from "typebox/value";
+import { jsonSchema, streamText } from "ai";
 import { parse } from "partial-json";
-import OpenAI from "openai";
-import { transform } from "esbuild";
-//#region src/provider/provider.ts
-let Provider;
-(function(_Provider) {
-	const KnownProviderEnum = _Provider.KnownProviderEnum = {
-		anthropic: "anthropic",
-		openai: "openai",
-		githubCopilot: "github-copilot",
-		openrouter: "openrouter",
-		groq: "groq",
-		xai: "xai",
-		cerebras: "cerebras",
-		zai: "zai",
-		opencode: "opencode"
-	};
-	const KnownProviderSchema = _Provider.KnownProviderSchema = Type.Union([
-		Type.Literal(KnownProviderEnum.anthropic),
-		Type.Literal(KnownProviderEnum.openai),
-		Type.Literal(KnownProviderEnum.githubCopilot),
-		Type.Literal(KnownProviderEnum.openrouter),
-		Type.Literal(KnownProviderEnum.groq),
-		Type.Literal(KnownProviderEnum.xai),
-		Type.Literal(KnownProviderEnum.cerebras),
-		Type.Literal(KnownProviderEnum.zai),
-		Type.Literal(KnownProviderEnum.opencode)
-	]);
-	_Provider.Info = Type.Object({
-		id: KnownProviderSchema,
-		name: Type.String(),
-		env: Type.Array(Type.String()),
-		key: Type.Optional(Type.String()),
-		options: Type.Optional(Type.Record(Type.String(), Type.Any()))
+import Schema from "typebox/schema";
+//#region src/message/message.ts
+let Message;
+(function(_Message) {
+	const TextContentSchema = _Message.TextContentSchema = Type$1.Object({
+		type: Type$1.Literal("text"),
+		text: Type$1.String(),
+		textSignature: Type$1.Optional(Type$1.String())
 	});
-	_Provider.ReasoningEffortMapSchema = Type.Object({
-		minimal: Type.Optional(Type.String()),
-		low: Type.Optional(Type.String()),
-		medium: Type.Optional(Type.String()),
-		high: Type.Optional(Type.String()),
-		xhigh: Type.Optional(Type.String())
+	const ImageContentSchema = _Message.ImageContentSchema = Type$1.Object({
+		type: Type$1.Literal("image"),
+		data: Type$1.String(),
+		mimeType: Type$1.String()
 	});
-	_Provider.OpenRouterRoutingSchema = Type.Object({
-		only: Type.Optional(Type.Array(Type.String())),
-		order: Type.Optional(Type.Array(Type.String()))
+	const ThinkingContentSchema = _Message.ThinkingContentSchema = Type$1.Object({
+		type: Type$1.Literal("thinking"),
+		thinking: Type$1.String(),
+		thinkingSignature: Type$1.Optional(Type$1.String()),
+		redacted: Type$1.Optional(Type$1.Boolean())
 	});
-	_Provider.VercelGatewayRoutingSchema = Type.Object({
-		only: Type.Optional(Type.Array(Type.String())),
-		order: Type.Optional(Type.Array(Type.String()))
+	const ToolCallBaseSchema = _Message.ToolCallBaseSchema = Type$1.Object({
+		type: Type$1.Literal("toolCall"),
+		callID: Type$1.String(),
+		name: Type$1.String(),
+		arguments: Type$1.Record(Type$1.String(), Type$1.Any()),
+		thoughtSignature: Type$1.Optional(Type$1.String()),
+		time: Type$1.Object({
+			start: Type$1.Number(),
+			end: Type$1.Number()
+		})
 	});
-})(Provider || (Provider = {}));
-//#endregion
-//#region src/model/catalog.ts
-let ModelCatalog;
-(function(_ModelCatalog) {
-	function modelsDevURL() {
-		return process.env.OPENCODE_MODELS_URL || "https://models.dev";
-	}
-	function modelsDevPath() {
-		return process.env.CODEWORK_AIKIT_MODELS_PATH;
-	}
-	const modelsDevData = _ModelCatalog.modelsDevData = lazy(async () => {
-		const path = modelsDevPath();
-		if (path) {
-			const result = await Filesystem.readJson(path).catch(() => void 0);
-			if (result) return result;
-		}
-		const json = await fetch(`${modelsDevURL()}/api.json`).then((x) => x.text());
-		return JSON.parse(json);
+	const ToolSuccessResult = _Message.ToolSuccessResult = Type$1.Object({
+		content: Type$1.Array(Type$1.Union([TextContentSchema, ImageContentSchema])),
+		details: Type$1.Optional(Type$1.Any()),
+		isError: Type$1.Literal(false)
 	});
-	async function get() {
-		return modelsDevData();
-	}
-	_ModelCatalog.get = get;
-	async function refresh() {
-		const result = await fetch(`${modelsDevURL()}/api.json`, { signal: AbortSignal.timeout(10 * 1e3) }).catch(() => void 0);
-		if (!result?.ok) return;
-		const json = await result.text();
-		const path = modelsDevPath();
-		if (path) await Filesystem.write(path, json);
-		modelsDevData.reset();
-	}
-	_ModelCatalog.refresh = refresh;
-	ModelCatalog.refresh();
-	setInterval(async () => {
-		await ModelCatalog.refresh();
-	}, 60 * 1e3 * 60).unref();
-})(ModelCatalog || (ModelCatalog = {}));
-//#endregion
-//#region src/model/transform.ts
-function defaultBaseUrl(providerId) {
-	switch (providerId) {
-		case Provider.KnownProviderEnum.openai: return "https://api.openai.com/v1";
-		default: return;
-	}
-}
-function resolveDefaultProtocol(providerId) {
-	switch (providerId) {
-		case Provider.KnownProviderEnum.anthropic: return Model.KnownProtocolEnum.anthropicMessages;
-		case Provider.KnownProviderEnum.openai: return Model.KnownProtocolEnum.openaiResponses;
-		default: return Model.KnownProtocolEnum.openaiCompletions;
-	}
-}
-function applyModification(providerId, provider, model) {
-	const baseUrl = model.baseUrl ?? provider.baseUrl ?? provider.api ?? defaultBaseUrl(providerId);
-	const normalized = {
-		id: model.id,
-		name: model.name,
-		provider: Model.toProviderInfo(providerId, provider),
-		baseUrl,
-		reasoning: Boolean(model.reasoning),
-		input: Model.normalizeInput(model.modalities.input),
-		cost: {
-			input: model.cost?.input ?? 0,
-			output: model.cost?.output ?? 0,
-			cacheRead: model.cost?.cache_read ?? 0,
-			cacheWrite: model.cost?.cache_write ?? 0
-		},
-		contextWindow: model.limit?.context ?? 0,
-		maxTokens: model.limit?.output ?? 0,
-		headers: model.headers ?? provider.headers,
-		protocol: resolveDefaultProtocol(providerId)
-	};
-	if (providerId === Provider.KnownProviderEnum.openai) {
-		normalized.supportedProtocols = { openaiCompletions: Model.KnownProtocolEnum.openaiCompletions };
-		return normalized;
-	} else return normalized;
-}
-//#endregion
-//#region src/model/model.ts
-let Model;
-(function(_Model) {
-	const KnownProtocolEnum = _Model.KnownProtocolEnum = {
-		anthropicMessages: "anthropic-messages",
-		openaiCompletions: "openai-completions",
-		openaiResponses: "openai-responses"
+	const ToolErrorResult = _Message.ToolErrorResult = Type$1.Object({
+		content: Type$1.Array(Type$1.Union([TextContentSchema, ImageContentSchema])),
+		details: Type$1.Optional(Type$1.Any()),
+		isError: Type$1.Literal(true)
+	});
+	const ToolRunningPartial = _Message.ToolRunningPartial = Type$1.Object({
+		content: Type$1.Optional(Type$1.Array(Type$1.Union([TextContentSchema, ImageContentSchema]))),
+		details: Type$1.Optional(Type$1.Any())
+	});
+	const ToolStatusEnum = _Message.ToolStatusEnum = {
+		pending: "pending",
+		running: "running",
+		completed: "completed",
+		error: "error",
+		skipped: "skipped",
+		aborted: "aborted"
 	};
-	_Model.KnownProtocolSchema = Type.Union([
-		Type.Literal(KnownProtocolEnum.anthropicMessages),
-		Type.Literal(KnownProtocolEnum.openaiCompletions),
-		Type.Literal(KnownProtocolEnum.openaiResponses)
-	]);
-	const InputSchema = Type.Array(Type.Union([Type.Literal("text"), Type.Literal("image")]));
-	const CostSchema = Type.Object({
-		input: Type.Number(),
-		output: Type.Number(),
-		cacheRead: Type.Number(),
-		cacheWrite: Type.Number()
+	const ToolRunningSchema = _Message.ToolRunningSchema = Type$1.Object({
+		status: Type$1.Literal(ToolStatusEnum.running),
+		partial: Type$1.Optional(ToolRunningPartial)
 	});
-	const HeadersSchema = Type.Optional(Type.Record(Type.String(), Type.String()));
-	const SupportedProtocolsSchema = _Model.SupportedProtocolsSchema = Type.Object({
-		anthropicMessages: Type.Optional(Type.Literal(KnownProtocolEnum.anthropicMessages)),
-		openaiCompletions: Type.Optional(Type.Literal(KnownProtocolEnum.openaiCompletions)),
-		openaiResponses: Type.Optional(Type.Literal(KnownProtocolEnum.openaiResponses))
+	const ToolCompletedSchema = _Message.ToolCompletedSchema = Type$1.Object({
+		status: Type$1.Literal(ToolStatusEnum.completed),
+		result: ToolSuccessResult
 	});
-	const BaseSchema = _Model.BaseSchema = Type.Object({
-		id: Type.String(),
-		name: Type.String(),
-		provider: Provider.Info,
-		baseUrl: Type.String(),
-		reasoning: Type.Boolean(),
-		input: InputSchema,
-		cost: CostSchema,
-		contextWindow: Type.Number(),
-		maxTokens: Type.Number(),
-		headers: HeadersSchema,
-		supportedProtocols: Type.Optional(Type.Partial(SupportedProtocolsSchema))
+	const ToolErrorSchema = _Message.ToolErrorSchema = Type$1.Object({
+		status: Type$1.Literal(ToolStatusEnum.error),
+		result: ToolErrorResult
 	});
-	const OpenAICompletionsCompatSchema = _Model.OpenAICompletionsCompatSchema = Type.Object({
-		supportsStore: Type.Optional(Type.Boolean()),
-		supportsDeveloperRole: Type.Optional(Type.Boolean()),
-		supportsReasoningEffort: Type.Optional(Type.Boolean()),
-		reasoningEffortMap: Type.Optional(Provider.ReasoningEffortMapSchema),
-		supportsUsageInStreaming: Type.Optional(Type.Boolean()),
-		maxTokensField: Type.Optional(Type.Union([Type.Literal("max_completion_tokens"), Type.Literal("max_tokens")])),
-		requiresToolResultName: Type.Optional(Type.Boolean()),
-		requiresAssistantAfterToolResult: Type.Optional(Type.Boolean()),
-		requiresThinkingAsText: Type.Optional(Type.Boolean()),
-		thinkingFormat: Type.Optional(Type.Union([
-			Type.Literal("openai"),
-			Type.Literal("openrouter"),
-			Type.Literal("zai"),
-			Type.Literal("qwen"),
-			Type.Literal("qwen-chat-template")
-		])),
-		openRouterRouting: Type.Optional(Provider.OpenRouterRoutingSchema),
-		vercelGatewayRouting: Type.Optional(Provider.VercelGatewayRoutingSchema),
-		zaiToolStream: Type.Optional(Type.Boolean()),
-		supportsStrictMode: Type.Optional(Type.Boolean())
+	const ToolSkippedSchema = _Message.ToolSkippedSchema = Type$1.Object({
+		status: Type$1.Literal(ToolStatusEnum.skipped),
+		result: ToolErrorResult
 	});
-	const OpenAIResponsesCompatSchema = _Model.OpenAIResponsesCompatSchema = Type.Object({});
-	_Model.OpenAICompatSchema = Type.Union([OpenAICompletionsCompatSchema, OpenAIResponsesCompatSchema]);
-	const AnthropicSchema = _Model.AnthropicSchema = Type.Composite([BaseSchema, Type.Object({ protocol: Type.Literal(KnownProtocolEnum.anthropicMessages) })]);
-	const OpenAICompletionsSchema = _Model.OpenAICompletionsSchema = Type.Composite([BaseSchema, Type.Object({
-		protocol: Type.Literal(KnownProtocolEnum.openaiCompletions),
-		compat: Type.Optional(OpenAICompletionsCompatSchema)
-	})]);
-	const OpenAIResponsesSchema = _Model.OpenAIResponsesSchema = Type.Composite([BaseSchema, Type.Object({
-		protocol: Type.Literal(KnownProtocolEnum.openaiResponses),
-		compat: Type.Optional(OpenAIResponsesCompatSchema)
-	})]);
-	_Model.Info = Type.Union([
-		AnthropicSchema,
-		OpenAICompletionsSchema,
-		OpenAIResponsesSchema
+	const ToolAbortedSchema = _Message.ToolAbortedSchema = Type$1.Object({
+		status: Type$1.Literal(ToolStatusEnum.aborted),
+		result: ToolErrorResult
+	});
+	const ToolCallPendingPart = Type$1.Intersect([ToolCallBaseSchema, Type$1.Object({ status: Type$1.Literal(ToolStatusEnum.pending) })]);
+	const ToolCallRunningPart = Type$1.Evaluate(Type$1.Intersect([ToolCallBaseSchema, ToolRunningSchema]));
+	const ToolCallCompletedPart = Type$1.Evaluate(Type$1.Intersect([ToolCallBaseSchema, ToolCompletedSchema]));
+	const ToolCallErrorPart = Type$1.Evaluate(Type$1.Intersect([ToolCallBaseSchema, ToolErrorSchema]));
+	const ToolCallSkippedPart = Type$1.Evaluate(Type$1.Intersect([ToolCallBaseSchema, ToolSkippedSchema]));
+	const ToolCallAbortedPart = Type$1.Evaluate(Type$1.Intersect([ToolCallBaseSchema, ToolAbortedSchema]));
+	_Message.ToolCallInFlightSchema = Type$1.Object({
+		callID: Type$1.String(),
+		name: Type$1.String(),
+		rawArgs: Type$1.Record(Type$1.String(), Type$1.Unknown()),
+		args: Type$1.Optional(Type$1.Unknown())
+	});
+	const ToolCallSchema = _Message.ToolCallSchema = Type$1.Union([
+		ToolCallPendingPart,
+		ToolCallRunningPart,
+		ToolCallCompletedPart,
+		ToolCallErrorPart,
+		ToolCallSkippedPart,
+		ToolCallAbortedPart
 	]);
-	const BUILTINS = keys(Provider.KnownProviderEnum);
-	function calculateCost(model, usage) {
-		usage.cost.input = usage.input / 1e6 * model.cost.input;
-		usage.cost.output = usage.output / 1e6 * model.cost.output;
-		usage.cost.cacheRead = usage.cacheRead / 1e6 * model.cost.cacheRead;
-		usage.cost.cacheWrite = usage.cacheWrite / 1e6 * model.cost.cacheWrite;
-		usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
-	}
-	_Model.calculateCost = calculateCost;
-	function normalizeInput(input) {
-		const normalized = /* @__PURE__ */ new Set();
-		for (const modality of input ?? ["text"]) if (modality === "text" || modality === "image") normalized.add(modality);
-		if (normalized.size === 0) normalized.add("text");
-		return [...normalized];
+	const UsageSchema = _Message.UsageSchema = Type$1.Object({
+		input: Type$1.Number(),
+		output: Type$1.Number(),
+		cacheRead: Type$1.Number(),
+		cacheWrite: Type$1.Number(),
+		totalTokens: Type$1.Number(),
+		cost: Type$1.Object({
+			input: Type$1.Number(),
+			output: Type$1.Number(),
+			cacheRead: Type$1.Number(),
+			cacheWrite: Type$1.Number(),
+			total: Type$1.Number()
+		})
+	});
+	const StopReasonSchema = _Message.StopReasonSchema = Type$1.Union([
+		Type$1.Literal("stop"),
+		Type$1.Literal("length"),
+		Type$1.Literal("toolUse"),
+		Type$1.Literal("error"),
+		Type$1.Literal("aborted")
+	]);
+	const UserMessageSchema = _Message.UserMessageSchema = Type$1.Object({
+		messageId: Type$1.String(),
+		role: Type$1.Literal("user"),
+		time: Type$1.Object({ created: Type$1.Number() }),
+		parts: Type$1.Array(Type$1.Union([TextContentSchema, ImageContentSchema]))
+	});
+	const AssistantMessageSchema = _Message.AssistantMessageSchema = Type$1.Object({
+		role: Type$1.Literal("assistant"),
+		protocol: Model.KnownProviderEnumSchema,
+		provider: Model.ProviderInfo,
+		model: Type$1.String(),
+		usage: UsageSchema,
+		stopReason: StopReasonSchema,
+		errorMessage: Type$1.Optional(Type$1.String()),
+		time: Type$1.Object({
+			created: Type$1.Number(),
+			completed: Type$1.Number()
+		}),
+		parts: Type$1.Array(Type$1.Union([
+			TextContentSchema,
+			ImageContentSchema,
+			ThinkingContentSchema,
+			ToolCallSchema
+		])),
+		responseId: Type$1.Optional(Type$1.String()),
+		responseModel: Type$1.Optional(Type$1.String()),
+		messageId: Type$1.String()
+	});
+	const MessageSchema = _Message.MessageSchema = Type$1.Union([UserMessageSchema, AssistantMessageSchema]);
+	function createMessageId() {
+		return uuidv7();
 	}
-	_Model.normalizeInput = normalizeInput;
-	function toProviderInfo(providerId, provider) {
+	_Message.createMessageId = createMessageId;
+	function createUserMessage(message) {
+		const { messageId = createMessageId(), ...rest } = message;
 		return {
-			id: providerId,
-			name: provider.name,
-			env: provider.env,
-			key: provider.key,
-			options: provider.headers
+			messageId,
+			...rest
 		};
 	}
-	_Model.toProviderInfo = toProviderInfo;
-	function toModelValue(providerId, provider, model) {
-		return applyModification(providerId, provider, model);
-	}
-	async function getBuiltInModels() {
-		return pipe(await ModelCatalog.get(), pick(BUILTINS), mapValues((provider, providerId) => mapValues(provider.models, (model) => toModelValue(providerId, provider, model))));
-	}
-	_Model.getBuiltInModels = getBuiltInModels;
-	const registry = _Model.registry = lazy(async () => {
-		const registry = /* @__PURE__ */ new Map();
-		const models = await getBuiltInModels();
-		for (const [provider, value] of Object.entries(models)) {
-			const providerModels = /* @__PURE__ */ new Map();
-			for (const [id, model] of Object.entries(value)) providerModels.set(id, model);
-			registry.set(provider, providerModels);
-		}
-		return registry;
-	});
-	async function getModel(provider, model, overrides) {
-		const result = (await registry()).get(provider)?.get(model);
-		if (result && overrides) return {
-			...result,
-			...overrides
+	_Message.createUserMessage = createUserMessage;
+	function createAssistantMessage(message) {
+		const { messageId = createMessageId(), ...rest } = message;
+		return {
+			messageId,
+			...rest
 		};
-		return result;
-	}
-	_Model.getModel = getModel;
-	async function getProviders() {
-		const data = await registry();
-		return Array.from(data.keys());
 	}
-	_Model.getProviders = getProviders;
-	async function getModels(provider) {
-		const models = (await registry()).get(provider);
-		return models ? Array.from(models.values()) : [];
+	_Message.createAssistantMessage = createAssistantMessage;
+	const ToolSchema = _Message.ToolSchema = Type$1.Object({
+		name: Type$1.String(),
+		description: Type$1.String(),
+		parameters: Type$1.Unsafe({})
+	});
+	function defineTool(tool) {
+		return tool;
 	}
-	_Model.getModels = getModels;
-	function isGpt5OrLater(modelID) {
-		const match = /^gpt-(\d+)/.exec(modelID);
-		if (!match) return false;
-		return Number(match[1]) >= 5;
+	_Message.defineTool = defineTool;
+	_Message.ContextSchema = Type$1.Object({
+		systemPrompt: Type$1.Optional(Type$1.String()),
+		messages: Type$1.Array(MessageSchema),
+		tools: Type$1.Optional(Type$1.Array(ToolSchema))
+	});
+	function isUnresolvedToolCall(toolCall) {
+		return toolCall.status === ToolStatusEnum.pending || toolCall.status === ToolStatusEnum.running;
 	}
-	function supportsXhigh(model) {
-		return isGpt5OrLater(model.id);
+	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())
+			}
+		};
 	}
-	_Model.supportsXhigh = supportsXhigh;
-	function modelsAreEqual(a, b) {
-		if (!a || !b) return false;
-		return a.id === b.id && a.provider.id === b.provider.id;
+	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;
 	}
-	_Model.modelsAreEqual = modelsAreEqual;
-})(Model || (Model = {}));
+	_Message.transformMessages = transformMessages;
+})(Message || (Message = {}));
 //#endregion
-//#region src/provider/stream.ts
-let Stream;
-(function(_Stream) {
-	const ProtocolProviderNotFoundError = _Stream.ProtocolProviderNotFoundError = NamedError.create("ProtocolProviderNotFoundError", Type.Object({ protocol: Model.KnownProtocolSchema }));
-	const ProtocolMismatchError = _Stream.ProtocolMismatchError = NamedError.create("ProtocolMismatchError", Type.Object({
-		actual: Model.KnownProtocolSchema,
-		expected: Model.KnownProtocolSchema
-	}));
-	const ThinkingLevelEnum = _Stream.ThinkingLevelEnum = {
-		off: "off",
-		minimal: "minimal",
-		low: "low",
-		medium: "medium",
-		high: "high",
-		xhigh: "xhigh"
+//#region src/event/event.ts
+let Event;
+(function(_Event) {
+	const LLMMessageEventType = _Event.LLMMessageEventType = {
+		start: "start",
+		textStart: "text.start",
+		textDelta: "text.delta",
+		textEnd: "text.end",
+		thinkingStart: "thinking.start",
+		thinkingDelta: "thinking.delta",
+		thinkingEnd: "thinking.end",
+		toolcallStart: "toolcall.start",
+		toolcallDelta: "toolcall.delta",
+		toolcallEnd: "toolcall.end",
+		toolcallFinal: "toolcall.final",
+		done: "done",
+		error: "error"
 	};
-	const ThinkingLevelSchema = _Stream.ThinkingLevelSchema = Type.Union([
-		Type.Literal(ThinkingLevelEnum.off),
-		Type.Literal(ThinkingLevelEnum.minimal),
-		Type.Literal(ThinkingLevelEnum.low),
-		Type.Literal(ThinkingLevelEnum.medium),
-		Type.Literal(ThinkingLevelEnum.high),
-		Type.Literal(ThinkingLevelEnum.xhigh)
-	]);
-	const ThinkingBudgetsSchema = _Stream.ThinkingBudgetsSchema = Type.Object({
-		off: Type.Optional(Type.Number()),
-		minimal: Type.Optional(Type.Number()),
-		low: Type.Optional(Type.Number()),
-		medium: Type.Optional(Type.Number()),
-		high: Type.Optional(Type.Number())
-	});
-	const CacheRetentionSchema = _Stream.CacheRetentionSchema = Type.Union([
-		Type.Literal("none"),
-		Type.Literal("short"),
-		Type.Literal("long")
+	_Event.LLMMessageEventSchema = Type$1.Union([
+		Type$1.Object({
+			type: Type$1.Literal(LLMMessageEventType.start),
+			partial: Message.AssistantMessageSchema
+		}),
+		Type$1.Object({
+			type: Type$1.Literal(LLMMessageEventType.textStart),
+			partIndex: Type$1.Number(),
+			partial: Message.AssistantMessageSchema
+		}),
+		Type$1.Object({
+			type: Type$1.Literal(LLMMessageEventType.textDelta),
+			partIndex: Type$1.Number(),
+			delta: Type$1.String(),
+			partial: Message.AssistantMessageSchema
+		}),
+		Type$1.Object({
+			type: Type$1.Literal(LLMMessageEventType.textEnd),
+			partIndex: Type$1.Number(),
+			content: Type$1.String(),
+			partial: Message.AssistantMessageSchema
+		}),
+		Type$1.Object({
+			type: Type$1.Literal(LLMMessageEventType.thinkingStart),
+			partIndex: Type$1.Number(),
+			partial: Message.AssistantMessageSchema
+		}),
+		Type$1.Object({
+			type: Type$1.Literal(LLMMessageEventType.thinkingDelta),
+			partIndex: Type$1.Number(),
+			delta: Type$1.String(),
+			partial: Message.AssistantMessageSchema
+		}),
+		Type$1.Object({
+			type: Type$1.Literal(LLMMessageEventType.thinkingEnd),
+			partIndex: Type$1.Number(),
+			content: Type$1.String(),
+			partial: Message.AssistantMessageSchema
+		}),
+		Type$1.Object({
+			type: Type$1.Literal(LLMMessageEventType.toolcallStart),
+			partIndex: Type$1.Number(),
+			partial: Message.AssistantMessageSchema
+		}),
+		Type$1.Object({
+			type: Type$1.Literal(LLMMessageEventType.toolcallDelta),
+			partIndex: Type$1.Number(),
+			delta: Type$1.String(),
+			partial: Message.AssistantMessageSchema
+		}),
+		Type$1.Object({
+			type: Type$1.Literal(LLMMessageEventType.toolcallEnd),
+			partIndex: Type$1.Number(),
+			toolCall: Message.ToolCallSchema,
+			partial: Message.AssistantMessageSchema
+		}),
+		Type$1.Object({
+			type: Type$1.Literal(LLMMessageEventType.toolcallFinal),
+			partIndex: Type$1.Number(),
+			toolCall: Message.ToolCallSchema,
+			partial: Message.AssistantMessageSchema
+		}),
+		Type$1.Object({
+			type: Type$1.Literal(LLMMessageEventType.done),
+			reason: Type$1.Union([
+				Type$1.Literal("stop"),
+				Type$1.Literal("length"),
+				Type$1.Literal("toolUse")
+			]),
+			message: Message.AssistantMessageSchema
+		}),
+		Type$1.Object({
+			type: Type$1.Literal(LLMMessageEventType.error),
+			reason: Type$1.Union([Type$1.Literal("aborted"), Type$1.Literal("error")]),
+			error: Message.AssistantMessageSchema
+		})
 	]);
-	const TransportSchema = _Stream.TransportSchema = Type.Union([
-		Type.Literal("sse"),
-		Type.Literal("websocket"),
-		Type.Literal("auto")
+	const AgentEventType = _Event.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$1.Union([Message.TextContentSchema, Message.ImageContentSchema]);
+	const AssistantMessagePart = Type$1.Union([
+		Message.TextContentSchema,
+		Message.ImageContentSchema,
+		Message.ThinkingContentSchema,
+		Message.ToolCallSchema
 	]);
-	const OptionsSchema = _Stream.OptionsSchema = Type.Object({
-		temperature: Type.Optional(Type.Number()),
-		maxTokens: Type.Optional(Type.Number()),
-		signal: Type.Optional(Type.Unsafe()),
-		apiKey: Type.Optional(Type.String()),
-		transport: Type.Optional(TransportSchema),
-		cacheRetention: Type.Optional(CacheRetentionSchema),
-		sessionId: Type.Optional(Type.String()),
-		onPayload: Type.Optional(Type.Unsafe()),
-		headers: Type.Optional(Type.Record(Type.String(), Type.String())),
-		maxRetryDelayMs: Type.Optional(Type.Number()),
-		metadata: Type.Optional(Type.Record(Type.String(), Type.Unknown()))
+	const UserMessagePartStart = Type$1.Object({
+		type: Type$1.Literal(AgentEventType.messagePartStart),
+		message: Message.UserMessageSchema,
+		partIndex: Type$1.Number(),
+		part: UserMessagePart
 	});
-	_Stream.SimpleOptionsSchema = Type.Composite([OptionsSchema, Type.Object({
-		reasoning: Type.Optional(ThinkingLevelSchema),
-		thinkingBudgets: Type.Optional(ThinkingBudgetsSchema)
-	})]);
-	function buildBaseOptions(model, options, apiKey) {
-		return {
-			temperature: options?.temperature,
-			maxTokens: options?.maxTokens || Math.min(model.maxTokens, 32e3),
-			signal: options?.signal,
-			apiKey: apiKey || options?.apiKey,
-			transport: options?.transport,
-			cacheRetention: options?.cacheRetention,
-			sessionId: options?.sessionId,
-			headers: options?.headers,
-			onPayload: options?.onPayload,
-			maxRetryDelayMs: options?.maxRetryDelayMs,
-			metadata: options?.metadata
-		};
-	}
-	_Stream.buildBaseOptions = buildBaseOptions;
-	function clampReasoning(effort) {
-		return effort === ThinkingLevelEnum.xhigh ? ThinkingLevelEnum.high : effort;
-	}
-	_Stream.clampReasoning = clampReasoning;
-	function adjustMaxTokensForThinking(baseMaxTokens, modelMaxTokens, reasoningLevel, customBudgets) {
-		const budgets = {
-			minimal: 1024,
-			low: 2048,
-			medium: 8192,
-			high: 16384,
-			...customBudgets
-		};
-		const minOutputTokens = 1024;
-		let thinkingBudget = budgets[clampReasoning(reasoningLevel)];
-		const maxTokens = Math.min(baseMaxTokens + thinkingBudget, modelMaxTokens);
-		if (maxTokens <= thinkingBudget) thinkingBudget = Math.max(0, maxTokens - minOutputTokens);
-		return {
-			maxTokens,
-			thinkingBudget
-		};
-	}
-	_Stream.adjustMaxTokensForThinking = adjustMaxTokensForThinking;
-	const protocolProviderRegistry = /* @__PURE__ */ new Map();
+	const UserMessagePartEnd = Type$1.Object({
+		type: Type$1.Literal(AgentEventType.messagePartEnd),
+		message: Message.UserMessageSchema,
+		partIndex: Type$1.Number(),
+		part: UserMessagePart
+	});
+	const AssistantMessagePartStart = Type$1.Object({
+		type: Type$1.Literal(AgentEventType.messagePartStart),
+		message: Message.AssistantMessageSchema,
+		partIndex: Type$1.Number(),
+		part: AssistantMessagePart
+	});
+	const AssistantMessagePartLLMUpdate = Type$1.Object({
+		type: Type$1.Literal(AgentEventType.messagePartUpdate),
+		message: Message.AssistantMessageSchema,
+		partIndex: Type$1.Number(),
+		part: AssistantMessagePart,
+		source: Type$1.Literal("llm")
+	});
+	const AssistantMessagePartToolUpdate = Type$1.Object({
+		type: Type$1.Literal(AgentEventType.messagePartUpdate),
+		message: Message.AssistantMessageSchema,
+		partIndex: Type$1.Number(),
+		part: AssistantMessagePart,
+		source: Type$1.Literal("tool")
+	});
+	const AssistantMessagePartEnd = Type$1.Object({
+		type: Type$1.Literal(AgentEventType.messagePartEnd),
+		message: Message.AssistantMessageSchema,
+		partIndex: Type$1.Number(),
+		part: AssistantMessagePart
+	});
+	const ToolExecutionStartSchema = Type$1.Evaluate(Type$1.Intersect([Message.ToolCallInFlightSchema, Type$1.Object({ type: Type$1.Literal(AgentEventType.toolExecutionStart) })]));
+	const ToolExecutionUpdateSchema = Type$1.Evaluate(Type$1.Intersect([
+		Message.ToolCallInFlightSchema,
+		Type$1.Object({ type: Type$1.Literal(AgentEventType.toolExecutionUpdate) }),
+		Message.ToolRunningSchema
+	]));
+	const ToolExecutionEndSchema = Type$1.Evaluate(Type$1.Intersect([
+		Message.ToolCallInFlightSchema,
+		Type$1.Object({ type: Type$1.Literal(AgentEventType.toolExecutionEnd) }),
+		Type$1.Union([Message.ToolCompletedSchema, Message.ToolErrorSchema])
+	]));
+	_Event.AgentEventSchema = Type$1.Union([
+		Type$1.Object({ type: Type$1.Literal(AgentEventType.agentStart) }),
+		Type$1.Object({
+			type: Type$1.Literal(AgentEventType.agentEnd),
+			messages: Type$1.Array(Message.MessageSchema)
+		}),
+		Type$1.Object({ type: Type$1.Literal(AgentEventType.turnStart) }),
+		Type$1.Object({
+			type: Type$1.Literal(AgentEventType.turnEnd),
+			message: Message.AssistantMessageSchema
+		}),
+		Type$1.Object({
+			type: Type$1.Literal(AgentEventType.messageStart),
+			message: Message.MessageSchema
+		}),
+		Type$1.Union([UserMessagePartStart, UserMessagePartEnd]),
+		Type$1.Union([
+			AssistantMessagePartStart,
+			AssistantMessagePartLLMUpdate,
+			AssistantMessagePartToolUpdate,
+			AssistantMessagePartEnd
+		]),
+		Type$1.Object({
+			type: Type$1.Literal(AgentEventType.messageUpdate),
+			message: Message.MessageSchema
+		}),
+		Type$1.Object({
+			type: Type$1.Literal(AgentEventType.messageEnd),
+			message: Message.MessageSchema
+		}),
+		ToolExecutionStartSchema,
+		ToolExecutionUpdateSchema,
+		ToolExecutionEndSchema
+	]);
+})(Event || (Event = {}));
+//#endregion
+//#region src/llm.ts
+const llmImpl = async (provider, model, overrides) => Model.getModel(provider, model, overrides);
+const llm = Object.assign(llmImpl, {
+	model: Model.getModel,
+	models: Model.getModels,
+	providers: Model.getProviders,
+	registry: Model.registry,
+	modelsAreEqual: Model.modelsAreEqual
+});
+//#endregion
+//#region src/llm/protocol.ts
+let Protocol;
+(function(_Protocol) {
+	const ProviderProtocolNotFoundError = _Protocol.ProviderProtocolNotFoundError = NamedError.create("ProviderProtocolNotFoundError", Type$1.Object({ protocol: Model.KnownProviderEnumSchema }));
+	const ProtocolMismatchError = _Protocol.ProtocolMismatchError = NamedError.create("ProtocolMismatchError", Type$1.Object({
+		actual: Model.KnownProviderEnumSchema,
+		expected: Model.KnownProviderEnumSchema
+	}));
+	_Protocol.ProtocolAuthError = NamedError.create("ProtocolAuthError", Type$1.Object({
+		message: Type$1.String(),
+		protocol: Type$1.String()
+	}));
+	const protocolRegistry = /* @__PURE__ */ new Map();
 	function wrapStream(protocol, stream) {
 		return (model, context, options) => {
 			if (model.protocol !== protocol) throw new ProtocolMismatchError({
@@ -395,65 +502,98 @@ let Stream;
 			return stream(model, context, options);
 		};
 	}
-	function wrapStreamSimple(protocol, streamSimple) {
-		return (model, context, options) => {
-			if (model.protocol !== protocol) throw new ProtocolMismatchError({
-				actual: model.protocol,
-				expected: protocol
-			});
-			return streamSimple(model, context, options);
-		};
-	}
 	function registerProtocolProvider(provider, sourceId) {
-		protocolProviderRegistry.set(provider.protocol, {
-			provider: {
-				protocol: provider.protocol,
-				stream: wrapStream(provider.protocol, provider.stream),
-				streamSimple: wrapStreamSimple(provider.protocol, provider.streamSimple)
-			},
+		const registered = {
+			protocol: provider.protocol,
+			stream: wrapStream(provider.protocol, provider.stream)
+		};
+		protocolRegistry.set(provider.protocol, {
+			provider: registered,
 			sourceId
 		});
 	}
-	_Stream.registerProtocolProvider = registerProtocolProvider;
+	_Protocol.registerProtocolProvider = registerProtocolProvider;
 	function getProtocolProvider(protocol) {
-		return protocolProviderRegistry.get(protocol)?.provider;
+		return protocolRegistry.get(protocol)?.provider;
 	}
-	_Stream.getProtocolProvider = getProtocolProvider;
+	_Protocol.getProtocolProvider = getProtocolProvider;
 	function resolveProtocolProvider(model) {
 		const provider = getProtocolProvider(model.protocol);
-		if (!provider) throw new ProtocolProviderNotFoundError({ protocol: model.protocol });
+		if (!provider) throw new ProviderProtocolNotFoundError({ protocol: model.protocol });
 		return provider;
 	}
-	_Stream.resolveProtocolProvider = resolveProtocolProvider;
+	_Protocol.resolveProtocolProvider = resolveProtocolProvider;
+	function getProtocolProviders() {
+		return Array.from(protocolRegistry.values(), (entry) => entry.provider);
+	}
+	_Protocol.getProtocolProviders = getProtocolProviders;
 	function stream(model, context, options) {
 		return resolveProtocolProvider(model).stream(model, context, options);
 	}
-	_Stream.stream = stream;
+	_Protocol.stream = stream;
 	async function complete(model, context, options) {
 		return stream(model, context, options).result();
 	}
-	_Stream.complete = complete;
-	function streamSimple(model, context, options) {
-		return resolveProtocolProvider(model).streamSimple(model, context, options);
-	}
-	_Stream.streamSimple = streamSimple;
-	async function completeSimple(model, context, options) {
-		return streamSimple(model, context, options).result();
-	}
-	_Stream.completeSimple = completeSimple;
-	function getApiProviders() {
-		return Array.from(protocolProviderRegistry.values(), (entry) => entry.provider);
-	}
-	_Stream.getApiProviders = getApiProviders;
+	_Protocol.complete = complete;
 	function unregisterProtocolProviders(sourceId) {
-		for (const [api, entry] of protocolProviderRegistry.entries()) if (entry.sourceId === sourceId) protocolProviderRegistry.delete(api);
+		for (const [protocol, entry] of protocolRegistry.entries()) if (entry.sourceId === sourceId) protocolRegistry.delete(protocol);
 	}
-	_Stream.unregisterProtocolProviders = unregisterProtocolProviders;
+	_Protocol.unregisterProtocolProviders = unregisterProtocolProviders;
 	function clearProtocolProviders() {
-		protocolProviderRegistry.clear();
+		protocolRegistry.clear();
 	}
-	_Stream.clearProtocolProviders = clearProtocolProviders;
-})(Stream || (Stream = {}));
+	_Protocol.clearProtocolProviders = clearProtocolProviders;
+})(Protocol || (Protocol = {}));
+//#endregion
+//#region src/llm/shared.ts
+const CacheRetention = Type$2.Union([
+	Type$2.Literal("none"),
+	Type$2.Literal("short"),
+	Type$2.Literal("long")
+]);
+const GenerationOptions = Type$2.Object({
+	maxTokens: Type$2.Optional(Type$2.Number()),
+	temperature: Type$2.Optional(Type$2.Number()),
+	cacheRetention: Type$2.Optional(CacheRetention)
+});
+const HelperOptions = Type$2.Object({
+	headers: Type$2.Optional(Type$2.Record(Type$2.String(), Type$2.String())),
+	sessionId: Type$2.Optional(Type$2.String()),
+	apiKey: Type$2.Optional(Type$2.String()),
+	timeoutMs: Type$2.Optional(Type$2.Number()),
+	maxRetries: Type$2.Optional(Type$2.Number()),
+	signal: Type$2.Optional(Type$2.Unsafe({})),
+	onPayload: Type$2.Optional(Type$2.Unsafe({})),
+	metadata: Type$2.Optional(Type$2.Record(Type$2.String(), Type$2.Unknown()))
+});
+const ThinkingBudgets = Type$2.Object({
+	minimal: Type$2.Optional(Type$2.Number()),
+	low: Type$2.Optional(Type$2.Number()),
+	medium: Type$2.Optional(Type$2.Number()),
+	high: Type$2.Optional(Type$2.Number()),
+	xhigh: Type$2.Optional(Type$2.Number())
+});
+const SharedOptions = Type$2.Evaluate(Type$2.Intersect([GenerationOptions, HelperOptions]));
+const DEFAULT_MAX_OUTPUT_TOKENS = 32e3;
+const CONTEXT_WINDOW_OUTPUT_TOLERANCE = 1024;
+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
+	};
+}
+Type$2.Evaluate(Type$2.Intersect([SharedOptions, Type$2.Object({
+	baseURL: Type$2.Optional(Type$2.String()),
+	method: Type$2.Optional(Model.APIMethodEnumSchema),
+	modelId: Type$2.Optional(Type$2.String()),
+	reasoning: Type$2.Optional(Model.ActiveThinkingLevel),
+	thinkingBudgets: Type$2.Optional(ThinkingBudgets),
+	toolChoice: Type$2.Optional(Type$2.Any()),
+	activeTools: Type$2.Optional(Type$2.Array(Type$2.String())),
+	factoryOptions: Type$2.Optional(Type$2.Record(Type$2.String(), Type$2.Unknown())),
+	providerOptions: Type$2.Optional(Type$2.Record(Type$2.String(), Type$2.Record(Type$2.String(), Type$2.Unknown())))
+})]));
 //#endregion
 //#region src/utils/eventstream.ts
 var EventStream = class {
@@ -512,788 +652,67 @@ var AssistantMessageEventStream = class extends EventStream {
 		});
 	}
 };
-//#endregion
-//#region src/utils/validation.ts
-const ajv = new Ajv({
-	allErrors: true,
-	strict: false,
-	coerceTypes: true
-});
-addFormats(ajv);
-/**
-* Validates an arbitrary value against a TypeBox schema and returns the coerced value.
-*/
-function validateSchema(schema, value, label) {
-	const validate = ajv.compile(schema);
-	const input = structuredClone(value);
-	if (validate(input)) return input;
-	const errors = validate.errors?.map((err) => {
-		return ` - ${err.instancePath ? err.instancePath.substring(1) : err.params?.missingProperty || "root"}: ${err.message}`;
-	}).join("\n") || "Unknown Validation Error";
-	throw new Error([
-		`Validation Failed For ${label}`,
-		`${errors}\n`,
-		"Received Value:",
-		`${JSON.stringify(value, null, 2)}\n`
-	].join("\n"));
-}
-/**
-* Validates tool call arguments against the tool's TypeBox schema
-*/
-function validateToolArguments(tool, toolExecution) {
-	return validateSchema(tool.parameters, toolExecution.rawArgs, `Tool "${toolExecution.name}"`);
+/** Factory function for AssistantMessageEventStream (for use in extensions) */
+function createAssistantMessageEventStream() {
+	return new AssistantMessageEventStream();
 }
 //#endregion
-//#region src/agent/loop.ts
-let Loop;
-(function(_Loop) {
-	function createAgentStream() {
-		return new EventStream((event) => event.type === "agent.end", (event) => event.type === "agent.end" ? event.messages : []);
-	}
-	const AgentContextError = _Loop.AgentContextError = NamedError.create("AgentContextError", Type.Object({ message: Type.String() }));
-	function snapshotAssistantMessage(message) {
-		return structuredClone(message);
-	}
-	function snapshotAssistantPartEvent(message, partIndex) {
-		const snapshot = snapshotAssistantMessage(message);
-		const part = snapshot.parts[partIndex];
-		if (!part) throw new Error(`Assistant message part at index ${partIndex} was not found`);
-		return {
-			message: snapshot,
-			part
-		};
+//#region src/llm/runtime.ts
+function mergeHeaders(...headerSources) {
+	const merged = {};
+	for (const headers of headerSources) if (headers) Object.assign(merged, headers);
+	return merged;
+}
+function getEnvApiKey(provider) {
+	if (typeof process === "undefined") return;
+	const candidates = [provider.key, ...provider.env ?? []].filter((name) => Boolean(name));
+	for (const name of candidates) {
+		const value = process.env[name];
+		if (value) return value;
 	}
-	async function emitEvent(emit, event) {
-		await emit(event);
+}
+function formatThrownError(error) {
+	if (error instanceof Error) return error.stack || error.message || error.name;
+	if (typeof error === "string") return error;
+	try {
+		return JSON.stringify(error);
+	} catch {
+		return String(error);
 	}
-	async function streamAssistantResponse(config, context, emit, streamFn, signal) {
-		let messages = context.messages;
-		if (config.transformContext) messages = await config.transformContext(messages, signal);
-		const llmMessages = await config.convertToLlm(messages);
-		const llmContext = {
-			systemPrompt: context.systemPrompt,
-			messages: llmMessages,
-			tools: context.tools
-		};
-		const streamFunction = streamFn || Stream.streamSimple;
-		const resolvedApiKey = (config.getApiKey ? await config.getApiKey(config.model.provider) : void 0) || config.apiKey;
-		const events = await streamFunction(config.model, llmContext, {
-			...config,
-			apiKey: resolvedApiKey,
-			signal
+}
+//#endregion
+//#region src/llm/provider.ts
+function cleanHeaders(headers) {
+	const result = {};
+	for (const [key, value] of Object.entries(headers)) if (value !== null) result[key] = value;
+	return result;
+}
+function resolveBaseURL(model, options) {
+	return (options.baseURL ?? model.api?.url ?? model.baseUrl) || void 0;
+}
+async function resolveAISDKLanguageModel(model, options) {
+	const npm = packageForModel(model);
+	const createProvider = await loadProviderFactory(npm);
+	const apiKey = options.apiKey ?? getEnvApiKey(model.provider);
+	const headers = cleanHeaders(mergeHeaders(model.headers, options.headers));
+	const baseURL = resolveBaseURL(model, options);
+	const factoryOptions = {
+		...model.options,
+		...options.factoryOptions
+	};
+	if (apiKey) factoryOptions.apiKey = apiKey;
+	if (Object.keys(headers).length > 0) factoryOptions.headers = headers;
+	if (baseURL) factoryOptions.baseURL = baseURL;
+	if (npm === "@ai-sdk/openai-compatible") {
+		if (!baseURL) throw new Protocol.ProtocolAuthError({
+			protocol: model.protocol,
+			message: "AI SDK openai-compatible transport requires model.baseUrl, model.api.url, or options.baseURL"
 		});
-		let partialMessage = null;
-		let started = false;
-		const ensureMessageStarted = async (message) => {
-			if (started) return;
-			started = true;
-			await emitEvent(emit, {
-				type: "message.start",
-				message: snapshotAssistantMessage(message)
-			});
-		};
-		const emitMessageUpdate = async (message) => {
-			await emitEvent(emit, {
-				type: "message.update",
-				message: snapshotAssistantMessage(message)
-			});
-		};
-		const emitPartStart = async (message, partIndex) => {
-			await emitEvent(emit, {
-				type: "message.part.start",
-				partIndex,
-				...snapshotAssistantPartEvent(message, partIndex)
-			});
-		};
-		const emitPartUpdate = async (message, partIndex) => {
-			await emitEvent(emit, {
-				type: "message.part.update",
-				partIndex,
-				...snapshotAssistantPartEvent(message, partIndex),
-				source: "llm"
-			});
-		};
-		const emitPartEnd = async (message, partIndex) => {
-			await emitEvent(emit, {
-				type: "message.part.end",
-				partIndex,
-				...snapshotAssistantPartEvent(message, partIndex)
-			});
-		};
-		for await (const event of events) switch (event.type) {
-			case "start":
-				partialMessage = event.partial;
-				await ensureMessageStarted(partialMessage);
-				break;
-			case "text.start":
-			case "thinking.start":
-			case "toolcall.start":
-				partialMessage = event.partial;
-				await ensureMessageStarted(partialMessage);
-				await emitPartStart(partialMessage, event.partIndex);
-				break;
-			case "text.delta":
-			case "thinking.delta":
-			case "toolcall.delta":
-				partialMessage = event.partial;
-				await ensureMessageStarted(partialMessage);
-				await emitPartUpdate(partialMessage, event.partIndex);
-				break;
-			case "text.end":
-			case "thinking.end":
-			case "toolcall.end":
-				partialMessage = event.partial;
-				await ensureMessageStarted(partialMessage);
-				await emitPartEnd(partialMessage, event.partIndex);
-				await emitMessageUpdate(partialMessage);
-				break;
-			case "done":
-				await ensureMessageStarted(event.message);
-				await emitEvent(emit, {
-					type: "message.end",
-					message: snapshotAssistantMessage(event.message)
-				});
-				return event.message;
-			case "error":
-				await ensureMessageStarted(event.error);
-				await emitEvent(emit, {
-					type: "message.end",
-					message: snapshotAssistantMessage(event.error)
-				});
-				return event.error;
-		}
-		const finalMessage = await events.result();
-		await ensureMessageStarted(finalMessage);
-		await emitEvent(emit, {
-			type: "message.end",
-			message: snapshotAssistantMessage(finalMessage)
-		});
-		return finalMessage;
-	}
-	async function executeToolCalls(config, currentContext, message, toolCalls, emit, signal) {
-		if (config.toolExecution === "sequential") return executeToolCallsSequential(config, currentContext, message, toolCalls, emit, signal);
-		return executeToolCallsParallel(config, currentContext, message, toolCalls, emit, signal);
-	}
-	async function executeToolCallsSequential(config, currentContext, message, toolCalls, emit, signal) {
-		for (const toolCall of toolCalls) {
-			const toolCallInFlight = {
-				callID: toolCall.callID,
-				name: toolCall.name,
-				rawArgs: toolCall.arguments
-			};
-			await emitEvent(emit, {
-				type: "tool.execution.start",
-				...toolCallInFlight
-			});
-			const prepared = await prepareToolCall(config, currentContext, message, toolCallInFlight, signal);
-			if (prepared.error) {
-				const error = {
-					status: "error",
-					result: {
-						content: [{
-							type: "text",
-							text: prepared.error.message
-						}],
-						details: prepared.error.details,
-						isError: true
-					}
-				};
-				await emitToolCallTerminalResult(toolCall, prepared.runnable, message, emit, error);
-			} else {
-				const runnable = {
-					toolCall,
-					runnable: prepared.runnable,
-					tool: prepared.tool
-				};
-				const executed = await executeRunnableToolCall(runnable, message, emit, signal);
-				if (executed.error) {
-					const error = {
-						status: "error",
-						result: {
-							content: [{
-								type: "text",
-								text: executed.error.message
-							}],
-							details: executed.error.details,
-							isError: true
-						}
-					};
-					await emitToolCallTerminalResult(runnable.toolCall, runnable.runnable, message, emit, error);
-				} else await finalizeExecutedToolCall(config, currentContext, runnable.toolCall, runnable.runnable, message, emit, executed.result);
-			}
-		}
-	}
-	async function executeToolCallsParallel(config, currentContext, message, toolCalls, emit, signal) {
-		const runnables = [];
-		for (const toolCall of toolCalls) {
-			const toolCallInFlight = {
-				callID: toolCall.callID,
-				name: toolCall.name,
-				rawArgs: toolCall.arguments
-			};
-			await emitEvent(emit, {
-				type: "tool.execution.start",
-				...toolCallInFlight
-			});
-			const prepared = await prepareToolCall(config, currentContext, message, toolCallInFlight, signal);
-			if (prepared.error) {
-				const error = {
-					status: "error",
-					result: {
-						content: [{
-							type: "text",
-							text: prepared.error.message
-						}],
-						details: prepared.error.details,
-						isError: true
-					}
-				};
-				await emitToolCallTerminalResult(toolCall, prepared.runnable, message, emit, error);
-			} else runnables.push({
-				toolCall,
-				runnable: prepared.runnable,
-				tool: prepared.tool
-			});
-		}
-		const runningExecutions = runnables.map((runnable) => ({
-			runnable,
-			execution: executeRunnableToolCall(runnable, message, emit, signal)
-		}));
-		for (const running of runningExecutions) {
-			const executed = await running.execution;
-			const { runnable } = running;
-			if (executed.error) {
-				const error = {
-					status: "error",
-					result: {
-						content: [{
-							type: "text",
-							text: executed.error.message
-						}],
-						details: executed.error.details,
-						isError: true
-					}
-				};
-				await emitToolCallTerminalResult(runnable.toolCall, runnable.runnable, message, emit, error);
-			} else await finalizeExecutedToolCall(config, currentContext, runnable.toolCall, runnable.runnable, message, emit, executed.result);
-		}
-	}
-	async function prepareToolCall(config, currentContext, assistantMessage, toolCallInFlight, signal) {
-		const tool = currentContext.tools?.find((t) => t.name === toolCallInFlight.name);
-		if (!tool) return {
-			error: {
-				kind: "error",
-				message: `Tool ${toolCallInFlight.name} Not Found`
-			},
-			runnable: toolCallInFlight
-		};
-		try {
-			toolCallInFlight.args = validateToolArguments(tool, toolCallInFlight);
-			if (config.beforeToolExecution) {
-				const beforeResult = await config.beforeToolExecution({
-					context: currentContext,
-					assistantMessage,
-					toolCall: toolCallInFlight
-				}, signal);
-				if (beforeResult?.block) return {
-					error: {
-						kind: "blocked",
-						message: beforeResult?.reason || "Tool Execution was Blocked",
-						details: beforeResult?.details
-					},
-					runnable: toolCallInFlight
-				};
-			}
-			return {
-				runnable: toolCallInFlight,
-				tool
-			};
-		} catch (err) {
-			return {
-				error: {
-					kind: "error",
-					message: err instanceof Error ? err.message : String(err)
-				},
-				runnable: toolCallInFlight
-			};
-		}
-	}
-	async function executeRunnableToolCall(toolCallRunnable, message, emit, signal) {
-		const { toolCall, runnable, tool } = toolCallRunnable;
-		const { partIndex, ...pendingPart } = toolCall;
-		try {
-			return { result: await tool.execute(runnable.callID, runnable.args, signal, async (result) => {
-				const runningResult = {
-					status: "running",
-					partial: result.partial
-				};
-				await emitEvent(emit, {
-					type: "tool.execution.update",
-					...runnable,
-					...runningResult
-				});
-				const runningPart = {
-					...pendingPart,
-					...runningResult
-				};
-				message.parts[partIndex] = runningPart;
-				await emitEvent(emit, {
-					type: "message.part.update",
-					message,
-					partIndex,
-					part: runningPart,
-					source: "tool"
-				});
-			}) };
-		} catch (err) {
-			return { error: { message: err instanceof Error ? err.message : String(err) } };
-		}
-	}
-	async function emitToolCallTerminalResult(toolCall, runnable, message, emit, result) {
-		const { partIndex, ...pendingPart } = toolCall;
-		const { time } = pendingPart;
-		await emitEvent(emit, {
-			type: "tool.execution.end",
-			...runnable,
-			...result
-		});
-		const part = {
-			...pendingPart,
-			...result,
-			time: {
-				start: time.start,
-				end: Date.now()
-			}
-		};
-		message.parts[partIndex] = part;
-		await emitEvent(emit, {
-			type: "message.part.start",
-			message,
-			partIndex,
-			part
-		});
-		await emitEvent(emit, {
-			type: "message.part.end",
-			message,
-			partIndex,
-			part
-		});
-		await emitEvent(emit, {
-			type: "message.update",
-			message
-		});
-	}
-	async function finalizeExecutedToolCall(config, currentContext, toolCall, runnable, message, emit, result, signal) {
-		if (config.afterToolExecution) {
-			const afterResult = await config.afterToolExecution({
-				context: currentContext,
-				assistantMessage: message,
-				toolCall: runnable,
-				result
-			}, signal);
-			if (afterResult) {
-				await emitToolCallTerminalResult(toolCall, runnable, message, emit, afterResult);
-				return;
-			}
-		}
-		await emitToolCallTerminalResult(toolCall, runnable, message, emit, result);
-	}
-	/**
-	* Main core loop shared by run and runContinue.
-	*/
-	async function runLoop(config, currentContext, newMessages, emit, streamFn, signal) {
-		let firstTurn = true;
-		let pendingMessages = await config.getSteeringMessages?.() || [];
-		while (true) {
-			let hasMoreToolCalls = true;
-			while (hasMoreToolCalls || pendingMessages.length > 0) {
-				if (!firstTurn) await emitEvent(emit, { type: "turn.start" });
-				else firstTurn = false;
-				if (pendingMessages.length > 0) {
-					for (const message of pendingMessages) {
-						await emitEvent(emit, {
-							type: "message.start",
-							message
-						});
-						for (const [partIndex, part] of message.parts.entries()) {
-							await emitEvent(emit, {
-								type: "message.part.start",
-								message,
-								partIndex,
-								part
-							});
-							await emitEvent(emit, {
-								type: "message.part.end",
-								message,
-								partIndex,
-								part
-							});
-							await emitEvent(emit, {
-								type: "message.update",
-								message
-							});
-						}
-						await emitEvent(emit, {
-							type: "message.end",
-							message
-						});
-						currentContext.messages.push(message);
-						newMessages.push(message);
-					}
-					pendingMessages = [];
-				}
-				const message = await streamAssistantResponse(config, currentContext, emit, streamFn, signal);
-				if (message.stopReason === "error" || message.stopReason === "aborted") {
-					currentContext.messages.push(message);
-					newMessages.push(message);
-					await emitEvent(emit, {
-						type: "turn.end",
-						message
-					});
-					await emitEvent(emit, {
-						type: "agent.end",
-						messages: newMessages
-					});
-					return;
-				}
-				const toolCalls = message.parts.map((part, index) => ({
-					...part,
-					partIndex: index
-				})).filter((part) => part.type === "toolCall" && part.status === "pending");
-				hasMoreToolCalls = toolCalls.length > 0;
-				if (hasMoreToolCalls) await executeToolCalls(config, currentContext, message, toolCalls, emit, signal);
-				currentContext.messages.push(message);
-				newMessages.push(message);
-				await emitEvent(emit, {
-					type: "turn.end",
-					message
-				});
-				pendingMessages = await config.getSteeringMessages?.() || [];
-			}
-			const followUpMessages = await config.getFollowUpMessages?.() || [];
-			if (followUpMessages.length > 0) {
-				pendingMessages = followUpMessages;
-				continue;
-			}
-			break;
-		}
-		await emitEvent(emit, {
-			type: "agent.end",
-			messages: newMessages
-		});
-	}
-	async function runAgentLoop(config, context, prompts, emit, streamFn, signal) {
-		/**
-		* maintain 2 arrays to represent state, `context` the actual full state sent to the LLM,
-		* `newMessages` for intermediate current loop state.
-		* think of newMessages as subset of context.messages for the running current loop.
-		* they do move at the same speed staring with initial user prompts.
-		* */
-		const newMessages = [...prompts];
-		const currentContext = {
-			...context,
-			messages: [...context.messages, ...prompts]
-		};
-		await emitEvent(emit, { type: "agent.start" });
-		await emitEvent(emit, { type: "turn.start" });
-		for (const prompt of prompts) {
-			await emitEvent(emit, {
-				type: "message.start",
-				message: prompt
-			});
-			for (const [partIndex, part] of prompt.parts.entries()) {
-				await emitEvent(emit, {
-					type: "message.part.start",
-					message: prompt,
-					partIndex,
-					part
-				});
-				await emitEvent(emit, {
-					type: "message.part.end",
-					message: prompt,
-					partIndex,
-					part
-				});
-			}
-			await emitEvent(emit, {
-				type: "message.end",
-				message: prompt
-			});
-		}
-		await runLoop(config, currentContext, newMessages, emit, streamFn, signal);
-		return newMessages;
-	}
-	_Loop.runAgentLoop = runAgentLoop;
-	async function runAgentLoopContinue(config, context, emit, streamFn, signal) {
-		if (context.messages.length === 0) throw new AgentContextError({ message: "connot continue: no messages in context" });
-		if (context.messages[context.messages.length - 1]?.role === "assistant") throw new AgentContextError({ message: "cannot continue from message role: assistant" });
-		const newMessages = [];
-		const currentContext = { ...context };
-		await emitEvent(emit, { type: "agent.start" });
-		await emitEvent(emit, { type: "turn.start" });
-		await runLoop(config, currentContext, newMessages, emit, streamFn, signal);
-		return newMessages;
-	}
-	_Loop.runAgentLoopContinue = runAgentLoopContinue;
-	function run(config, context, prompts, streamFn, signal) {
-		const stream = createAgentStream();
-		runAgentLoop(config, context, prompts, async (event) => {
-			stream.push(event);
-		}, streamFn, signal).then((messages) => {
-			stream.end(messages);
-		});
-		return stream;
-	}
-	_Loop.run = run;
-	function runContinue(config, context, streamFn, signal) {
-		const stream = createAgentStream();
-		runAgentLoopContinue(config, context, async (event) => {
-			stream.push(event);
-		}, streamFn, signal).then((messages) => {
-			stream.end(messages);
-		});
-		return stream;
-	}
-	_Loop.runContinue = runContinue;
-})(Loop || (Loop = {}));
-//#endregion
-//#region src/agent.ts
-const agent = {
-	loop: Loop.run,
-	loopContinue: Loop.runContinue
-};
-//#endregion
-//#region src/message/message.ts
-let Message;
-(function(_Message) {
-	const TextContentSchema = _Message.TextContentSchema = Type.Object({
-		type: Type.Literal("text"),
-		text: Type.String(),
-		textSignature: Type.Optional(Type.String())
-	});
-	const ImageContentSchema = _Message.ImageContentSchema = Type.Object({
-		type: Type.Literal("image"),
-		data: Type.String(),
-		mimeType: Type.String()
-	});
-	const ThinkingContentSchema = _Message.ThinkingContentSchema = Type.Object({
-		type: Type.Literal("thinking"),
-		thinking: Type.String(),
-		thinkingSignature: Type.Optional(Type.String()),
-		redacted: Type.Optional(Type.Boolean())
-	});
-	const ToolCallBaseSchema = _Message.ToolCallBaseSchema = Type.Object({
-		type: Type.Literal("toolCall"),
-		callID: Type.String(),
-		name: Type.String(),
-		arguments: Type.Record(Type.String(), Type.Any()),
-		thoughtSignature: Type.Optional(Type.String()),
-		time: Type.Object({
-			start: Type.Number(),
-			end: Type.Number()
-		})
-	});
-	const ToolSuccessResult = _Message.ToolSuccessResult = Type.Object({
-		content: Type.Array(Type.Union([TextContentSchema, ImageContentSchema])),
-		details: Type.Optional(Type.Any()),
-		isError: Type.Literal(false)
-	});
-	const ToolErrorResult = _Message.ToolErrorResult = Type.Object({
-		content: Type.Array(Type.Union([TextContentSchema, ImageContentSchema])),
-		details: Type.Optional(Type.Any()),
-		isError: Type.Literal(true)
-	});
-	const ToolRunningPartial = _Message.ToolRunningPartial = Type.Object({
-		content: Type.Optional(Type.Array(Type.Union([TextContentSchema, ImageContentSchema]))),
-		details: Type.Optional(Type.Any())
-	});
-	const ToolStatusEnum = _Message.ToolStatusEnum = {
-		pending: "pending",
-		running: "running",
-		completed: "completed",
-		error: "error",
-		skipped: "skipped",
-		aborted: "aborted"
-	};
-	const ToolRunningSchema = _Message.ToolRunningSchema = Type.Object({
-		status: Type.Literal(ToolStatusEnum.running),
-		partial: Type.Optional(ToolRunningPartial)
-	});
-	const ToolCompletedSchema = _Message.ToolCompletedSchema = Type.Object({
-		status: Type.Literal(ToolStatusEnum.completed),
-		result: ToolSuccessResult
-	});
-	const ToolErrorSchema = _Message.ToolErrorSchema = Type.Object({
-		status: Type.Literal(ToolStatusEnum.error),
-		result: ToolErrorResult
-	});
-	const ToolSkippedSchema = _Message.ToolSkippedSchema = Type.Object({
-		status: Type.Literal(ToolStatusEnum.skipped),
-		result: ToolErrorResult
-	});
-	const ToolAbortedSchema = _Message.ToolAbortedSchema = Type.Object({
-		status: Type.Literal(ToolStatusEnum.aborted),
-		result: ToolErrorResult
-	});
-	const ToolCallPendingPart = Type.Intersect([ToolCallBaseSchema, Type.Object({ status: Type.Literal(ToolStatusEnum.pending) })]);
-	const ToolCallRunningPart = Type.Composite([ToolCallBaseSchema, ToolRunningSchema]);
-	const ToolCallCompletedPart = Type.Composite([ToolCallBaseSchema, ToolCompletedSchema]);
-	const ToolCallErrorPart = Type.Composite([ToolCallBaseSchema, ToolErrorSchema]);
-	const ToolCallSkippedPart = Type.Composite([ToolCallBaseSchema, ToolSkippedSchema]);
-	const ToolCallAbortedPart = Type.Composite([ToolCallBaseSchema, ToolAbortedSchema]);
-	const ToolCallSchema = _Message.ToolCallSchema = Type.Union([
-		ToolCallPendingPart,
-		ToolCallRunningPart,
-		ToolCallCompletedPart,
-		ToolCallErrorPart,
-		ToolCallSkippedPart,
-		ToolCallAbortedPart
-	]);
-	const UsageSchema = _Message.UsageSchema = Type.Object({
-		input: Type.Number(),
-		output: Type.Number(),
-		cacheRead: Type.Number(),
-		cacheWrite: Type.Number(),
-		totalTokens: Type.Number(),
-		cost: Type.Object({
-			input: Type.Number(),
-			output: Type.Number(),
-			cacheRead: Type.Number(),
-			cacheWrite: Type.Number(),
-			total: Type.Number()
-		})
-	});
-	const StopReasonSchema = _Message.StopReasonSchema = Type.Union([
-		Type.Literal("stop"),
-		Type.Literal("length"),
-		Type.Literal("toolUse"),
-		Type.Literal("error"),
-		Type.Literal("aborted")
-	]);
-	const UserMessageSchema = _Message.UserMessageSchema = Type.Object({
-		messageId: Type.String(),
-		role: Type.Literal("user"),
-		time: Type.Object({ created: Type.Number() }),
-		parts: Type.Array(Type.Union([TextContentSchema, ImageContentSchema]))
-	});
-	const AssistantMessageSchema = _Message.AssistantMessageSchema = Type.Object({
-		role: Type.Literal("assistant"),
-		protocol: Model.KnownProtocolSchema,
-		provider: Provider.Info,
-		model: Type.String(),
-		usage: UsageSchema,
-		stopReason: StopReasonSchema,
-		errorMessage: Type.Optional(Type.String()),
-		time: Type.Object({
-			created: Type.Number(),
-			completed: Type.Number()
-		}),
-		parts: Type.Array(Type.Union([
-			TextContentSchema,
-			ImageContentSchema,
-			ThinkingContentSchema,
-			ToolCallSchema
-		])),
-		responseId: Type.Optional(Type.String()),
-		messageId: Type.String()
-	});
-	const MessageSchema = _Message.MessageSchema = Type.Union([UserMessageSchema, AssistantMessageSchema]);
-	function createMessageId() {
-		return uuidv7();
-	}
-	_Message.createMessageId = createMessageId;
-	function createUserMessage(message) {
-		const { messageId = createMessageId(), ...rest } = message;
-		return {
-			messageId,
-			...rest
-		};
-	}
-	_Message.createUserMessage = createUserMessage;
-	function createAssistantMessage(message) {
-		const { messageId = createMessageId(), ...rest } = message;
-		return {
-			messageId,
-			...rest
-		};
-	}
-	_Message.createAssistantMessage = createAssistantMessage;
-	const ToolSchema = _Message.ToolSchema = Type.Object({
-		name: Type.String(),
-		description: Type.String(),
-		parameters: Type.Unsafe()
-	});
-	function defineTool(tool) {
-		return tool;
-	}
-	_Message.defineTool = defineTool;
-	_Message.ContextSchema = Type.Object({
-		systemPrompt: Type.Optional(Type.String()),
-		messages: Type.Array(MessageSchema),
-		tools: Type.Optional(Type.Array(ToolSchema))
-	});
-	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;
-			});
-			transformed.push({
-				...assistantMsg,
-				parts
-			});
-		}
-		return transformed;
+		factoryOptions.name ??= model.provider.id;
+		factoryOptions.includeUsage ??= true;
 	}
-	_Message.transformMessages = transformMessages;
-})(Message || (Message = {}));
+	return resolveLanguageModel(createProvider(factoryOptions), model, options.method);
+}
 //#endregion
 //#region src/utils/jsonparse.ts
 /**
@@ -1311,6 +730,14 @@ function parseStreamingJson(partialJson) {
 	try {
 		return JSON.parse(partialJson);
 	} catch {
+		const repaired = repairInvalidJsonStringContent(partialJson);
+		if (repaired !== partialJson) try {
+			return JSON.parse(repaired);
+		} catch {
+			try {
+				return parse(repaired) ?? {};
+			} catch {}
+		}
 		try {
 			return parse(partialJson) ?? {};
 		} catch {
@@ -1318,6 +745,55 @@ function parseStreamingJson(partialJson) {
 		}
 	}
 }
+function repairInvalidJsonStringContent(input) {
+	let output = "";
+	let inString = false;
+	let escaping = false;
+	for (const char of input) {
+		if (!inString) {
+			output += char;
+			if (char === "\"") inString = true;
+			continue;
+		}
+		if (escaping) {
+			if (`"\\/bfnrtu`.includes(char)) output += `\\${char}`;
+			else output += `\\\\${char}`;
+			escaping = false;
+			continue;
+		}
+		if (char === "\\") {
+			escaping = true;
+			continue;
+		}
+		if (char === "\"") {
+			inString = false;
+			output += char;
+			continue;
+		}
+		switch (char) {
+			case "\b":
+				output += "\\b";
+				break;
+			case "\f":
+				output += "\\f";
+				break;
+			case "\n":
+				output += "\\n";
+				break;
+			case "\r":
+				output += "\\r";
+				break;
+			case "	":
+				output += "\\t";
+				break;
+			default:
+				output += char;
+				break;
+		}
+	}
+	if (escaping) output += "\\\\";
+	return output;
+}
 //#endregion
 //#region src/utils/sanitize.ts
 /**
@@ -1344,812 +820,542 @@ function sanitizeSurrogates(text) {
 	return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "");
 }
 //#endregion
-//#region src/provider/providers/utils.ts
-function getEnvApiKey(_provider) {}
-//#endregion
-//#region src/provider/providers/anthropic/index.ts
-function resolveCacheRetention(cacheRetention) {
-	if (cacheRetention) return cacheRetention;
-	if (typeof process !== "undefined" && process.env.CODEWORK_CACHE_RETENTION === "long") return "long";
-	return "short";
-}
-function getCacheControl(baseUrl, cacheRetention) {
-	const retention = resolveCacheRetention(cacheRetention);
-	if (retention === "none") return { retention };
-	const ttl = retention === "long" && baseUrl.includes("api.anthropic.com") ? "1h" : void 0;
-	return {
-		retention,
-		cacheControl: {
-			type: "ephemeral",
-			...ttl && { ttl }
+//#region src/llm/transform.ts
+function createAssistantMessage(model) {
+	return Message.createAssistantMessage({
+		role: "assistant",
+		parts: [],
+		protocol: model.protocol,
+		provider: model.provider,
+		model: model.id,
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				total: 0
+			}
+		},
+		stopReason: "stop",
+		time: {
+			created: Date.now(),
+			completed: Date.now()
 		}
-	};
+	});
 }
-const claudeCodeVersion = "2.1.2";
-const ccToolLookup = new Map([
-	"Read",
-	"Write",
-	"Edit",
-	"Bash",
-	"Grep",
-	"Glob",
-	"AskUserQuestion",
-	"EnterPlanMode",
-	"ExitPlanMode",
-	"KillShell",
-	"NotebookEdit",
-	"Skill",
-	"Task",
-	"TaskOutput",
-	"TodoWrite",
-	"WebFetch",
-	"WebSearch"
-].map((t) => [t.toLowerCase(), t]));
-const toClaudeCodeName = (name) => ccToolLookup.get(name.toLowerCase()) ?? name;
-const fromClaudeCodeName = (name, tools) => {
-	if (tools && tools.length > 0) {
-		const lowerName = name.toLowerCase();
-		const matchedTool = tools.find((tool) => tool.name.toLowerCase() === lowerName);
-		if (matchedTool) return matchedTool.name;
-	}
-	return name;
-};
-function convertContentBlocks(content) {
-	if (!content.some((c) => c.type === "image")) return sanitizeSurrogates(content.map((c) => c.text).join("\n"));
-	const blocks = content.map((block) => {
-		if (block.type === "text") return {
-			type: "text",
-			text: sanitizeSurrogates(block.text)
-		};
-		return {
+function userContent(parts, supportsImages) {
+	const content = [];
+	for (const part of parts) {
+		if (part.type === "text") {
+			const text = sanitizeSurrogates(part.text);
+			if (text.trim().length > 0) content.push({
+				type: "text",
+				text
+			});
+			continue;
+		}
+		if (supportsImages) content.push({
 			type: "image",
-			source: {
-				type: "base64",
-				media_type: block.mimeType,
-				data: block.data
-			}
-		};
-	});
-	if (!blocks.some((b) => b.type === "text")) blocks.unshift({
-		type: "text",
-		text: "(see attached image)"
-	});
-	return blocks;
-}
-function mergeHeaders(...headerSources) {
-	const merged = {};
-	for (const headers of headerSources) if (headers) Object.assign(merged, headers);
-	return merged;
-}
-function isOAuthToken(apiKey) {
-	return apiKey.includes("sk-ant-oat");
-}
-function createClient$1(model, apiKey, interleavedThinking, optionsHeaders) {
-	const betaFeatures = ["fine-grained-tool-streaming-2025-05-14"];
-	if (interleavedThinking) betaFeatures.push("interleaved-thinking-2025-05-14");
-	if (isOAuthToken(apiKey)) {
-		const defaultHeaders = mergeHeaders({
-			accept: "application/json",
-			"anthropic-dangerous-direct-browser-access": "true",
-			"anthropic-beta": `claude-code-20250219,oauth-2025-04-20,${betaFeatures.join(",")}`,
-			"user-agent": `claude-cli/${claudeCodeVersion} (external, cli)`,
-			"x-app": "cli"
-		}, model.headers, optionsHeaders);
-		return {
-			client: new Anthropic({
-				apiKey: null,
-				authToken: apiKey,
-				baseURL: model.baseUrl,
-				defaultHeaders,
-				dangerouslyAllowBrowser: true
-			}),
-			isOAuthToken: true
-		};
+			image: part.data,
+			mediaType: part.mimeType
+		});
 	}
-	const defaultHeaders = mergeHeaders({
-		accept: "application/json",
-		"anthropic-dangerous-direct-browser-access": "true",
-		"anthropic-beta": betaFeatures.join(",")
-	}, model.headers, optionsHeaders);
-	return {
-		client: new Anthropic({
-			apiKey,
-			baseURL: model.baseUrl,
-			dangerouslyAllowBrowser: true,
-			defaultHeaders
-		}),
-		isOAuthToken: false
-	};
-}
-function normalizeToolCallId(id) {
-	return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+	if (content.length === 0) return [];
+	return [{
+		role: "user",
+		content
+	}];
 }
-function assertReplayableAssistant(message) {
-	let sawToolCall = false;
-	let sawNonTerminalToolCall = false;
-	let sawTerminalToolCall = false;
-	for (const part of message.parts) {
-		if (part.type === "image") throw new Error("Anthropic replay does not support assistant image parts");
-		if (part.type === "toolCall") {
-			sawToolCall = true;
-			if (part.status === "pending" || part.status === "running") sawNonTerminalToolCall = true;
-			else sawTerminalToolCall = true;
-			continue;
-		}
-		if (sawToolCall) throw new Error("Assistant parts after a toolCall are not replayable for Anthropic");
+function sanitizeValue(value) {
+	if (typeof value === "string") return sanitizeSurrogates(value);
+	if (Array.isArray(value)) return value.map((item) => sanitizeValue(item));
+	if (typeof value === "object" && value !== null) {
+		const result = {};
+		for (const [key, item] of Object.entries(value)) result[key] = sanitizeValue(item);
+		return result;
 	}
-	if (sawToolCall && message.stopReason !== "toolUse") throw new Error("Assistant message with tool calls must have stopReason 'toolUse'");
-	if (!sawToolCall && message.stopReason === "toolUse") throw new Error("Assistant message with stopReason 'toolUse' must contain at least one toolCall");
-	if (sawTerminalToolCall && sawNonTerminalToolCall) throw new Error("Assistant message cannot mix terminal and non-terminal toolCall states");
+	return value;
+}
+function sanitizeRecord(value) {
+	return sanitizeValue(value);
 }
-function buildSyntheticToolResult$1(block) {
+function toolResultOutput(toolCall) {
+	const text = toolCall.result.content.filter((content) => content.type === "text").map((content) => sanitizeSurrogates(content.text)).join("\n");
+	const images = toolCall.result.content.filter((content) => content.type === "image");
+	if (toolCall.result.isError) return {
+		type: "error-text",
+		value: text || "Tool returned an error"
+	};
+	if (images.length === 0) return {
+		type: "text",
+		value: text
+	};
 	return {
-		type: "tool_result",
-		tool_use_id: block.callID,
-		content: convertContentBlocks([{
+		type: "content",
+		value: [...text.length > 0 ? [{
 			type: "text",
-			text: [
-				"<result>",
-				"No Result Provided",
-				"</result>"
-			].join("\n")
-		}]),
-		is_error: true
+			text
+		}] : [], ...images.map((image) => ({
+			type: "image-data",
+			data: image.data,
+			mediaType: image.mimeType
+		}))]
 	};
 }
-function convertMessages$1(messages, model, isOAuthToken, cacheControl) {
-	const params = [];
-	const transformedMessages = Message.transformMessages(messages, model, normalizeToolCallId);
-	for (const msg of transformedMessages) {
-		if (msg.role === "user") {
-			const blocks = msg.parts.map((item) => {
-				if (item.type === "text") return {
-					type: "text",
-					text: sanitizeSurrogates(item.text)
-				};
-				return {
-					type: "image",
-					source: {
-						type: "base64",
-						media_type: item.mimeType,
-						data: item.data
-					}
-				};
-			});
-			let filteredBlocks = !model.input.includes("image") ? blocks.filter((b) => b.type !== "image") : blocks;
-			filteredBlocks = filteredBlocks.filter((b) => b.type === "text" ? b.text.trim().length > 0 : true);
-			if (filteredBlocks.length === 0) continue;
-			params.push({
-				role: "user",
-				content: filteredBlocks
+function assistantMessages(message) {
+	if (message.stopReason === "error" || message.stopReason === "aborted") return [];
+	const assistantContent = [];
+	const toolResults = [];
+	for (const part of message.parts) {
+		if (part.type === "text") {
+			const text = sanitizeSurrogates(part.text);
+			if (text.trim().length === 0) continue;
+			assistantContent.push({
+				type: "text",
+				text
 			});
 			continue;
 		}
-		if (msg.stopReason === "error" || msg.stopReason === "aborted") continue;
-		assertReplayableAssistant(msg);
-		const assistantBlocks = [];
-		const toolResults = [];
-		for (const block of msg.parts) if (block.type === "text") {
-			if (block.text.trim().length === 0) continue;
-			assistantBlocks.push({
-				type: "text",
-				text: sanitizeSurrogates(block.text)
-			});
-		} else if (block.type === "thinking") {
-			if (block.thinking.trim().length === 0) continue;
-			if (!block.thinkingSignature || block.thinkingSignature.trim().length === 0) assistantBlocks.push({
-				type: "text",
-				text: sanitizeSurrogates(block.thinking)
-			});
-			else assistantBlocks.push({
-				type: "thinking",
-				thinking: sanitizeSurrogates(block.thinking),
-				signature: block.thinkingSignature
-			});
-		} else if (block.type === "toolCall") {
-			assistantBlocks.push({
-				type: "tool_use",
-				id: block.callID,
-				name: isOAuthToken ? toClaudeCodeName(block.name) : block.name,
-				input: block.arguments ?? {}
-			});
-			if (block.status === "pending" || block.status === "running") toolResults.push(buildSyntheticToolResult$1(block));
-			else toolResults.push({
-				type: "tool_result",
-				tool_use_id: block.callID,
-				content: convertContentBlocks(block.result.content),
-				is_error: block.result.isError
-			});
+		if (part.type === "thinking") {
+			const thinking = sanitizeSurrogates(part.thinking);
+			if (thinking.trim().length === 0) continue;
+			const reasoning = {
+				type: "reasoning",
+				text: thinking
+			};
+			if (part.thinkingSignature) reasoning.providerOptions = { anthropic: { signature: part.thinkingSignature } };
+			assistantContent.push(reasoning);
+			continue;
 		}
-		if (assistantBlocks.length > 0) params.push({
-			role: "assistant",
-			content: assistantBlocks
+		if (part.type !== "toolCall") continue;
+		assistantContent.push({
+			type: "tool-call",
+			toolCallId: part.callID,
+			toolName: part.name,
+			input: sanitizeRecord(part.arguments ?? {})
 		});
-		if (toolResults.length > 0) params.push({
-			role: "user",
-			content: toolResults
+		const terminal = part.status === "pending" || part.status === "running" ? void 0 : part;
+		toolResults.push({
+			type: "tool-result",
+			toolCallId: part.callID,
+			toolName: part.name,
+			output: terminal ? toolResultOutput(terminal) : {
+				type: "error-text",
+				value: "No result provided"
+			}
 		});
 	}
-	if (cacheControl && params.length > 0) {
-		const lastMessage = params[params.length - 1];
-		if (lastMessage.role === "user") {
-			if (Array.isArray(lastMessage.content)) {
-				const lastBlock = lastMessage.content[lastMessage.content.length - 1];
-				if (lastBlock && (lastBlock.type === "text" || lastBlock.type === "image" || lastBlock.type === "tool_result")) lastBlock.cache_control = cacheControl;
-			} else if (typeof lastMessage.content === "string") lastMessage.content = [{
-				type: "text",
-				text: lastMessage.content,
-				cache_control: cacheControl
-			}];
+	const result = [];
+	if (assistantContent.length > 0) result.push({
+		role: "assistant",
+		content: assistantContent
+	});
+	if (toolResults.length > 0) result.push({
+		role: "tool",
+		content: toolResults
+	});
+	return result;
+}
+function convertMessages(context, model) {
+	const messages = [];
+	const transformedMessages = Message.transformMessages(context.messages, model);
+	for (const msg of transformedMessages) {
+		if (msg.role === "user") {
+			messages.push(...userContent(msg.parts, model.input.includes("image")));
+			continue;
 		}
+		messages.push(...assistantMessages(msg));
 	}
-	return params;
+	return messages;
 }
-function convertTools$1(tools, isOAuthToken) {
-	if (!tools) return [];
-	return tools.map((tool) => {
-		const jsonSchema = tool.parameters;
-		return {
-			name: isOAuthToken ? toClaudeCodeName(tool.name) : tool.name,
-			description: tool.description,
-			input_schema: {
-				type: "object",
-				properties: jsonSchema.properties || {},
-				required: jsonSchema.required || []
-			}
-		};
-	});
+function convertTools(tools) {
+	if (!tools || tools.length === 0) return;
+	const result = {};
+	for (const tool of tools) result[tool.name] = {
+		description: tool.description,
+		inputSchema: jsonSchema(tool.parameters)
+	};
+	return result;
 }
-function mapStopReason$1(reason) {
+function mapFinishReason(reason) {
 	switch (reason) {
-		case "end_turn": return "stop";
-		case "max_tokens": return "length";
-		case "tool_use": return "toolUse";
-		case "pause_turn":
-		case "stop_sequence": return "stop";
-		case "refusal":
-		case "sensitive": return "error";
-		default: throw new Error("Unhandled Anthropic stop reason");
+		case "length": return "length";
+		case "tool-calls": return "toolUse";
+		case "content-filter":
+		case "error":
+		case "other": return "error";
+		default: return "stop";
 	}
 }
-function buildParams$1(model, context, isOAuthToken, options) {
-	const { cacheControl } = getCacheControl(model.baseUrl, options?.cacheRetention);
-	const params = {
-		model: model.id,
-		messages: convertMessages$1(context.messages, model, isOAuthToken, cacheControl),
-		max_tokens: options?.maxTokens || model.maxTokens / 3 | 0,
-		stream: true
+function mapUsage(usage, model) {
+	const cacheRead = usage?.inputTokenDetails?.cacheReadTokens ?? usage?.cachedInputTokens ?? 0;
+	const cacheWrite = usage?.inputTokenDetails?.cacheWriteTokens ?? 0;
+	const input = usage?.inputTokenDetails?.noCacheTokens ?? Math.max((usage?.inputTokens ?? 0) - cacheRead - cacheWrite, 0);
+	const output = usage?.outputTokens ?? 0;
+	const result = {
+		input,
+		output,
+		cacheRead,
+		cacheWrite,
+		totalTokens: usage?.totalTokens ?? input + cacheRead + cacheWrite + output,
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			total: 0
+		}
 	};
-	if (isOAuthToken) {
-		params.system = [{
-			type: "text",
-			text: "You are Claude Code, Anthropic's official CLI for Claude.",
-			...cacheControl ? { cache_control: cacheControl } : {}
-		}];
-		if (context.systemPrompt) params.system.push({
-			type: "text",
-			text: sanitizeSurrogates(context.systemPrompt),
-			...cacheControl ? { cache_control: cacheControl } : {}
-		});
-	} else if (context.systemPrompt) params.system = [{
-		type: "text",
-		text: sanitizeSurrogates(context.systemPrompt),
-		...cacheControl ? { cache_control: cacheControl } : {}
-	}];
-	if (options?.temperature !== void 0 && !options?.thinkingEnabled) params.temperature = options.temperature;
-	if (context.tools) params.tools = convertTools$1(context.tools, isOAuthToken);
-	if (options?.thinkingEnabled && model.reasoning) params.thinking = {
-		type: "enabled",
-		budget_tokens: options.thinkingBudgetTokens || 1024
+	Model.calculateCost(model, result);
+	return result;
+}
+function toolCallFromPart(part) {
+	return {
+		type: "toolCall",
+		callID: part.toolCallId,
+		name: part.toolName,
+		arguments: typeof part.input === "object" && part.input !== null ? part.input : {},
+		status: "pending",
+		time: {
+			start: Date.now(),
+			end: Date.now()
+		}
 	};
-	if (options?.metadata) {
-		const userId = options.metadata.user_id;
-		if (typeof userId === "string") params.metadata = { user_id: userId };
+}
+function updateToolCallFromInput(block, partialJson) {
+	block.partialJson = partialJson;
+	block.arguments = parseStreamingJson(partialJson);
+	block.time.end = Date.now();
+}
+//#endregion
+//#region src/llm/stream.ts
+function providerOptionsKey(model) {
+	return model.providerOptionsKey ?? model.protocol;
+}
+function mergeProviderOptions(...sources) {
+	const result = {};
+	for (const source of sources) {
+		if (!source) continue;
+		for (const [key, value] of Object.entries(source)) {
+			if (!value) continue;
+			result[key] = {
+				...result[key],
+				...value
+			};
+		}
 	}
-	if (options?.toolChoice) params.tool_choice = typeof options.toolChoice === "string" ? { type: options.toolChoice } : options.toolChoice;
-	return params;
+	return result;
 }
-const streamAnthropic = (model, context, options) => {
-	const stream = new AssistantMessageEventStream();
-	(async () => {
-		const output = Message.createAssistantMessage({
-			role: "assistant",
-			parts: [],
-			protocol: model.protocol,
-			provider: model.provider,
-			model: model.id,
-			usage: {
-				input: 0,
-				output: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-				totalTokens: 0,
-				cost: {
-					input: 0,
-					output: 0,
-					cacheRead: 0,
-					cacheWrite: 0,
-					total: 0
-				}
-			},
-			stopReason: "stop",
-			time: {
-				created: Date.now(),
-				completed: Date.now()
-			}
-		});
-		try {
-			let client;
-			let isOAuthToken;
-			if (options?.client) {
-				client = options.client;
-				isOAuthToken = false;
-			} else {
-				const apiKey = options?.apiKey ?? /* @__PURE__ */ getEnvApiKey(model.provider);
-				if (!apiKey) throw new Error(`No API key for provider: ${model.provider.id}`);
-				const created = createClient$1(model, apiKey, options?.interleavedThinking ?? true, options?.headers);
-				client = created.client;
-				isOAuthToken = created.isOAuthToken;
-			}
-			let params = buildParams$1(model, context, isOAuthToken, options);
-			const nextParams = await options?.onPayload?.(params, model);
-			if (nextParams !== void 0) params = nextParams;
-			const anthropicStream = client.messages.stream({
-				...params,
-				stream: true
-			}, { signal: options?.signal });
+function configuredCacheRetention(options) {
+	if (options.cacheRetention) return options.cacheRetention;
+	const env = process.env.CODEWORK_CACHE_RETENTION;
+	if (env === "none" || env === "short" || env === "long") return env;
+}
+function cacheProviderOptions(model, options) {
+	const retention = configuredCacheRetention(options);
+	const key = providerOptionsKey(model);
+	if (retention === "none") return {};
+	if (key === "openai") {
+		const openai = {};
+		if (options.sessionId) openai.promptCacheKey = options.sessionId;
+		if (retention === "short") openai.promptCacheRetention = "in_memory";
+		if (retention === "long") openai.promptCacheRetention = "24h";
+		return Object.keys(openai).length > 0 ? { [key]: openai } : {};
+	}
+	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
+};
+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 = Model.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") 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 partIndex(output, block) {
+	return output.parts.indexOf(block);
+}
+function ensureTextBlock(output, id, stream) {
+	const existing = output.parts.find((part) => part.type === "text" && part.streamId === id);
+	if (existing) return existing;
+	const block = {
+		type: "text",
+		text: "",
+		streamId: id
+	};
+	output.parts.push(block);
+	stream.push({
+		type: "text.start",
+		partIndex: partIndex(output, block),
+		partial: output
+	});
+	return block;
+}
+function ensureThinkingBlock(output, id, stream) {
+	const existing = output.parts.find((part) => part.type === "thinking" && part.streamId === id);
+	if (existing) return existing;
+	const block = {
+		type: "thinking",
+		thinking: "",
+		streamId: id
+	};
+	output.parts.push(block);
+	stream.push({
+		type: "thinking.start",
+		partIndex: partIndex(output, block),
+		partial: output
+	});
+	return block;
+}
+function ensureToolCallBlock(output, id, name, stream, emitStart) {
+	const existing = output.parts.find((part) => part.type === "toolCall" && part.callID === id);
+	if (existing) {
+		if (!existing.name && name) existing.name = name;
+		return existing;
+	}
+	const block = {
+		type: "toolCall",
+		callID: id,
+		name,
+		arguments: {},
+		status: "pending",
+		time: {
+			start: Date.now(),
+			end: Date.now()
+		}
+	};
+	output.parts.push(block);
+	if (emitStart) stream.push({
+		type: "toolcall.start",
+		partIndex: partIndex(output, block),
+		partial: output
+	});
+	return block;
+}
+function finishTextBlock(output, id, stream) {
+	const block = output.parts.find((part) => part.type === "text" && part.streamId === id);
+	if (!block) return;
+	const index = partIndex(output, block);
+	delete block.streamId;
+	stream.push({
+		type: "text.end",
+		partIndex: index,
+		content: block.text,
+		partial: output
+	});
+}
+function finishThinkingBlock(output, id, stream) {
+	const block = output.parts.find((part) => part.type === "thinking" && part.streamId === id);
+	if (!block) return;
+	const index = partIndex(output, block);
+	delete block.streamId;
+	stream.push({
+		type: "thinking.end",
+		partIndex: index,
+		content: block.thinking,
+		partial: output
+	});
+}
+function finishToolInput(output, id, stream) {
+	const block = output.parts.find((part) => part.type === "toolCall" && part.callID === id);
+	if (!block) return;
+	const index = partIndex(output, block);
+	delete block.partialJson;
+	stream.push({
+		type: "toolcall.end",
+		partIndex: index,
+		toolCall: block,
+		partial: output
+	});
+}
+function finalizeToolCall(output, part, stream) {
+	const existing = output.parts.find((item) => item.type === "toolCall" && item.callID === part.toolCallId);
+	const block = existing ?? toolCallFromPart(part);
+	block.callID = part.toolCallId;
+	block.name = part.toolName;
+	block.arguments = typeof part.input === "object" && part.input !== null ? part.input : {};
+	block.time.end = Date.now();
+	delete block.partialJson;
+	if (!existing) output.parts.push(block);
+	const index = partIndex(output, block);
+	stream.push({
+		type: "toolcall.final",
+		partIndex: index,
+		toolCall: block,
+		partial: output
+	});
+}
+function handlePart(part, output, model, stream) {
+	switch (part.type) {
+		case "text-start":
+			ensureTextBlock(output, part.id, stream);
+			break;
+		case "text-delta": {
+			const block = ensureTextBlock(output, part.id, stream);
+			block.text += part.text;
 			stream.push({
-				type: "start",
+				type: "text.delta",
+				partIndex: partIndex(output, block),
+				delta: part.text,
 				partial: output
 			});
-			const blocks = output.parts;
-			for await (const event of anthropicStream) if (event.type === "message_start") {
-				output.responseId = event.message.id;
-				output.usage.input = event.message.usage.input_tokens || 0;
-				output.usage.output = event.message.usage.output_tokens || 0;
-				output.usage.cacheRead = event.message.usage.cache_read_input_tokens || 0;
-				output.usage.cacheWrite = event.message.usage.cache_creation_input_tokens || 0;
-				output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
-				Model.calculateCost(model, output.usage);
-			} else if (event.type === "content_block_start") {
-				if (event.content_block.type === "text") {
-					const block = {
-						type: "text",
-						text: "",
-						index: event.index
-					};
-					output.parts.push(block);
-					stream.push({
-						type: "text.start",
-						partIndex: output.parts.length - 1,
-						partial: output
-					});
-				} else if (event.content_block.type === "thinking") {
-					const block = {
-						type: "thinking",
-						thinking: "",
-						thinkingSignature: "",
-						index: event.index
-					};
-					output.parts.push(block);
-					stream.push({
-						type: "thinking.start",
-						partIndex: output.parts.length - 1,
-						partial: output
-					});
-				} else if (event.content_block.type === "redacted_thinking") {
-					const block = {
-						type: "thinking",
-						thinking: "[Reasoning redacted]",
-						thinkingSignature: event.content_block.data,
-						redacted: true,
-						index: event.index
-					};
-					output.parts.push(block);
-					stream.push({
-						type: "thinking.start",
-						partIndex: output.parts.length - 1,
-						partial: output
-					});
-				} else if (event.content_block.type === "tool_use") {
-					const block = {
-						type: "toolCall",
-						callID: event.content_block.id,
-						name: isOAuthToken ? fromClaudeCodeName(event.content_block.name, context.tools) : event.content_block.name,
-						arguments: event.content_block.input ?? {},
-						partialJson: "",
-						status: "pending",
-						time: {
-							start: Date.now(),
-							end: Date.now()
-						},
-						index: event.index
-					};
-					output.parts.push(block);
-					stream.push({
-						type: "toolcall.start",
-						partIndex: output.parts.length - 1,
-						partial: output
-					});
-				}
-			} else if (event.type === "content_block_delta") {
-				const partIndex = blocks.findIndex((b) => b.index === event.index);
-				const block = blocks[partIndex];
-				if (!block) continue;
-				if (event.delta.type === "text_delta" && block.type === "text") {
-					block.text += event.delta.text;
-					stream.push({
-						type: "text.delta",
-						partIndex,
-						delta: event.delta.text,
-						partial: output
-					});
-				} else if (event.delta.type === "thinking_delta" && block.type === "thinking") {
-					block.thinking += event.delta.thinking;
-					stream.push({
-						type: "thinking.delta",
-						partIndex,
-						delta: event.delta.thinking,
-						partial: output
-					});
-				} else if (event.delta.type === "input_json_delta" && block.type === "toolCall") {
-					block.partialJson += event.delta.partial_json;
-					block.arguments = parseStreamingJson(block.partialJson);
-					stream.push({
-						type: "toolcall.delta",
-						partIndex,
-						delta: event.delta.partial_json,
-						partial: output
-					});
-				} else if (event.delta.type === "signature_delta" && block.type === "thinking") {
-					block.thinkingSignature = block.thinkingSignature || "";
-					block.thinkingSignature += event.delta.signature;
-				}
-			} else if (event.type === "content_block_stop") {
-				const partIndex = blocks.findIndex((b) => b.index === event.index);
-				const block = blocks[partIndex];
-				if (block) {
-					delete block.index;
-					if (block.type === "text") stream.push({
-						type: "text.end",
-						partIndex,
-						content: block.text,
-						partial: output
-					});
-					else if (block.type === "thinking") stream.push({
-						type: "thinking.end",
-						partIndex,
-						content: block.thinking,
-						partial: output
-					});
-					else if (block.type === "toolCall") {
-						block.arguments = parseStreamingJson(block.partialJson);
-						delete block.partialJson;
-						stream.push({
-							type: "toolcall.end",
-							partIndex,
-							toolCall: block,
-							partial: output
-						});
-					}
-				}
-			} else if (event.type === "message_delta") {
-				if (event.delta.stop_reason) output.stopReason = mapStopReason$1(event.delta.stop_reason);
-				if (event.usage.input_tokens != null) output.usage.input = event.usage.input_tokens;
-				if (event.usage.output_tokens != null) output.usage.output = event.usage.output_tokens;
-				if (event.usage.cache_read_input_tokens != null) output.usage.cacheRead = event.usage.cache_read_input_tokens;
-				if (event.usage.cache_creation_input_tokens != null) output.usage.cacheWrite = event.usage.cache_creation_input_tokens;
-				output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
-				Model.calculateCost(model, output.usage);
-			}
-			if (options?.signal?.aborted) throw new Error("Request was aborted");
-			if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error("An unknown error occurred");
-			output.time.completed = Date.now();
+			break;
+		}
+		case "text-end":
+			finishTextBlock(output, part.id, stream);
+			break;
+		case "reasoning-start":
+			ensureThinkingBlock(output, part.id, stream);
+			break;
+		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;
+			if (typeof sig === "string") block.thinkingSignature = sig;
 			stream.push({
-				type: "done",
-				reason: output.stopReason,
-				message: output
+				type: "thinking.delta",
+				partIndex: partIndex(output, block),
+				delta: part.text,
+				partial: output
 			});
-			stream.end();
-		} catch (error) {
-			for (const block of output.parts) delete block.index;
-			output.time.completed = Date.now();
-			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-			output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+			break;
+		}
+		case "reasoning-end":
+			finishThinkingBlock(output, part.id, stream);
+			break;
+		case "tool-input-start":
+			ensureToolCallBlock(output, part.id, part.toolName, stream, true);
+			break;
+		case "tool-input-delta": {
+			const block = ensureToolCallBlock(output, part.id, "", stream, true);
+			updateToolCallFromInput(block, (block.partialJson ?? "") + part.delta);
 			stream.push({
-				type: "error",
-				reason: output.stopReason,
-				error: output
+				type: "toolcall.delta",
+				partIndex: partIndex(output, block),
+				delta: part.delta,
+				partial: output
 			});
-			stream.end();
+			break;
 		}
-	})();
-	return stream;
-};
-const streamSimpleAnthropic = (model, context, options) => {
-	const apiKey = options?.apiKey || /* @__PURE__ */ getEnvApiKey(model.provider);
-	if (!apiKey) throw new Error(`No API key for provider: ${model.provider.id}`);
-	const base = Stream.buildBaseOptions(model, options, apiKey);
-	if (!options?.reasoning) return streamAnthropic(model, context, {
-		...base,
-		thinkingEnabled: false
-	});
-	const adjusted = Stream.adjustMaxTokensForThinking(base.maxTokens || 0, model.maxTokens, options.reasoning, options.thinkingBudgets);
-	return streamAnthropic(model, context, {
-		...base,
-		maxTokens: adjusted.maxTokens,
-		thinkingEnabled: true,
-		thinkingBudgetTokens: adjusted.thinkingBudget
-	});
-};
-const anthropicProtocolProvider = {
-	protocol: Model.KnownProtocolEnum.anthropicMessages,
-	stream: streamAnthropic,
-	streamSimple: streamSimpleAnthropic
-};
-//#endregion
-//#region src/provider/providers/github/github.ts
-function inferCopilotInitiator(messages) {
-	const last = messages[messages.length - 1];
-	return last && last.role !== "user" ? "agent" : "user";
-}
-function hasCopilotVisionInput(messages) {
-	return messages.some((msg) => {
-		if (msg.role === "user") return msg.parts.some((c) => c.type === "image");
-		return false;
-	});
-}
-function buildCopilotDynamicHeaders(params) {
-	const headers = {
-		"X-Initiator": inferCopilotInitiator(params.messages),
-		"Openai-Intent": "conversation-edits"
-	};
-	if (params.hasImages) headers["Copilot-Vision-Request"] = "true";
-	return headers;
-}
-//#endregion
-//#region src/provider/providers/openai/completions.ts
-function hasToolHistory(messages) {
-	for (const msg of messages) {
-		if (msg.role !== "assistant") continue;
-		if (msg.parts.some((block) => block.type === "toolCall")) return true;
+		case "tool-input-end":
+			finishToolInput(output, part.id, stream);
+			break;
+		case "tool-call":
+			finalizeToolCall(output, part, stream);
+			break;
+		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);
+			output.stopReason = mapFinishReason(part.finishReason);
+			break;
+		case "finish":
+			output.usage = mapUsage(part.totalUsage, model);
+			output.stopReason = mapFinishReason(part.finishReason);
+			break;
+		case "abort":
+			output.stopReason = "aborted";
+			output.errorMessage = part.reason;
+			break;
+		case "error": throw part.error instanceof Error ? part.error : new Error(formatThrownError(part.error));
 	}
-	return false;
-}
-function buildSyntheticToolResult(block, compat) {
-	const message = {
-		role: "tool",
-		content: [
-			"<result>",
-			"No Result Provided",
-			"</result>"
-		].join("\n"),
-		tool_call_id: block.callID
-	};
-	if (compat.requiresToolResultName) message.name = block.name;
-	return message;
 }
-function resolveBaseUrl(model) {
-	return model.baseUrl || (model.provider.id === Provider.KnownProviderEnum.openai ? "https://api.openai.com/v1" : "");
+/**
+* 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.
+*/
+function resolveMaxOutputTokens(model, options, providerOptions) {
+	const maxTokens = options.maxTokens;
+	if (maxTokens === void 0) return void 0;
+	const key = providerOptionsKey(model);
+	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;
 }
-const streamOpenAICompletions = (model, context, options) => {
+const stream$1 = (model, context, options) => {
 	const stream = new AssistantMessageEventStream();
+	const runtimeOptions = applyDefaultMaxTokens(model, options ?? {});
 	(async () => {
-		const output = Message.createAssistantMessage({
-			role: "assistant",
-			parts: [],
-			protocol: model.protocol,
-			provider: model.provider,
-			model: model.id,
-			usage: {
-				input: 0,
-				output: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-				totalTokens: 0,
-				cost: {
-					input: 0,
-					output: 0,
-					cacheRead: 0,
-					cacheWrite: 0,
-					total: 0
-				}
-			},
-			stopReason: "stop",
-			time: {
-				created: Date.now(),
-				completed: Date.now()
-			}
-		});
+		const output = createAssistantMessage(model);
 		try {
-			const client = createClient(model, context, options?.apiKey || /* @__PURE__ */ getEnvApiKey(model.provider) || "", options?.headers);
-			let params = buildParams(model, context, options);
-			const nextParams = await options?.onPayload?.(params, model);
-			if (nextParams !== void 0) params = nextParams;
-			const openaiStream = await client.chat.completions.create(params, { signal: options?.signal });
+			const languageModel = await resolveAISDKLanguageModel(model, runtimeOptions);
+			const tools = convertTools(context.tools);
+			const messages = convertMessages(context, model);
+			const providerOptions = resolveProviderOptions(model, runtimeOptions);
+			const activeTools = runtimeOptions.activeTools?.filter((name) => !tools || name in tools);
+			let params = {
+				model: languageModel,
+				system: context.systemPrompt,
+				messages,
+				tools,
+				toolChoice: runtimeOptions.toolChoice,
+				activeTools,
+				maxOutputTokens: resolveMaxOutputTokens(model, runtimeOptions, providerOptions),
+				temperature: runtimeOptions.temperature,
+				providerOptions,
+				abortSignal: runtimeOptions.signal,
+				timeout: runtimeOptions.timeoutMs,
+				maxRetries: runtimeOptions.maxRetries,
+				headers: runtimeOptions.headers
+			};
+			const payload = await runtimeOptions.onPayload?.(params, model);
+			if (payload !== void 0) params = payload;
+			const result = streamText(params);
 			stream.push({
 				type: "start",
 				partial: output
 			});
-			let currentBlock = null;
-			const blocks = output.parts;
-			const activeToolCalls = /* @__PURE__ */ new Map();
-			const finishCurrentBlock = (block) => {
-				if (block) {
-					const partIndex = block.index ?? blocks.indexOf(block);
-					delete block.index;
-					if (block.type === "text") stream.push({
-						type: "text.end",
-						partIndex,
-						content: block.text,
-						partial: output
-					});
-					else if (block.type === "thinking") stream.push({
-						type: "thinking.end",
-						partIndex,
-						content: block.thinking,
-						partial: output
-					});
-					else if (block.type === "toolCall") {
-						if (block.streamIndex !== void 0) activeToolCalls.delete(block.streamIndex);
-						block.arguments = parseStreamingJson(block.partialArgs);
-						delete block.partialArgs;
-						delete block.streamIndex;
-						stream.push({
-							type: "toolcall.end",
-							partIndex,
-							toolCall: block,
-							partial: output
-						});
-					}
-				}
-			};
-			const flushActiveToolCalls = () => {
-				for (const toolBlock of [...activeToolCalls.values()].sort((a, b) => (a.index ?? 0) - (b.index ?? 0))) finishCurrentBlock(toolBlock);
-			};
-			for await (const chunk of openaiStream) {
-				if (!chunk || typeof chunk !== "object") continue;
-				output.responseId ||= chunk.id;
-				if (chunk.usage) output.usage = parseChunkUsage(chunk.usage, model);
-				const choice = Array.isArray(chunk.choices) ? chunk.choices[0] : void 0;
-				if (!choice) continue;
-				const choiceWithUsage = choice;
-				if (!chunk.usage && choiceWithUsage.usage) output.usage = parseChunkUsage(choiceWithUsage.usage, model);
-				if (choice.finish_reason) {
-					const finishReasonResult = mapStopReason(choice.finish_reason);
-					output.stopReason = finishReasonResult.stopReason;
-					if (finishReasonResult.errorMessage) output.errorMessage = finishReasonResult.errorMessage;
-				}
-				if (!choice.delta) continue;
-				if (choice.delta.content !== null && choice.delta.content !== void 0 && choice.delta.content.length > 0) {
-					if (activeToolCalls.size > 0) flushActiveToolCalls();
-					if (!currentBlock || currentBlock.type !== "text") {
-						finishCurrentBlock(currentBlock);
-						currentBlock = {
-							type: "text",
-							text: "",
-							index: output.parts.length
-						};
-						output.parts.push(currentBlock);
-						stream.push({
-							type: "text.start",
-							partIndex: currentBlock.index,
-							partial: output
-						});
-					}
-					if (currentBlock.type === "text") {
-						currentBlock.text += choice.delta.content;
-						stream.push({
-							type: "text.delta",
-							partIndex: currentBlock.index,
-							delta: choice.delta.content,
-							partial: output
-						});
-					}
-				}
-				const reasoningFields = [
-					"reasoning_content",
-					"reasoning",
-					"reasoning_text"
-				];
-				let foundReasoningField = null;
-				for (const field of reasoningFields) {
-					const value = choice.delta[field];
-					if (typeof value === "string" && value.length > 0) {
-						foundReasoningField = field;
-						break;
-					}
-				}
-				if (foundReasoningField) {
-					if (activeToolCalls.size > 0) flushActiveToolCalls();
-					if (!currentBlock || currentBlock.type !== "thinking") {
-						finishCurrentBlock(currentBlock);
-						currentBlock = {
-							type: "thinking",
-							thinking: "",
-							thinkingSignature: foundReasoningField,
-							index: output.parts.length
-						};
-						output.parts.push(currentBlock);
-						stream.push({
-							type: "thinking.start",
-							partIndex: currentBlock.index,
-							partial: output
-						});
-					}
-					if (currentBlock.type === "thinking") {
-						const delta = choice.delta[foundReasoningField];
-						if (typeof delta === "string") {
-							currentBlock.thinking += delta;
-							stream.push({
-								type: "thinking.delta",
-								partIndex: currentBlock.index,
-								delta,
-								partial: output
-							});
-						}
-					}
-				}
-				if (choice.delta.tool_calls) {
-					if (currentBlock) {
-						finishCurrentBlock(currentBlock);
-						currentBlock = null;
-					}
-					for (const toolCall of choice.delta.tool_calls) {
-						const streamIndex = toolCall.index ?? activeToolCalls.size;
-						let toolBlock = activeToolCalls.get(streamIndex);
-						if (!toolBlock) {
-							toolBlock = {
-								type: "toolCall",
-								callID: toolCall.id || "",
-								name: toolCall.function?.name || "",
-								arguments: {},
-								partialArgs: "",
-								index: output.parts.length,
-								streamIndex,
-								status: "pending",
-								time: {
-									start: Date.now(),
-									end: Date.now()
-								}
-							};
-							activeToolCalls.set(streamIndex, toolBlock);
-							output.parts.push(toolBlock);
-							stream.push({
-								type: "toolcall.start",
-								partIndex: toolBlock.index,
-								partial: output
-							});
-						}
-						if (toolCall.id) toolBlock.callID = toolCall.id;
-						if (toolCall.function?.name) toolBlock.name = toolCall.function.name;
-						let delta = "";
-						if (toolCall.function?.arguments) {
-							delta = toolCall.function.arguments;
-							toolBlock.partialArgs = (toolBlock.partialArgs || "") + delta;
-							toolBlock.arguments = parseStreamingJson(toolBlock.partialArgs);
-						}
-						toolBlock.time.end = Date.now();
-						stream.push({
-							type: "toolcall.delta",
-							partIndex: toolBlock.index,
-							delta,
-							partial: output
-						});
-					}
-				}
-				const reasoningDetails = choice.delta.reasoning_details;
-				if (reasoningDetails && Array.isArray(reasoningDetails)) {
-					for (const detail of reasoningDetails) if (detail.type === "reasoning.encrypted" && typeof detail.id === "string" && detail.data !== void 0) {
-						const matchingToolCall = output.parts.find((block) => block.type === "toolCall" && block.callID === detail.id);
-						if (matchingToolCall) matchingToolCall.thoughtSignature = JSON.stringify(detail);
-					}
-				}
-			}
-			finishCurrentBlock(currentBlock);
-			flushActiveToolCalls();
-			if (options?.signal?.aborted) throw new Error("Request was aborted");
-			if (output.stopReason === "aborted") throw new Error("Request was aborted");
+			for await (const part of result.fullStream) handlePart(part, output, model, stream);
+			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({
@@ -2160,15 +1366,13 @@ const streamOpenAICompletions = (model, context, options) => {
 			stream.end();
 		} catch (error) {
 			for (const block of output.parts) {
-				delete block.index;
-				delete block.partialArgs;
-				delete block.streamIndex;
+				delete block.streamId;
+				delete block.streamId;
+				delete block.partialJson;
 			}
 			output.time.completed = Date.now();
-			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-			output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
-			const rawMetadata = error?.error?.metadata?.raw;
-			if (rawMetadata) output.errorMessage += `\n${rawMetadata}`;
+			output.stopReason = runtimeOptions.signal?.aborted || output.stopReason === "aborted" ? "aborted" : "error";
+			output.errorMessage = formatThrownError(error);
 			stream.push({
 				type: "error",
 				reason: output.stopReason,
@@ -2179,1182 +1383,30 @@ const streamOpenAICompletions = (model, context, options) => {
 	})();
 	return stream;
 };
-const streamSimpleOpenAICompletions = (model, context, options) => {
-	const apiKey = options?.apiKey || /* @__PURE__ */ getEnvApiKey(model.provider);
-	if (!apiKey) throw new Error(`No API key for provider: ${model.provider.id}`);
-	const base = Stream.buildBaseOptions(model, options, apiKey);
-	const simpleReasoning = Model.supportsXhigh(model) ? options?.reasoning : Stream.clampReasoning(options?.reasoning);
-	const reasoningEffort = simpleReasoning && simpleReasoning !== Stream.ThinkingLevelEnum.off ? simpleReasoning : void 0;
-	const toolChoice = options?.toolChoice;
-	return streamOpenAICompletions(model, context, {
-		...base,
-		reasoningEffort,
-		toolChoice
-	});
-};
-function buildParams(model, context, options) {
-	const compat = getCompat(model);
-	const messages = convertMessages(model, context, compat);
-	maybeAddOpenRouterAnthropicCacheControl(model, messages);
-	const baseUrl = resolveBaseUrl(model);
-	const params = {
-		model: model.id,
-		messages,
-		stream: true
-	};
-	if (compat.supportsUsageInStreaming !== false) params.stream_options = { include_usage: true };
-	if (compat.supportsStore) params.store = false;
-	if (options?.maxTokens) if (compat.maxTokensField === "max_tokens") params.max_tokens = options.maxTokens;
-	else params.max_completion_tokens = options.maxTokens;
-	if (options?.temperature !== void 0) params.temperature = options.temperature;
-	if (context.tools) {
-		params.tools = convertTools(context.tools, compat);
-		if (compat.zaiToolStream) params.tool_stream = true;
-	} else if (hasToolHistory(context.messages)) params.tools = [];
-	if (options?.toolChoice) params.tool_choice = options.toolChoice;
-	if ((compat.thinkingFormat === "zai" || compat.thinkingFormat === "qwen") && model.reasoning) params.enable_thinking = !!options?.reasoningEffort;
-	else if (compat.thinkingFormat === "qwen-chat-template" && model.reasoning) params.chat_template_kwargs = { enable_thinking: !!options?.reasoningEffort };
-	else if (compat.thinkingFormat === "openrouter" && model.reasoning) {
-		const openRouterParams = params;
-		if (options?.reasoningEffort) openRouterParams.reasoning = { effort: mapReasoningEffort(options.reasoningEffort, compat.reasoningEffortMap) };
-		else openRouterParams.reasoning = { effort: "none" };
-	} else if (options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) params.reasoning_effort = mapReasoningEffort(options.reasoningEffort, compat.reasoningEffortMap);
-	if (baseUrl.includes("openrouter.ai") && model.compat?.openRouterRouting) params.provider = model.compat.openRouterRouting;
-	if (baseUrl.includes("ai-gateway.vercel.sh") && model.compat?.vercelGatewayRouting) {
-		const routing = model.compat.vercelGatewayRouting;
-		if (routing.only || routing.order) {
-			const gatewayOptions = {};
-			if (routing.only) gatewayOptions.only = routing.only;
-			if (routing.order) gatewayOptions.order = routing.order;
-			params.providerOptions = { gateway: gatewayOptions };
-		}
-	}
-	return params;
-}
-function createClient(model, context, apiKey, optsHeaders) {
-	const baseUrl = resolveBaseUrl(model);
-	if (!apiKey) {
-		if (!process.env.OPENAI_API_KEY) throw new Error("OpenAI API key is required. set OPENAI_API_KEY environment variable or pass it as an argument");
-		apiKey = process.env.OPENAI_API_KEY;
-	}
-	const headers = { ...model.headers };
-	if (model.provider.id === Provider.KnownProviderEnum.githubCopilot) {
-		const hasImages = hasCopilotVisionInput(context.messages);
-		const copilotHeaders = buildCopilotDynamicHeaders({
-			messages: context.messages,
-			hasImages
-		});
-		Object.assign(headers, copilotHeaders);
-	}
-	if (optsHeaders) Object.assign(headers, optsHeaders);
-	return new OpenAI({
-		apiKey,
-		baseURL: baseUrl,
-		dangerouslyAllowBrowser: true,
-		defaultHeaders: headers
-	});
-}
-function mapReasoningEffort(effort, reasoningEffortMap) {
-	return reasoningEffortMap[effort] ?? effort;
-}
-function maybeAddOpenRouterAnthropicCacheControl(model, messages) {
-	if (model.provider.id !== Provider.KnownProviderEnum.openrouter || !model.id.startsWith("anthropic/")) return;
-	for (let i = messages.length - 1; i >= 0; i--) {
-		const msg = messages[i];
-		if (!msg) continue;
-		if (msg.role !== "user" && msg.role !== "assistant") continue;
-		const content = msg.content;
-		if (typeof content === "string") {
-			msg.content = [Object.assign({
-				type: "text",
-				text: content
-			}, { cache_control: { type: "ephemeral" } })];
-			return;
-		}
-		if (!Array.isArray(content)) continue;
-		for (let j = content.length - 1; j >= 0; j--) {
-			const part = content[j];
-			if (part?.type === "text") {
-				Object.assign(part, { cache_control: { type: "ephemeral" } });
-				return;
-			}
-		}
-	}
-}
-function convertMessages(model, context, compat) {
-	const params = [];
-	const normalizeToolCallId = (id) => {
-		if (id.includes("|")) return (id.split("|")[0] ?? id).replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 40);
-		if (model.provider.id === Provider.KnownProviderEnum.openai) return id.length > 40 ? id.slice(0, 40) : id;
-		return id;
-	};
-	const transformedMessages = Message.transformMessages(context.messages, model, normalizeToolCallId);
-	if (context.systemPrompt) {
-		const role = model.reasoning && compat.supportsDeveloperRole ? "developer" : "system";
-		params.push({
-			role,
-			content: sanitizeSurrogates(context.systemPrompt)
-		});
-	}
-	let lastRole = null;
-	for (const msg of transformedMessages) {
-		if (compat.requiresAssistantAfterToolResult && lastRole === "tool" && msg.role === "user") {
-			params.push({
-				role: "assistant",
-				content: "I have processed the tool results."
-			});
-			lastRole = "assistant";
-		}
-		if (msg.role === "user") {
-			const content = msg.parts.flatMap((item) => {
-				if (item.type === "text") {
-					const text = sanitizeSurrogates(item.text);
-					if (text.trim().length === 0) return [];
-					return [{
-						type: "text",
-						text
-					}];
-				}
-				if (!model.input.includes("image")) return [];
-				return [{
-					type: "image_url",
-					image_url: { url: `data:${item.mimeType};base64,${item.data}` }
-				}];
-			});
-			if (content.length === 0) continue;
-			params.push({
-				role: "user",
-				content
-			});
-			lastRole = "user";
-			continue;
-		}
-		const assistantMsg = {
-			role: "assistant",
-			content: compat.requiresAssistantAfterToolResult ? "" : null
-		};
-		const textSegments = msg.parts.filter((block) => block.type === "text").map((block) => sanitizeSurrogates(block.text)).filter((text) => text.trim().length > 0);
-		const nonEmptyThinkingBlocks = msg.parts.filter((block) => block.type === "thinking").filter((block) => block.thinking.trim().length > 0);
-		if (compat.requiresThinkingAsText && nonEmptyThinkingBlocks.length > 0) textSegments.unshift(...nonEmptyThinkingBlocks.map((block) => sanitizeSurrogates(block.thinking)));
-		else if (nonEmptyThinkingBlocks.length > 0) {
-			const signature = nonEmptyThinkingBlocks[0]?.thinkingSignature;
-			if (signature && signature.length > 0) assistantMsg[signature] = nonEmptyThinkingBlocks.map((block) => sanitizeSurrogates(block.thinking)).join("\n");
-		}
-		if (textSegments.length > 0) assistantMsg.content = textSegments.join("");
-		const toolCalls = msg.parts.filter((block) => block.type === "toolCall");
-		if (toolCalls.length > 0) {
-			assistantMsg.tool_calls = toolCalls.map((toolCall) => ({
-				id: toolCall.callID,
-				type: "function",
-				function: {
-					name: toolCall.name,
-					arguments: JSON.stringify(toolCall.arguments)
-				}
-			}));
-			const reasoningDetails = toolCalls.filter((toolCall) => toolCall.thoughtSignature).map((toolCall) => {
-				try {
-					return JSON.parse(toolCall.thoughtSignature);
-				} catch {
-					return null;
-				}
-			}).filter(Boolean);
-			if (reasoningDetails.length > 0) assistantMsg.reasoning_details = reasoningDetails;
-		}
-		const assistantContent = assistantMsg.content;
-		if (!(assistantContent !== null && assistantContent !== void 0 && (typeof assistantContent === "string" ? assistantContent.length > 0 : assistantContent.length > 0)) && !assistantMsg.tool_calls) continue;
-		params.push(assistantMsg);
-		lastRole = "assistant";
-		const imageBlocks = [];
-		for (const toolCall of toolCalls) {
-			if (toolCall.status === "pending" || toolCall.status === "running") {
-				params.push(buildSyntheticToolResult(toolCall, compat));
-				lastRole = "tool";
-				continue;
-			}
-			const textResult = toolCall.result.content.filter((content) => content.type === "text").map((content) => content.text).join("\n");
-			const hasImages = toolCall.result.content.some((content) => content.type === "image");
-			const toolResultMsg = {
-				role: "tool",
-				content: sanitizeSurrogates(textResult.length > 0 ? textResult : "(see attached image)"),
-				tool_call_id: toolCall.callID
-			};
-			if (compat.requiresToolResultName) toolResultMsg.name = toolCall.name;
-			params.push(toolResultMsg);
-			lastRole = "tool";
-			if (hasImages && model.input.includes("image")) {
-				for (const block of toolCall.result.content) if (block.type === "image") imageBlocks.push({
-					type: "image_url",
-					image_url: { url: `data:${block.mimeType};base64,${block.data}` }
-				});
-			}
-		}
-		if (imageBlocks.length > 0) {
-			if (compat.requiresAssistantAfterToolResult) params.push({
-				role: "assistant",
-				content: "I have processed the tool results."
-			});
-			params.push({
-				role: "user",
-				content: [{
-					type: "text",
-					text: "Attached image(s) from tool result:"
-				}, ...imageBlocks]
-			});
-			lastRole = "user";
-		}
-	}
-	return params;
-}
-function convertTools(tools, compat) {
-	return tools.map((tool) => ({
-		type: "function",
-		function: {
-			name: tool.name,
-			description: tool.description,
-			parameters: tool.parameters,
-			...compat.supportsStrictMode !== false && { strict: false }
-		}
-	}));
-}
-function parseChunkUsage(rawUsage, model) {
-	const promptTokens = rawUsage.prompt_tokens || 0;
-	const reportedCachedTokens = rawUsage.prompt_tokens_details?.cached_tokens || 0;
-	const cacheWriteTokens = rawUsage.prompt_tokens_details?.cache_write_tokens || 0;
-	const reasoningTokens = rawUsage.completion_tokens_details?.reasoning_tokens || 0;
-	const cacheReadTokens = cacheWriteTokens > 0 ? Math.max(0, reportedCachedTokens - cacheWriteTokens) : reportedCachedTokens;
-	const input = Math.max(0, promptTokens - cacheReadTokens - cacheWriteTokens);
-	const outputTokens = (rawUsage.completion_tokens || 0) + reasoningTokens;
-	const usage = {
-		input,
-		output: outputTokens,
-		cacheRead: cacheReadTokens,
-		cacheWrite: cacheWriteTokens,
-		totalTokens: input + outputTokens + cacheReadTokens + cacheWriteTokens,
-		cost: {
-			input: 0,
-			output: 0,
-			cacheRead: 0,
-			cacheWrite: 0,
-			total: 0
-		}
-	};
-	Model.calculateCost(model, usage);
-	return usage;
-}
-function mapStopReason(reason) {
-	if (reason === null) return { stopReason: "stop" };
-	switch (reason) {
-		case "stop":
-		case "end": return { stopReason: "stop" };
-		case "length": return { stopReason: "length" };
-		case "function_call":
-		case "tool_calls": return { stopReason: "toolUse" };
-		case "content_filter": return {
-			stopReason: "error",
-			errorMessage: "Provider finish_reason: content_filter"
-		};
-		case "network_error": return {
-			stopReason: "error",
-			errorMessage: "Provider finish_reason: network_error"
-		};
-		default: return {
-			stopReason: "error",
-			errorMessage: `Provider finish_reason: ${reason}`
-		};
-	}
-}
-function detectCompat(model) {
-	const provider = model.provider.id;
-	const baseUrl = resolveBaseUrl(model);
-	const isZai = provider === "zai" || baseUrl.includes("api.z.ai");
-	const isNonStandard = provider === "cerebras" || baseUrl.includes("cerebras.ai") || provider === "xai" || baseUrl.includes("api.x.ai") || baseUrl.includes("chutes.ai") || baseUrl.includes("deepseek.com") || isZai || provider === "opencode" || baseUrl.includes("opencode.ai");
-	const useMaxTokens = baseUrl.includes("chutes.ai");
-	const isGrok = provider === "xai" || baseUrl.includes("api.x.ai");
-	const reasoningEffortMap = (provider === "groq" || baseUrl.includes("groq.com")) && model.id === "qwen/qwen3-32b" ? {
-		minimal: "default",
-		low: "default",
-		medium: "default",
-		high: "default",
-		xhigh: "default"
-	} : {};
+//#endregion
+//#region src/llm/index.ts
+function createAISDKProtocol(protocol) {
 	return {
-		supportsStore: !isNonStandard,
-		supportsDeveloperRole: !isNonStandard,
-		supportsReasoningEffort: !isGrok && !isZai,
-		reasoningEffortMap,
-		supportsUsageInStreaming: true,
-		maxTokensField: useMaxTokens ? "max_tokens" : "max_completion_tokens",
-		requiresToolResultName: false,
-		requiresAssistantAfterToolResult: false,
-		requiresThinkingAsText: false,
-		thinkingFormat: isZai ? "zai" : provider === "openrouter" || baseUrl.includes("openrouter.ai") ? "openrouter" : "openai",
-		openRouterRouting: {},
-		vercelGatewayRouting: {},
-		zaiToolStream: false,
-		supportsStrictMode: true
+		protocol,
+		stream: stream$1
 	};
 }
-/**
-* Get resolved compatibility settings for a model.
-* Uses explicit model.compat if provided, otherwise auto-detects from provider/URL.
-*/
-function getCompat(model) {
-	const detected = detectCompat(model);
-	if (!model.compat) return detected;
-	return {
-		supportsStore: model.compat.supportsStore ?? detected.supportsStore,
-		supportsDeveloperRole: model.compat.supportsDeveloperRole ?? detected.supportsDeveloperRole,
-		supportsReasoningEffort: model.compat.supportsReasoningEffort ?? detected.supportsReasoningEffort,
-		reasoningEffortMap: model.compat.reasoningEffortMap ?? detected.reasoningEffortMap,
-		supportsUsageInStreaming: model.compat.supportsUsageInStreaming ?? detected.supportsUsageInStreaming,
-		maxTokensField: model.compat.maxTokensField ?? detected.maxTokensField,
-		requiresToolResultName: model.compat.requiresToolResultName ?? detected.requiresToolResultName,
-		requiresAssistantAfterToolResult: model.compat.requiresAssistantAfterToolResult ?? detected.requiresAssistantAfterToolResult,
-		requiresThinkingAsText: model.compat.requiresThinkingAsText ?? detected.requiresThinkingAsText,
-		thinkingFormat: model.compat.thinkingFormat ?? detected.thinkingFormat,
-		openRouterRouting: model.compat.openRouterRouting ?? {},
-		vercelGatewayRouting: model.compat.vercelGatewayRouting ?? detected.vercelGatewayRouting,
-		zaiToolStream: model.compat.zaiToolStream ?? detected.zaiToolStream,
-		supportsStrictMode: model.compat.supportsStrictMode ?? detected.supportsStrictMode
-	};
+function registerAISDKProtocols() {
+	Protocol.registerProtocolProvider(createAISDKProtocol(Model.KnownProviderEnum.anthropic));
+	Protocol.registerProtocolProvider(createAISDKProtocol(Model.KnownProviderEnum.google));
+	Protocol.registerProtocolProvider(createAISDKProtocol(Model.KnownProviderEnum.googleVertex));
+	Protocol.registerProtocolProvider(createAISDKProtocol(Model.KnownProviderEnum.googleVertexAnthropic));
+	Protocol.registerProtocolProvider(createAISDKProtocol(Model.KnownProviderEnum.openai));
+	Protocol.registerProtocolProvider(createAISDKProtocol(Model.KnownProviderEnum.openaiCompatible));
+	Protocol.registerProtocolProvider(createAISDKProtocol(Model.KnownProviderEnum.openrouter));
+	Protocol.registerProtocolProvider(createAISDKProtocol(Model.KnownProviderEnum.xai));
 }
-const openAICompletionsProtocolProvider = {
-	protocol: Model.KnownProtocolEnum.openaiCompletions,
-	stream: streamOpenAICompletions,
-	streamSimple: streamSimpleOpenAICompletions
-};
-//#endregion
-//#region src/provider/register.ts
-Stream.registerProtocolProvider(anthropicProtocolProvider, "providers/anthropic/index.ts");
-Stream.registerProtocolProvider(openAICompletionsProtocolProvider, "providers/openai/completions.ts");
-//#endregion
-//#region src/agent/agent.ts
-let Agent;
-(function(_Agent) {
-	_Agent.ToolTerminalResultSchema = Type.Union([Message.ToolCompletedSchema, Message.ToolErrorSchema]);
-	_Agent.ToolResultSchema = Type.Union([
-		Message.ToolRunningSchema,
-		Message.ToolCompletedSchema,
-		Message.ToolErrorSchema
-	]);
-	function defineTool(tool) {
-		return tool;
-	}
-	_Agent.defineTool = defineTool;
-	_Agent.ToolCallInFlightSchema = Type.Object({
-		callID: Type.String(),
-		name: Type.String(),
-		rawArgs: Type.Record(Type.String(), Type.Unknown()),
-		args: Type.Optional(Type.Unknown())
-	});
-	const ModelNotFoundErr = _Agent.ModelNotFoundErr = NamedError.create("ModelNotFoundErr", Type.Object({
-		message: Type.String(),
-		provider: Type.String(),
-		model: Type.String()
-	}));
-	const ModelNotConfiguredErr = _Agent.ModelNotConfiguredErr = NamedError.create("ModelNotConfiguredErr", Type.Object({ message: Type.String() }));
-	const AgentInStreamingErr = _Agent.AgentInStreamingErr = NamedError.create("AgentInStreamingErr", Type.Object({
-		message: Type.String(),
-		name: Type.String()
-	}));
-	class Instance {
-		_state;
-		listeners = /* @__PURE__ */ new Set();
-		abortController;
-		convertToLlm;
-		transformContext;
-		steeringQueue = [];
-		followUpQueue = [];
-		steeringMode;
-		followUpMode;
-		streamFn;
-		_sessionId;
-		getApiKey;
-		_onPayload;
-		runningPrompt;
-		resolveRunningPrompt;
-		_thinkingBudgets;
-		_transport;
-		_maxRetryDelayMs;
-		_toolExecution;
-		_beforeToolExecution;
-		_afterToolExecution;
-		constructor(name, model, opts = {}) {
-			this._state = {
-				systemPrompt: "",
-				thinkingLevel: "off",
-				tools: [],
-				messages: [],
-				isStreaming: false,
-				streamMessage: null,
-				pendingToolCalls: /* @__PURE__ */ new Set(),
-				error: void 0,
-				...opts.initialState,
-				name,
-				model
-			};
-			/**
-			* Transformation logic to prepare messages for the LLM.
-			* * @remarks
-			* Currently just forwards messages as-is. Modify this logic when
-			* specific formatting or filtering is required.
-			* A good example is using user message parts with custom content
-			* * @default
-			* forwards messages as is.
-			*/
-			this.convertToLlm = opts.convertToLlm || ((messages) => messages);
-			this.transformContext = opts.transformContext;
-			this.steeringMode = opts.steeringMode || "one-at-a-time";
-			this.followUpMode = opts.followUpMode || "one-at-a-time";
-			this.streamFn = opts.streamFn || Stream.streamSimple;
-			this._sessionId = opts.sessionId;
-			this.getApiKey = opts.getApiKey;
-			this._onPayload = opts.onPayload;
-			this._thinkingBudgets = opts.thinkingBudgets;
-			this._transport = opts.transport ?? "sse";
-			this._maxRetryDelayMs = opts.maxRetryDelayMs;
-			this._toolExecution = opts.toolExecution ?? "parallel";
-			this._beforeToolExecution = opts.beforeToolExecution;
-			this._afterToolExecution = opts.afterToolExecution;
-		}
-		/**
-		* Get the current session ID used for provider caching.
-		*/
-		get sessionId() {
-			return this._sessionId;
-		}
-		/**
-		* Set the session ID for provider caching.
-		* Call this when switching sessions (new session, branch, resume, etc).
-		*/
-		set sessionId(value) {
-			this._sessionId = value;
-		}
-		/**
-		* Get the current thinking budgets.
-		*/
-		get thinkingBudgets() {
-			return this._thinkingBudgets;
-		}
-		/**
-		* Set custom thinking budgets for token-based providers.
-		*/
-		set thinkingBudgets(value) {
-			this._thinkingBudgets = value;
-		}
-		/**
-		* Get the current preferred transport.
-		*/
-		get transport() {
-			return this._transport;
-		}
-		/**
-		* Set the preferred transport.
-		*/
-		setTransport(value) {
-			this._transport = value;
-		}
-		/**
-		* Get the current max retry delay in milliseconds.
-		*/
-		get maxRetryDelayMs() {
-			return this._maxRetryDelayMs;
-		}
-		/**
-		* Set the maximum delay to wait for server-requested retries.
-		* Set to 0 to disable the cap.
-		*/
-		set maxRetryDelayMs(value) {
-			this._maxRetryDelayMs = value;
-		}
-		get toolExecution() {
-			return this._toolExecution;
-		}
-		setToolExecution(value) {
-			this._toolExecution = value;
-		}
-		setBeforeToolExecution(value) {
-			this._beforeToolExecution = value;
-		}
-		setAfterToolExecution(value) {
-			this._afterToolExecution = value;
-		}
-		get state() {
-			return this._state;
-		}
-		subscribe(fn) {
-			this.listeners.add(fn);
-			return () => this.listeners.delete(fn);
-		}
-		setSystemPrompt(v) {
-			this._state.systemPrompt = v;
-		}
-		setModel(m) {
-			this._state.model = m;
-		}
-		setThinkingLevel(l) {
-			this._state.thinkingLevel = l;
-		}
-		setSteeringMode(mode) {
-			this.steeringMode = mode;
-		}
-		getSteeringMode() {
-			return this.steeringMode;
-		}
-		setFollowUpMode(mode) {
-			this.followUpMode = mode;
-		}
-		getFollowUpMode() {
-			return this.followUpMode;
-		}
-		setTools(t) {
-			this._state.tools = t;
-		}
-		replaceMessages(ms) {
-			this._state.messages = ms.slice();
-		}
-		appendMessage(m) {
-			this._state.messages = [...this._state.messages, m];
-		}
-		findMessageIndexById(messageId) {
-			return this._state.messages.findIndex((message) => message.messageId === messageId);
-		}
-		replaceMessageById(message) {
-			const messageIndex = this.findMessageIndexById(message.messageId);
-			if (messageIndex === -1) return false;
-			const messages = this._state.messages.slice();
-			messages[messageIndex] = message;
-			this._state.messages = messages;
-			return true;
-		}
-		upsertMessage(message) {
-			if (this.replaceMessageById(message)) return;
-			this.appendMessage(message);
-		}
-		patchStoredAssistantPart(messageId, partIndex, part) {
-			const messageIndex = this.findMessageIndexById(messageId);
-			if (messageIndex === -1) return false;
-			const messages = this._state.messages.slice();
-			const existing = messages[messageIndex];
-			if (!existing || existing.role !== "assistant") return false;
-			const nextParts = existing.parts.slice();
-			nextParts[partIndex] = part;
-			messages[messageIndex] = {
-				...existing,
-				parts: nextParts
-			};
-			this._state.messages = messages;
-			return true;
-		}
-		/**
-		* Queue a steering message while the agent is running.
-		* Delivered after the current assistant turn finishes executing its tool calls,
-		* before the next LLM call.
-		*/
-		steer(m) {
-			this.steeringQueue.push(m);
-		}
-		/**
-		* Queue a follow-up message to be processed after the agent finishes.
-		* Delivered only when agent has no more tool calls or steering messages.
-		*/
-		followUp(m) {
-			this.followUpQueue.push(m);
-		}
-		clearSteeringQueue() {
-			this.steeringQueue = [];
-		}
-		clearFollowUpQueue() {
-			this.followUpQueue = [];
-		}
-		clearAllQueues() {
-			this.steeringQueue = [];
-			this.followUpQueue = [];
-		}
-		hasQueuedMessages() {
-			return this.steeringQueue.length > 0 || this.followUpQueue.length > 0;
-		}
-		dequeueSteeringMessages() {
-			if (this.steeringMode === "one-at-a-time") {
-				if (this.steeringQueue.length > 0) {
-					const first = this.steeringQueue[0];
-					this.steeringQueue = this.steeringQueue.slice(1);
-					return [first];
-				}
-				return [];
-			}
-			const steering = this.steeringQueue.slice();
-			this.steeringQueue = [];
-			return steering;
-		}
-		dequeueFollowUpMessages() {
-			if (this.followUpMode === "one-at-a-time") {
-				if (this.followUpQueue.length > 0) {
-					const first = this.followUpQueue[0];
-					this.followUpQueue = this.followUpQueue.slice(1);
-					return [first];
-				}
-				return [];
-			}
-			const followUp = this.followUpQueue.slice();
-			this.followUpQueue = [];
-			return followUp;
-		}
-		clearMessages() {
-			this._state.messages = [];
-		}
-		abort() {
-			this.abortController?.abort();
-		}
-		waitForIdle() {
-			return this.runningPrompt ?? Promise.resolve();
-		}
-		reset() {
-			this._state.messages = [];
-			this._state.isStreaming = false;
-			this._state.streamMessage = null;
-			this._state.pendingToolCalls = /* @__PURE__ */ new Set();
-			this._state.error = void 0;
-			this.steeringQueue = [];
-			this.followUpQueue = [];
-		}
-		getName() {
-			return this._state.name;
-		}
-		ensureIdle() {
-			if (this._state.isStreaming) throw new AgentInStreamingErr({
-				message: "agent is already processing a prompt. Use steer() or followup() to queue messages, or wait for completion.",
-				name: this._state.name
-			});
-		}
-		async _runLoop(messages, opts) {
-			const model = this._state.model;
-			if (!model) throw new ModelNotConfiguredErr({ message: "no model configured yet" });
-			this.runningPrompt = new Promise((resolve) => {
-				this.resolveRunningPrompt = resolve;
-			});
-			this.abortController = new AbortController();
-			this._state.isStreaming = true;
-			this._state.streamMessage = null;
-			this._state.error = void 0;
-			const reasoning = this.state.thinkingLevel === "off" ? void 0 : this._state.thinkingLevel;
-			const context = {
-				systemPrompt: this._state.systemPrompt,
-				messages: this._state.messages.slice(),
-				tools: this._state.tools
-			};
-			let skipInitialSteeringPoll = opts?.skipInitialSteeringPoll === true;
-			const config = {
-				model,
-				reasoning,
-				sessionId: this._sessionId,
-				onPayload: this._onPayload,
-				transport: this._transport,
-				thinkingBudgets: this._thinkingBudgets,
-				maxRetryDelayMs: this._maxRetryDelayMs,
-				toolExecution: this._toolExecution,
-				beforeToolExecution: this._beforeToolExecution,
-				afterToolExecution: this._afterToolExecution,
-				convertToLlm: this.convertToLlm,
-				transformContext: this.transformContext,
-				getApiKey: this.getApiKey,
-				getSteeringMessages: async () => {
-					if (skipInitialSteeringPoll) {
-						skipInitialSteeringPoll = false;
-						return [];
-					}
-					return this.dequeueSteeringMessages();
-				},
-				getFollowUpMessages: async () => this.dequeueFollowUpMessages()
-			};
-			try {
-				if (messages) await Loop.runAgentLoop(config, context, messages, async (e) => this._processLoopEvent(e), this.streamFn, this.abortController.signal);
-				else await Loop.runAgentLoopContinue(config, context, async (e) => this._processLoopEvent(e), this.streamFn, this.abortController.signal);
-			} catch (err) {
-				const message = Message.createAssistantMessage({
-					role: "assistant",
-					protocol: model.protocol,
-					provider: model.provider,
-					model: model.id,
-					usage: {
-						input: 0,
-						output: 0,
-						cacheRead: 0,
-						cacheWrite: 0,
-						totalTokens: 0,
-						cost: {
-							input: 0,
-							output: 0,
-							cacheRead: 0,
-							cacheWrite: 0,
-							total: 0
-						}
-					},
-					stopReason: this.abortController.signal.aborted ? "aborted" : "error",
-					errorMessage: err?.message || String(err),
-					time: {
-						created: Date.now(),
-						completed: Date.now()
-					},
-					parts: []
-				});
-				this.appendMessage(message);
-				this._state.error = err?.message || String(err);
-				this.emit({
-					type: "agent.end",
-					messages: [message]
-				});
-			} finally {
-				this._state.isStreaming = false;
-				this._state.streamMessage = null;
-				this._state.pendingToolCalls = /* @__PURE__ */ new Set();
-				this.abortController = void 0;
-				this.resolveRunningPrompt?.();
-				this.runningPrompt = void 0;
-				this.resolveRunningPrompt = void 0;
-			}
-		}
-		async loop(messages) {
-			this.ensureIdle();
-			await this._runLoop(messages);
-		}
-		async loopContinue() {
-			this.ensureIdle();
-			await this._runLoop();
-		}
-		async prompt(messages, images) {
-			this.ensureIdle();
-			if (!this._state.model) throw new ModelNotConfiguredErr({ message: "no model configured yet." });
-			const message = Message.createUserMessage({
-				role: "user",
-				time: { created: Date.now() },
-				parts: [...messages, ...images ?? []]
-			});
-			await this.loop([message]);
-		}
-		_processLoopEvent(event) {
-			switch (event.type) {
-				case "message.start":
-					this._state.streamMessage = event.message;
-					break;
-				case "message.part.start":
-				case "message.part.update":
-				case "message.part.end":
-					this._state.streamMessage = event.message;
-					if (event.message.role === "assistant") this.patchStoredAssistantPart(event.message.messageId, event.partIndex, event.part);
-					break;
-				case "message.update":
-					this._state.streamMessage = event.message;
-					this.replaceMessageById(event.message);
-					break;
-				case "message.end":
-					this._state.streamMessage = null;
-					this.upsertMessage(event.message);
-					break;
-				case "tool.execution.start": {
-					const pendingToolCalls = new Set(this._state.pendingToolCalls);
-					pendingToolCalls.add(event.callID);
-					this._state.pendingToolCalls = pendingToolCalls;
-					break;
-				}
-				case "tool.execution.end": {
-					const pendingToolCalls = new Set(this._state.pendingToolCalls);
-					pendingToolCalls.delete(event.callID);
-					this._state.pendingToolCalls = pendingToolCalls;
-					break;
-				}
-				case "turn.end":
-					if (event.message.role === "assistant" && event.message.parts.length > 0) this._state.error = event.message.errorMessage;
-					break;
-				case "agent.end":
-					this._state.isStreaming = false;
-					this._state.streamMessage = null;
-					break;
-			}
-			this.emit(event);
-		}
-		emit(e) {
-			for (const listener of this.listeners) listener(e);
-		}
-	}
-	_Agent.Instance = Instance;
-	async function create(options) {
-		let resolvedModel;
-		if ("provider" in options) {
-			const result = await Model.getModel(options.provider, options.model);
-			if (!result) throw new ModelNotFoundErr({
-				message: "model not found or not configured yet",
-				provider: options.provider,
-				model: options.model
-			});
-			resolvedModel = result;
-		} else resolvedModel = options.model;
-		return new Instance(options.name ?? "main", resolvedModel, options);
-	}
-	_Agent.create = create;
-})(Agent || (Agent = {}));
 //#endregion
-//#region src/agent/codemode/codemode.ts
-let CodeMode;
-(function(_CodeMode) {
-	const ToolDefinitionErr = _CodeMode.ToolDefinitionErr = NamedError.create("ToolDefinitionErr", Type.Object({ message: Type.String() }));
-	const toolFnPrefix = process.env.CODEWORK_CODEMODE_FN_PREFIX ?? "external_";
-	const SandboxExecutionInputSchema = _CodeMode.SandboxExecutionInputSchema = Type.Object({ typescriptCode: Type.String({ description: "TypeScript code to execute in the sandbox." }) });
-	const SandboxExecutionOutputSchema = _CodeMode.SandboxExecutionOutputSchema = Type.Object({
-		result: Type.Optional(Type.Unknown()),
-		logs: Type.Optional(Type.Array(Type.String()))
-	});
-	const SandboxExecutionErrorSchema = _CodeMode.SandboxExecutionErrorSchema = Type.Object({
-		message: Type.String(),
-		name: Type.Optional(Type.String()),
-		stack: Type.Optional(Type.String()),
-		line: Type.Optional(Type.Number()),
-		logs: Type.Optional(Type.Array(Type.String()))
-	});
-	function withMessageInStack(message, stack) {
-		if (!stack) return void 0;
-		return stack.includes(message) ? stack : `${message}\n${stack}`;
-	}
-	function normalizeExecutionError(error) {
-		if (error instanceof Error) return {
-			name: error.name,
-			message: error.message,
-			stack: withMessageInStack(error.message, error.stack),
-			line: parseErrorLine(error.stack)
-		};
-		if (typeof error === "object" && error !== null) {
-			const candidate = error;
-			return {
-				name: typeof candidate.name === "string" ? candidate.name : void 0,
-				message: typeof candidate.message === "string" ? candidate.message : JSON.stringify(candidate) || "Unknown execution error",
-				stack: typeof candidate.stack === "string" ? withMessageInStack(typeof candidate.message === "string" ? candidate.message : JSON.stringify(candidate) || "Unknown execution error", candidate.stack) : void 0,
-				line: typeof candidate.line === "number" ? candidate.line : parseErrorLine(candidate.stack)
-			};
-		}
-		return {
-			name: "Error",
-			message: String(error)
-		};
-	}
-	function parseErrorLine(stack) {
-		if (typeof stack !== "string") return void 0;
-		const lineMatch = stack.match(/:(\d+)(?::\d+)?\)?$/m);
-		return lineMatch ? Number(lineMatch[1]) : void 0;
-	}
-	function serializeForContent(value) {
-		return JSON.stringify(value, (_key, currentValue) => typeof currentValue === "bigint" ? currentValue.toString() : currentValue, 2);
-	}
-	function toolContentToText(result) {
-		return result.content.filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n").trim();
-	}
-	function unwrapToolResult(tool, result) {
-		if (result.status === "completed") {
-			if (tool.outputSchema) return validateSchema(tool.outputSchema, result.result.details, `Tool "${tool.name}" output`);
-			return result.result.details;
-		}
-		if (tool.errorSchema && result.result.details !== void 0) validateSchema(tool.errorSchema, result.result.details, `Tool "${tool.name}" error`);
-		const message = toolContentToText(result.result) || `Tool "${tool.name}" failed`;
-		const error = new Error(message);
-		if (result.result.details !== void 0) error.cause = result.result.details;
-		throw error;
-	}
-	function toolToBinding(tool, prefix = "") {
-		const inputSchema = TypeGuard.IsSchema(tool.parameters) ? tool.parameters : Type.Object({});
-		const outputSchema = TypeGuard.IsSchema(tool.outputSchema) ? tool.outputSchema : void 0;
-		const errorSchema = TypeGuard.IsSchema(tool.errorSchema) ? tool.errorSchema : void 0;
-		if (!("execute" in tool) || typeof tool.execute !== "function") throw new ToolDefinitionErr({ message: `tool "${tool.name}" does not have an execute function. code mode requires tools with implementation` });
-		return {
-			name: `${prefix}${tool.name}`,
-			description: tool.description,
-			inputSchema,
-			outputSchema,
-			errorSchema,
-			execute: async (callID, params, signal) => {
-				const validatedParams = validateSchema(inputSchema, params, `Tool "${tool.name}" input`);
-				return unwrapToolResult(tool, await tool.execute(callID, validatedParams, signal));
-			}
-		};
-	}
-	function toolsForBinding(tools, prefix) {
-		const bindings = {};
-		for (const tool of tools) {
-			const name = `${prefix}${tool.name}`;
-			bindings[name] = toolToBinding(tool, prefix);
-		}
-		return bindings;
-	}
-	function indent(value, depth = 1) {
-		const prefix = "	".repeat(depth);
-		return value.split("\n").map((line) => `${prefix}${line}`).join("\n");
-	}
-	function toPropertyKey(name) {
-		return /^[$A-Z_a-z][$\w]*$/i.test(name) ? name : JSON.stringify(name);
-	}
-	function schemaToTypeScript(schema) {
-		if (TypeGuard.IsAny(schema)) return "any";
-		if (TypeGuard.IsUnknown(schema)) return "unknown";
-		if (TypeGuard.IsString(schema)) return "string";
-		if (TypeGuard.IsNumber(schema) || TypeGuard.IsInteger(schema)) return "number";
-		if (TypeGuard.IsBoolean(schema)) return "boolean";
-		if (TypeGuard.IsNull(schema)) return "null";
-		if (TypeGuard.IsUndefined(schema) || TypeGuard.IsVoid(schema)) return "undefined";
-		if (TypeGuard.IsLiteral(schema)) return JSON.stringify(schema.const);
-		if (TypeGuard.IsArray(schema)) return `Array<${schemaToTypeScript(schema.items)}>`;
-		if (TypeGuard.IsTuple(schema)) return `[${(schema.items ?? []).map((item) => schemaToTypeScript(item)).join(", ")}]`;
-		if (TypeGuard.IsUnion(schema)) return schema.anyOf.map((item) => schemaToTypeScript(item)).join(" | ");
-		if (TypeGuard.IsIntersect(schema)) return schema.allOf.map((item) => schemaToTypeScript(item)).join(" & ");
-		if (TypeGuard.IsRecord(schema)) return `Record<string, ${schemaToTypeScript(Object.values(schema.patternProperties ?? {}).find(TypeGuard.IsSchema) ?? (schema.additionalProperties && TypeGuard.IsSchema(schema.additionalProperties) ? schema.additionalProperties : Type.Unknown()))}>`;
-		if (TypeGuard.IsObject(schema)) {
-			const required = new Set(schema.required ?? []);
-			const properties = Object.entries(schema.properties ?? {}).map(([key, value]) => {
-				const optional = required.has(key) ? "" : "?";
-				return `${toPropertyKey(key)}${optional}: ${schemaToTypeScript(value)};`;
-			});
-			if (schema.additionalProperties === true) properties.push("[key: string]: unknown;");
-			else if (schema.additionalProperties && TypeGuard.IsSchema(schema.additionalProperties)) properties.push(`[key: string]: ${schemaToTypeScript(schema.additionalProperties)};`);
-			if (properties.length === 0) return "{}";
-			return `{\n${indent(properties.join("\n"))}\n}`;
-		}
-		return "unknown";
-	}
-	function generateTypeStubs(bindings, options = {}) {
-		const { includeDescriptions = true } = options;
-		const declarations = [];
-		for (const [name, binding] of Object.entries(bindings)) {
-			const inputTypeName = `${capitalize(name)}Input`;
-			const outputTypeName = `${capitalize(name)}Output`;
-			declarations.push(`type ${inputTypeName} = ${schemaToTypeScript(binding.inputSchema)};`);
-			let outputTypeRef = "unknown";
-			if (binding.outputSchema !== void 0) {
-				declarations.push(`type ${outputTypeName} = ${schemaToTypeScript(binding.outputSchema)};`);
-				outputTypeRef = outputTypeName;
-			}
-			const description = includeDescriptions && binding.description ? `/** ${binding.description} */\n` : "";
-			declarations.push(`${description}declare function ${name}(input: ${inputTypeName}): Promise<${outputTypeRef}>;`);
-		}
-		return declarations.join("\n\n");
-	}
-	_CodeMode.generateTypeStubs = generateTypeStubs;
-	function buildExampleSnippet() {
-		return [
-			"```typescript",
-			"const numbers = [12, 24, 36];",
-			"const total = numbers.reduce((sum, value) => sum + value, 0);",
-			"",
-			"return {",
-			"  count: numbers.length,",
-			"  average: total / numbers.length,",
-			"};",
-			"```"
-		];
-	}
-	function generateSystemPrompt(config) {
-		const fnPrefix = config.fnPrefix ?? toolFnPrefix;
-		const bindings = toolsForBinding(config.tools, fnPrefix);
-		const typeStubs = generateTypeStubs(bindings);
-		return [
-			"## Code Execution Tool",
-			"",
-			"You have access to `sandbox_execute_typescript` which runs TypeScript code in a sandboxed environment.",
-			"",
-			"### When to Use",
-			"",
-			"Use `sandbox_execute_typescript` when you need to:",
-			"- Process data with loops, conditionals, or complex logic",
-			"- Make multiple tool calls in parallel with `Promise.all(...)`",
-			"- Transform, filter, or aggregate data",
-			"- Perform calculations or data analysis",
-			"",
-			"For simple operations, prefer calling tools directly.",
-			"",
-			"### Available External APIs",
-			"",
-			"Inside your TypeScript code, you can call these async functions:",
-			"",
-			Object.entries(bindings).map(([name, binding]) => `- \`${name}(input)\`: ${binding.description}`).join("\n") || "- No external APIs available for this run.",
-			"",
-			"### Type Definitions",
-			"",
-			"```typescript",
-			typeStubs,
-			"```",
-			"",
-			"### Example",
-			"",
-			...buildExampleSnippet(),
-			"",
-			"### Important Notes",
-			"",
-			`- All\`${fnPrefix}\`*calls are async, so always use \`await\``,
-			"- Return a value to pass results back to you",
-			"- Use `console.log()` for debugging (logs are captured)",
-			"- The sandbox is isolated - no network access or file system",
-			"- Each execution is isolated and does not share state with previous runs",
-			""
-		].join("\n");
-	}
-	_CodeMode.generateSystemPrompt = generateSystemPrompt;
-	async function transpileTypeScript(typescriptCode) {
-		return (await transform([
-			"(async () => {",
-			"	const __codemodeNormalizeError = (error: unknown) => {",
-			"		if (error instanceof Error) return { name: error.name, message: error.message, stack: error.stack };",
-			"		if (typeof error === 'object' && error !== null) {",
-			"			const candidate = error as { name?: unknown; message?: unknown; stack?: unknown };",
-			"			return {",
-			"				name: typeof candidate.name === 'string' ? candidate.name : 'Error',",
-			"				message:",
-			"					typeof candidate.message === 'string'",
-			"						? candidate.message",
-			"						: JSON.stringify(candidate) || 'Unknown execution error',",
-			"				stack: typeof candidate.stack === 'string' ? candidate.stack : undefined,",
-			"			};",
-			"		}",
-			"		return { name: 'Error', message: String(error) };",
-			"	};",
-			"	try {",
-			typescriptCode,
-			"	} catch (error) {",
-			"		throw __codemodeNormalizeError(error);",
-			"	}",
-			"})()"
-		].join("\n"), {
-			loader: "ts",
-			target: "es2022",
-			sourcefile: "script.ts",
-			minify: false,
-			keepNames: false
-		})).code;
-	}
-	function buildToolDescription(tools, fnPrefix = toolFnPrefix) {
-		return [
-			"Execute TypeScript code in a secure sandbox environment. ",
-			"The code can use these external API functions:",
-			"<functions>",
-			` ${tools.map((tool) => `${fnPrefix}${tool.name}`).join("\n")}`,
-			"</functions>",
-			`All ${fnPrefix}* calls are async and must be awaited. `,
-			"Return a value to pass results back. Use console.log() for debugging."
-		].join("\n");
-	}
-	function createCodeModeTool(config) {
-		if (config.tools.length === 0) throw new ToolDefinitionErr({ message: "at least one tool must be provided to `createCodeModeTool`" });
-		return Agent.defineTool({
-			name: "sandbox_execute_typescript",
-			label: "Sandbox TypeScript",
-			description: buildToolDescription(config.tools, config.fnPrefix),
-			parameters: SandboxExecutionInputSchema,
-			outputSchema: SandboxExecutionOutputSchema,
-			errorSchema: SandboxExecutionErrorSchema,
-			async execute(_callID, params, signal, onUpdate) {
-				const bindings = toolsForBinding(config.tools, config.fnPrefix ?? toolFnPrefix);
-				let context;
-				try {
-					await onUpdate?.({
-						status: "running",
-						partial: { content: [{
-							type: "text",
-							text: "Transpiling TypeScript for sandbox execution"
-						}] }
-					});
-					const javascriptCode = await transpileTypeScript(params.typescriptCode);
-					await onUpdate?.({
-						status: "running",
-						partial: { content: [{
-							type: "text",
-							text: "Executing code in sandbox runtime"
-						}] }
-					});
-					context = await config.driver.createContext({
-						bindings,
-						timeout: config.timeout,
-						memoryLimit: config.memoryLimit,
-						signal
-					});
-					const executionResult = await context.execute(javascriptCode);
-					if (executionResult.success) {
-						const details = {
-							result: executionResult.value,
-							...executionResult.logs && executionResult.logs.length > 0 ? { logs: executionResult.logs } : {}
-						};
-						return {
-							status: "completed",
-							result: {
-								content: [{
-									type: "text",
-									text: serializeForContent(details)
-								}],
-								details,
-								isError: false
-							}
-						};
-					}
-					const details = {
-						message: executionResult.error?.message || "sandbox execution failed",
-						...executionResult.error?.name ? { name: executionResult.error.name } : {},
-						...executionResult.error?.stack ? { stack: executionResult.error.stack } : {},
-						...executionResult.error?.line != null ? { line: executionResult.error.line } : {},
-						...executionResult.logs && executionResult.logs.length > 0 ? { logs: executionResult.logs } : {}
-					};
-					return {
-						status: "error",
-						result: {
-							content: [{
-								type: "text",
-								text: serializeForContent(details)
-							}],
-							details,
-							isError: true
-						}
-					};
-				} catch (error) {
-					const normalizedError = normalizeExecutionError(error);
-					const details = {
-						message: normalizedError.message,
-						...normalizedError.name ? { name: normalizedError.name } : {},
-						...normalizedError.stack ? { stack: normalizedError.stack } : {},
-						...normalizedError.line != null ? { line: normalizedError.line } : {}
-					};
-					return {
-						status: "error",
-						result: {
-							content: [{
-								type: "text",
-								text: serializeForContent(details)
-							}],
-							details,
-							isError: true
-						}
-					};
-				} finally {
-					await context?.dispose();
-				}
-			}
-		});
-	}
-	_CodeMode.createCodeModeTool = createCodeModeTool;
-	async function create(config) {
-		return {
-			tool: createCodeModeTool(config),
-			systemPrompt: generateSystemPrompt(config)
-		};
-	}
-	_CodeMode.create = create;
-})(CodeMode || (CodeMode = {}));
-//#endregion
-//#region src/llm.ts
-const llmImpl = async (provider, model, overrides) => Model.getModel(provider, model, overrides);
-const llm = Object.assign(llmImpl, {
-	model: Model.getModel,
-	models: Model.getModels,
-	providers: Model.getProviders,
-	registry: Model.registry,
-	supportsXhigh: Model.supportsXhigh,
-	modelsAreEqual: Model.modelsAreEqual
-});
+//#region src/llm/register.ts
+registerAISDKProtocols();
 //#endregion
 //#region src/stream.ts
-const streamImpl = (model, context, options) => Stream.stream(model, context, options);
+const streamImpl = (model, context, options) => Protocol.stream(model, context, options);
 /**
 * Start a streaming assistant response for a model/context pair.
 *
@@ -3362,20 +1414,65 @@ const streamImpl = (model, context, options) => Stream.stream(model, context, op
 * Attached helpers:
 *
 * - `stream.complete(...)` resolves the final assistant message without manually iterating events.
-* - `stream.simple(...)` uses `Stream.SimpleOptions` for higher-level reasoning controls.
-* - `stream.completeSimple(...)` is the non-streaming counterpart to `stream.simple(...)`.
 * - `stream.resolveProtocolProvider(...)` exposes protocol resolution for advanced integrations.
 */
 const stream = Object.assign(streamImpl, {
-	complete: Stream.complete,
-	simple: Stream.streamSimple,
-	completeSimple: Stream.completeSimple,
-	resolveProtocolProvider: Stream.resolveProtocolProvider
+	complete: Protocol.complete,
+	resolveProtocolProvider: Protocol.resolveProtocolProvider
 });
-Stream.complete;
-Stream.streamSimple;
-Stream.completeSimple;
+Protocol.complete;
+//#endregion
+//#region src/utils/validation.ts
+const validators = /* @__PURE__ */ new WeakMap();
+function getValidator(schema) {
+	const existing = validators.get(schema);
+	if (existing) return existing;
+	const validator = Schema.Compile(schema);
+	validators.set(schema, validator);
+	return validator;
+}
+function errorPath(error) {
+	if (error.instancePath) return error.instancePath.substring(1);
+	const requiredProperties = error.params?.requiredProperties;
+	if (Array.isArray(requiredProperties)) return requiredProperties.join(", ");
+	return "root";
+}
+/**
+* Validates an arbitrary value against a TypeBox schema and returns the coerced value.
+*/
+function validateSchema(schema, value, label) {
+	const validator = getValidator(schema);
+	const input = Value.Convert(schema, structuredClone(value));
+	try {
+		return validator.Parse(input);
+	} catch {
+		const [_result, validationErrors] = validator.Errors(input);
+		const errors = validationErrors.map((err) => {
+			return ` - ${errorPath(err)}: ${err.message}`;
+		}).join("\n") || "Unknown Validation Error";
+		throw new Error([
+			`Validation Failed For ${label}`,
+			`${errors}\n`,
+			"Received Value:",
+			`${JSON.stringify(value, null, 2)}\n`
+		].join("\n"));
+	}
+}
+/**
+* Finds a tool by name and validates the tool call arguments against its TypeBox schema
+*/
+function validateToolCall(tools, toolExecution) {
+	const tool = tools.find((t) => t.name === toolExecution.name);
+	if (!tool) throw new Error(`Tool "${toolExecution.name}" not found`);
+	return validateToolArguments(tool, toolExecution);
+}
+/**
+* Validates tool call arguments against the tool's TypeBox schema
+*/
+function validateToolArguments(tool, toolExecution) {
+	return validateSchema(tool.parameters, toolExecution.rawArgs, `Tool "${toolExecution.name}"`);
+}
 //#endregion
-export { Agent, CodeMode, Message, agent, llm, stream };
+export { Event, EventStream, Message, Model, Protocol, ThinkingBudgets, Type, createAssistantMessageEventStream, llm, stream, validateSchema, validateToolArguments, validateToolCall };
 
 //# sourceMappingURL=index.mjs.map