@codeworksh/aikit 0.4.0 → 0.4.1-dev.20260530133433

package/index.mjs

@@ -0,0 +1,1478 @@
+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 Value from "typebox/value";
+import { jsonSchema, streamText } from "ai";
+import { parse } from "partial-json";
+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())
+	});
+	const ImageContentSchema = _Message.ImageContentSchema = Type$1.Object({
+		type: Type$1.Literal("image"),
+		data: Type$1.String(),
+		mimeType: Type$1.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())
+	});
+	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()
+		})
+	});
+	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)
+	});
+	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"
+	};
+	const ToolRunningSchema = _Message.ToolRunningSchema = Type$1.Object({
+		status: Type$1.Literal(ToolStatusEnum.running),
+		partial: Type$1.Optional(ToolRunningPartial)
+	});
+	const ToolCompletedSchema = _Message.ToolCompletedSchema = Type$1.Object({
+		status: Type$1.Literal(ToolStatusEnum.completed),
+		result: ToolSuccessResult
+	});
+	const ToolErrorSchema = _Message.ToolErrorSchema = Type$1.Object({
+		status: Type$1.Literal(ToolStatusEnum.error),
+		result: ToolErrorResult
+	});
+	const ToolSkippedSchema = _Message.ToolSkippedSchema = Type$1.Object({
+		status: Type$1.Literal(ToolStatusEnum.skipped),
+		result: ToolErrorResult
+	});
+	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 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();
+	}
+	_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$1.Object({
+		name: Type$1.String(),
+		description: Type$1.String(),
+		parameters: Type$1.Unsafe({})
+	});
+	function defineTool(tool) {
+		return tool;
+	}
+	_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 syntheticSkippedToolCall(toolCall) {
+		const { status: _status, partial: _partial, ...base } = toolCall;
+		return {
+			...base,
+			status: ToolStatusEnum.skipped,
+			result: {
+				content: [{
+					type: "text",
+					text: "No result provided"
+				}],
+				isError: true
+			},
+			time: {
+				...toolCall.time,
+				end: Math.max(toolCall.time.end, Date.now())
+			}
+		};
+	}
+	function transformMessages(messages, model, normalizeToolCallId) {
+		const toolCallIDMap = /* @__PURE__ */ new Map();
+		const transformed = [];
+		for (const msg of messages) {
+			if (msg.role === "user") {
+				transformed.push(msg);
+				continue;
+			}
+			const assistantMsg = msg;
+			const isSameModel = assistantMsg.provider.id === model.provider.id && assistantMsg.protocol === model.protocol && assistantMsg.model === model.id;
+			const parts = assistantMsg.parts.flatMap((block) => {
+				if (block.type === "thinking") {
+					if (isSameModel && block.thinkingSignature) return block;
+					if (!block.thinking || block.thinking.trim() === "") return [];
+					if (isSameModel) return block;
+					return {
+						type: "text",
+						text: block.thinking
+					};
+				}
+				if (block.type === "text") {
+					if (isSameModel) return block;
+					return {
+						type: "text",
+						text: block.text
+					};
+				}
+				if (block.type === "toolCall") {
+					const toolCall = block;
+					let normalizedToolCall = toolCall;
+					if (!isSameModel && toolCall.thoughtSignature) {
+						normalizedToolCall = { ...toolCall };
+						delete normalizedToolCall.thoughtSignature;
+					}
+					const normalizedID = toolCallIDMap.get(block.callID);
+					if (normalizedID && normalizedID !== block.callID) normalizedToolCall = {
+						...normalizedToolCall,
+						callID: normalizedID
+					};
+					else if (!isSameModel && normalizeToolCallId) {
+						const nextID = normalizeToolCallId(toolCall.callID, model, assistantMsg);
+						if (nextID !== toolCall.callID) {
+							toolCallIDMap.set(toolCall.callID, nextID);
+							normalizedToolCall = {
+								...normalizedToolCall,
+								callID: nextID
+							};
+						}
+					}
+					return normalizedToolCall;
+				}
+				return block;
+			}).map((block) => {
+				if (block.type === "toolCall" && isUnresolvedToolCall(block)) return syntheticSkippedToolCall(block);
+				return block;
+			});
+			transformed.push({
+				...assistantMsg,
+				parts
+			});
+		}
+		return transformed;
+	}
+	_Message.transformMessages = transformMessages;
+})(Message || (Message = {}));
+//#endregion
+//#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"
+	};
+	_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 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 UserMessagePartStart = Type$1.Object({
+		type: Type$1.Literal(AgentEventType.messagePartStart),
+		message: Message.UserMessageSchema,
+		partIndex: Type$1.Number(),
+		part: UserMessagePart
+	});
+	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({
+				actual: model.protocol,
+				expected: protocol
+			});
+			return stream(model, context, options);
+		};
+	}
+	function registerProtocolProvider(provider, sourceId) {
+		const registered = {
+			protocol: provider.protocol,
+			stream: wrapStream(provider.protocol, provider.stream)
+		};
+		protocolRegistry.set(provider.protocol, {
+			provider: registered,
+			sourceId
+		});
+	}
+	_Protocol.registerProtocolProvider = registerProtocolProvider;
+	function getProtocolProvider(protocol) {
+		return protocolRegistry.get(protocol)?.provider;
+	}
+	_Protocol.getProtocolProvider = getProtocolProvider;
+	function resolveProtocolProvider(model) {
+		const provider = getProtocolProvider(model.protocol);
+		if (!provider) throw new ProviderProtocolNotFoundError({ protocol: model.protocol });
+		return provider;
+	}
+	_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);
+	}
+	_Protocol.stream = stream;
+	async function complete(model, context, options) {
+		return stream(model, context, options).result();
+	}
+	_Protocol.complete = complete;
+	function unregisterProtocolProviders(sourceId) {
+		for (const [protocol, entry] of protocolRegistry.entries()) if (entry.sourceId === sourceId) protocolRegistry.delete(protocol);
+	}
+	_Protocol.unregisterProtocolProviders = unregisterProtocolProviders;
+	function clearProtocolProviders() {
+		protocolRegistry.clear();
+	}
+	_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 {
+	queue = [];
+	waiting = [];
+	done = false;
+	finalResultPromise;
+	resolveFinalResult;
+	constructor(isComplete, extractResult) {
+		this.isComplete = isComplete;
+		this.extractResult = extractResult;
+		this.finalResultPromise = new Promise((resolve) => {
+			this.resolveFinalResult = resolve;
+		});
+	}
+	push(event) {
+		if (this.done) return;
+		if (this.isComplete(event)) {
+			this.done = true;
+			this.resolveFinalResult(this.extractResult(event));
+		}
+		const waiter = this.waiting.shift();
+		if (waiter) waiter({
+			value: event,
+			done: false
+		});
+		else this.queue.push(event);
+	}
+	end(result) {
+		this.done = true;
+		if (result !== void 0) this.resolveFinalResult(result);
+		while (this.waiting.length > 0) this.waiting.shift()({
+			value: void 0,
+			done: true
+		});
+	}
+	async *[Symbol.asyncIterator]() {
+		while (true) if (this.queue.length > 0) yield this.queue.shift();
+		else if (this.done) return;
+		else {
+			const result = await new Promise((resolve) => this.waiting.push(resolve));
+			if (result.done) return;
+			yield result.value;
+		}
+	}
+	result() {
+		return this.finalResultPromise;
+	}
+};
+var AssistantMessageEventStream = class extends EventStream {
+	constructor() {
+		super((event) => event.type === "done" || event.type === "error", (event) => {
+			if (event.type === "done") return event.message;
+			else if (event.type === "error") return event.error;
+			throw new Error("Unexpected event type for final result");
+		});
+	}
+};
+/** Factory function for AssistantMessageEventStream (for use in extensions) */
+function createAssistantMessageEventStream() {
+	return new AssistantMessageEventStream();
+}
+//#endregion
+//#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;
+	}
+}
+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);
+	}
+}
+//#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"
+		});
+		factoryOptions.name ??= model.provider.id;
+		factoryOptions.includeUsage ??= true;
+	}
+	return resolveLanguageModel(createProvider(factoryOptions), model, options.method);
+}
+//#endregion
+//#region src/utils/jsonparse.ts
+/**
+* @description Helper function to parse partial jsons during LLM streaming.
+*/
+/**
+* Attempts to parse potentially incomplete JSON during streaming.
+* Always returns a valid object, even if the JSON is incomplete.
+*
+* @param partialJson The partial JSON string from streaming
+* @returns Parsed object or empty object if parsing fails
+*/
+function parseStreamingJson(partialJson) {
+	if (!partialJson || partialJson.trim() === "") return {};
+	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 {
+			return {};
+		}
+	}
+}
+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
+/**
+* Removes unpaired Unicode surrogate characters from a string.
+*
+* Unpaired surrogates (high surrogates 0xD800-0xDBFF without matching low surrogates 0xDC00-0xDFFF,
+* or vice versa) cause JSON serialization errors in many API providers.
+*
+* Valid emoji and other characters outside the Basic Multilingual Plane use properly paired
+* surrogates and will NOT be affected by this function.
+*
+* @param text - The text to sanitize
+* @returns The sanitized text with unpaired surrogates removed
+*
+* @example
+* // Valid emoji (properly paired surrogates) are preserved
+* sanitizeSurrogates("Hello 🙈 World") // => "Hello 🙈 World"
+*
+* // Unpaired high surrogate is removed
+* const unpaired = String.fromCharCode(0xD83D); // high surrogate without low
+* sanitizeSurrogates(`Text ${unpaired} here`) // => "Text  here"
+*/
+function sanitizeSurrogates(text) {
+	return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "");
+}
+//#endregion
+//#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()
+		}
+	});
+}
+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",
+			image: part.data,
+			mediaType: part.mimeType
+		});
+	}
+	if (content.length === 0) return [];
+	return [{
+		role: "user",
+		content
+	}];
+}
+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;
+	}
+	return value;
+}
+function sanitizeRecord(value) {
+	return sanitizeValue(value);
+}
+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: "content",
+		value: [...text.length > 0 ? [{
+			type: "text",
+			text
+		}] : [], ...images.map((image) => ({
+			type: "image-data",
+			data: image.data,
+			mediaType: image.mimeType
+		}))]
+	};
+}
+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 (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 (part.type !== "toolCall") continue;
+		assistantContent.push({
+			type: "tool-call",
+			toolCallId: part.callID,
+			toolName: part.name,
+			input: sanitizeRecord(part.arguments ?? {})
+		});
+		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"
+			}
+		});
+	}
+	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 messages;
+}
+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 mapFinishReason(reason) {
+	switch (reason) {
+		case "length": return "length";
+		case "tool-calls": return "toolUse";
+		case "content-filter":
+		case "error":
+		case "other": return "error";
+		default: return "stop";
+	}
+}
+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
+		}
+	};
+	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()
+		}
+	};
+}
+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
+			};
+		}
+	}
+	return result;
+}
+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: "text.delta",
+				partIndex: partIndex(output, block),
+				delta: part.text,
+				partial: output
+			});
+			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: "thinking.delta",
+				partIndex: partIndex(output, block),
+				delta: part.text,
+				partial: output
+			});
+			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: "toolcall.delta",
+				partIndex: partIndex(output, block),
+				delta: part.delta,
+				partial: output
+			});
+			break;
+		}
+		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));
+	}
+}
+/**
+* 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 stream$1 = (model, context, options) => {
+	const stream = new AssistantMessageEventStream();
+	const runtimeOptions = applyDefaultMaxTokens(model, options ?? {});
+	(async () => {
+		const output = createAssistantMessage(model);
+		try {
+			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
+			});
+			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({
+				type: "done",
+				reason: output.stopReason,
+				message: output
+			});
+			stream.end();
+		} catch (error) {
+			for (const block of output.parts) {
+				delete block.streamId;
+				delete block.streamId;
+				delete block.partialJson;
+			}
+			output.time.completed = Date.now();
+			output.stopReason = runtimeOptions.signal?.aborted || output.stopReason === "aborted" ? "aborted" : "error";
+			output.errorMessage = formatThrownError(error);
+			stream.push({
+				type: "error",
+				reason: output.stopReason,
+				error: output
+			});
+			stream.end();
+		}
+	})();
+	return stream;
+};
+//#endregion
+//#region src/llm/index.ts
+function createAISDKProtocol(protocol) {
+	return {
+		protocol,
+		stream: stream$1
+	};
+}
+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));
+}
+//#endregion
+//#region src/llm/register.ts
+registerAISDKProtocols();
+//#endregion
+//#region src/stream.ts
+const streamImpl = (model, context, options) => Protocol.stream(model, context, options);
+/**
+* Start a streaming assistant response for a model/context pair.
+*
+* This is the main streaming entrypoint.
+* Attached helpers:
+*
+* - `stream.complete(...)` resolves the final assistant message without manually iterating events.
+* - `stream.resolveProtocolProvider(...)` exposes protocol resolution for advanced integrations.
+*/
+const stream = Object.assign(streamImpl, {
+	complete: Protocol.complete,
+	resolveProtocolProvider: Protocol.resolveProtocolProvider
+});
+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 { Event, EventStream, Message, Model, Protocol, ThinkingBudgets, Type, createAssistantMessageEventStream, llm, stream, validateSchema, validateToolArguments, validateToolCall };
+
+//# sourceMappingURL=index.mjs.map