@codeworksh/aikit 0.6.0 → 0.7.1-dev.20260824182047

package/index.mjs

@@ -1,580 +1,673 @@
-import { d as NamedError, i as packageForModel, o as resolveLanguageModel, r as loadProviderFactory, s as Model } from "./registry-DUKrGxt4.mjs";
-import { n as createOpenAICodex, r as openaiCodex } from "./openai-codex-CZrBnLAJ.mjs";
-import Type$1, { Type, Type as Type$2 } from "typebox";
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { E as NamedError, _ as getProviders, c as APIMethodEnumSchema, d as KnownProviderEnumSchema, f as ProviderInfo, g as getModels, h as getModel, i as packageForModel, l as ActiveThinkingLevel, m as clampThinkingLevel, o as resolveLanguageModel, p as calculateCost, r as loadProviderFactory, u as KnownProviderEnum, v as model_exports, x as registry, y as modelsAreEqual } from "./registry-CMkIE_B4.mjs";
+import { g as shortHash, n as createOpenAICodex, r as openaiCodex, v as openAICodexTools, x as resolveOpenAICodexToolConstraint } from "./openai-codex-_3XkJ4bs.mjs";
+import Type$2, { Type, Type as Type$1 } from "typebox";
 import { uuidv7 } from "uuidv7";
 import Value from "typebox/value";
 import { jsonSchema, streamText } from "ai";
 import { parse } from "partial-json";
 import Schema from "typebox/schema";
 //#region src/message/message.ts
-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"
+var message_exports = /* @__PURE__ */ __exportAll({
+	AssistantMessageSchema: () => AssistantMessageSchema,
+	ConstrainedSamplingSchema: () => ConstrainedSamplingSchema,
+	ContextSchema: () => ContextSchema,
+	GrammarVariantsSchema: () => GrammarVariantsSchema,
+	ImageContentSchema: () => ImageContentSchema,
+	MessageSchema: () => MessageSchema,
+	StopReasonSchema: () => StopReasonSchema,
+	TextContentSchema: () => TextContentSchema,
+	ThinkingContentSchema: () => ThinkingContentSchema,
+	ToolAbortedSchema: () => ToolAbortedSchema,
+	ToolCallAbortedPartSchema: () => ToolCallAbortedPartSchema,
+	ToolCallBaseSchema: () => ToolCallBaseSchema,
+	ToolCallCompletedPartSchema: () => ToolCallCompletedPartSchema,
+	ToolCallErrorPartSchema: () => ToolCallErrorPartSchema,
+	ToolCallInFlightSchema: () => ToolCallInFlightSchema,
+	ToolCallPendingPartSchema: () => ToolCallPendingPartSchema,
+	ToolCallRunningPartSchema: () => ToolCallRunningPartSchema,
+	ToolCallSchema: () => ToolCallSchema,
+	ToolCallSkippedPartSchema: () => ToolCallSkippedPartSchema,
+	ToolCallTerminalPartSchema: () => ToolCallTerminalPartSchema,
+	ToolCompletedSchema: () => ToolCompletedSchema,
+	ToolErrorResult: () => ToolErrorResult,
+	ToolErrorSchema: () => ToolErrorSchema,
+	ToolRunningPartial: () => ToolRunningPartial,
+	ToolRunningSchema: () => ToolRunningSchema,
+	ToolSchema: () => ToolSchema,
+	ToolSkippedSchema: () => ToolSkippedSchema,
+	ToolStatusEnum: () => ToolStatusEnum,
+	ToolSuccessResult: () => ToolSuccessResult,
+	UsageSchema: () => UsageSchema,
+	UserMessageSchema: () => UserMessageSchema,
+	createAssistantMessage: () => createAssistantMessage$1,
+	createMessageId: () => createMessageId,
+	createUserMessage: () => createUserMessage,
+	defineTool: () => defineTool,
+	transformMessages: () => transformMessages
+});
+const TextContentSchema = Type$2.Object({
+	type: Type$2.Literal("text"),
+	text: Type$2.String(),
+	textSignature: Type$2.Optional(Type$2.String())
+});
+const ImageContentSchema = Type$2.Object({
+	type: Type$2.Literal("image"),
+	data: Type$2.String(),
+	mimeType: Type$2.String()
+});
+const ThinkingContentSchema = Type$2.Object({
+	type: Type$2.Literal("thinking"),
+	thinking: Type$2.String(),
+	thinkingSignature: Type$2.Optional(Type$2.String()),
+	/** When true, the thinking content was redacted by safety filters. The opaque
+	*  encrypted payload is stored in `thinkingSignature` so it can be passed back
+	*  to the API for multi-turn continuity. */
+	redacted: Type$2.Optional(Type$2.Boolean())
+});
+const ToolCallBaseSchema = Type$2.Object({
+	type: Type$2.Literal("toolCall"),
+	callID: Type$2.String(),
+	name: Type$2.String(),
+	arguments: Type$2.Record(Type$2.String(), Type$2.Any()),
+	thoughtSignature: Type$2.Optional(Type$2.String()),
+	namespace: Type$2.Optional(Type$2.String()),
+	/** Names from Context.tools that became available after this tool result. */
+	addedToolNames: Type$2.Optional(Type$2.Array(Type$2.String())),
+	time: Type$2.Object({
+		start: Type$2.Number(),
+		end: Type$2.Number()
+	})
+});
+const ToolSuccessResult = Type$2.Object({
+	content: Type$2.Array(Type$2.Union([TextContentSchema, ImageContentSchema])),
+	details: Type$2.Optional(Type$2.Any()),
+	isError: Type$2.Literal(false)
+});
+const ToolErrorResult = Type$2.Object({
+	content: Type$2.Array(Type$2.Union([TextContentSchema, ImageContentSchema])),
+	details: Type$2.Optional(Type$2.Any()),
+	isError: Type$2.Literal(true)
+});
+const ToolRunningPartial = Type$2.Object({
+	content: Type$2.Optional(Type$2.Array(Type$2.Union([TextContentSchema, ImageContentSchema]))),
+	details: Type$2.Optional(Type$2.Any())
+});
+const ToolStatusEnum = {
+	pending: "pending",
+	running: "running",
+	completed: "completed",
+	error: "error",
+	skipped: "skipped",
+	aborted: "aborted"
+};
+const ToolRunningSchema = Type$2.Object({
+	status: Type$2.Literal(ToolStatusEnum.running),
+	partial: Type$2.Optional(ToolRunningPartial)
+});
+const ToolCompletedSchema = Type$2.Object({
+	status: Type$2.Literal(ToolStatusEnum.completed),
+	result: ToolSuccessResult
+});
+const ToolErrorSchema = Type$2.Object({
+	status: Type$2.Literal(ToolStatusEnum.error),
+	result: ToolErrorResult
+});
+const ToolSkippedSchema = Type$2.Object({
+	status: Type$2.Literal(ToolStatusEnum.skipped),
+	result: ToolErrorResult
+});
+const ToolAbortedSchema = Type$2.Object({
+	status: Type$2.Literal(ToolStatusEnum.aborted),
+	result: ToolErrorResult
+});
+const ToolCallPendingPartSchema = Type$2.Intersect([ToolCallBaseSchema, Type$2.Object({ status: Type$2.Literal(ToolStatusEnum.pending) })]);
+const ToolCallRunningPartSchema = Type$2.Evaluate(Type$2.Intersect([ToolCallBaseSchema, ToolRunningSchema]));
+const ToolCallCompletedPartSchema = Type$2.Evaluate(Type$2.Intersect([ToolCallBaseSchema, ToolCompletedSchema]));
+const ToolCallErrorPartSchema = Type$2.Evaluate(Type$2.Intersect([ToolCallBaseSchema, ToolErrorSchema]));
+const ToolCallSkippedPartSchema = Type$2.Evaluate(Type$2.Intersect([ToolCallBaseSchema, ToolSkippedSchema]));
+const ToolCallAbortedPartSchema = Type$2.Evaluate(Type$2.Intersect([ToolCallBaseSchema, ToolAbortedSchema]));
+const ToolCallTerminalPartSchema = Type$2.Union([
+	ToolCallCompletedPartSchema,
+	ToolCallErrorPartSchema,
+	ToolCallSkippedPartSchema,
+	ToolCallAbortedPartSchema
+]);
+const ToolCallInFlightSchema = Type$2.Object({
+	callID: Type$2.String(),
+	name: Type$2.String(),
+	rawArgs: Type$2.Record(Type$2.String(), Type$2.Unknown()),
+	args: Type$2.Optional(Type$2.Unknown())
+});
+const ToolCallSchema = Type$2.Union([
+	ToolCallPendingPartSchema,
+	ToolCallRunningPartSchema,
+	ToolCallTerminalPartSchema
+]);
+const UsageSchema = Type$2.Object({
+	input: Type$2.Number(),
+	output: Type$2.Number(),
+	cacheRead: Type$2.Number(),
+	cacheWrite: Type$2.Number(),
+	reasoning: Type$2.Optional(Type$2.Number()),
+	totalTokens: Type$2.Number(),
+	cost: Type$2.Object({
+		input: Type$2.Number(),
+		output: Type$2.Number(),
+		cacheRead: Type$2.Number(),
+		cacheWrite: Type$2.Number(),
+		total: Type$2.Number()
+	})
+});
+const StopReasonSchema = Type$2.Union([
+	Type$2.Literal("stop"),
+	Type$2.Literal("length"),
+	Type$2.Literal("toolUse"),
+	Type$2.Literal("error"),
+	Type$2.Literal("aborted")
+]);
+const UserMessageSchema = Type$2.Object({
+	messageId: Type$2.String(),
+	role: Type$2.Literal("user"),
+	time: Type$2.Object({ created: Type$2.Number() }),
+	parts: Type$2.Array(Type$2.Union([TextContentSchema, ImageContentSchema]))
+});
+const AssistantMessageSchema = Type$2.Object({
+	role: Type$2.Literal("assistant"),
+	protocol: KnownProviderEnumSchema,
+	provider: ProviderInfo,
+	model: Type$2.String(),
+	usage: UsageSchema,
+	stopReason: StopReasonSchema,
+	errorMessage: Type$2.Optional(Type$2.String()),
+	time: Type$2.Object({
+		created: Type$2.Number(),
+		completed: Type$2.Number()
+	}),
+	parts: Type$2.Array(Type$2.Union([
+		TextContentSchema,
+		ImageContentSchema,
+		ThinkingContentSchema,
+		ToolCallSchema
+	])),
+	responseId: Type$2.Optional(Type$2.String()),
+	responseModel: Type$2.Optional(Type$2.String()),
+	messageId: Type$2.String()
+});
+const MessageSchema = Type$2.Union([UserMessageSchema, AssistantMessageSchema]);
+function createMessageId() {
+	return uuidv7();
+}
+function createUserMessage(message) {
+	const { messageId = createMessageId(), ...rest } = message;
+	return {
+		messageId,
+		...rest
 	};
-	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: [{
+}
+function createAssistantMessage$1(message) {
+	const { messageId = createMessageId(), ...rest } = message;
+	return {
+		messageId,
+		...rest
+	};
+}
+const GrammarVariantsSchema = Type$2.Partial(Type$2.Object({
+	openai_lark: Type$2.String(),
+	openai_regex: Type$2.String()
+}));
+const ConstrainedSamplingSchema = Type$2.Union([Type$2.Object({
+	type: Type$2.Literal("json_schema"),
+	strict: Type$2.Union([Type$2.Literal("prefer"), Type$2.Literal("require")])
+}), Type$2.Object({
+	type: Type$2.Literal("grammar"),
+	variants: GrammarVariantsSchema
+})]);
+/**
+* Generic tool definition with typed parameter schema.
+* Usage:
+*
+* const search = Message.defineTool({
+*   name: "search",
+*   description: "Search documents",
+*   parameters: Type.Object({
+*     query: Type.String(),
+*     limit: Type.Optional(Type.Number()),
+*   }),
+* });
+*
+* type SearchParams = Static<typeof search.parameters>;
+*/
+const ToolSchema = Type$2.Object({
+	name: Type$2.String(),
+	description: Type$2.String(),
+	parameters: Type$2.Unsafe({}),
+	constrainedSampling: Type$2.Optional(Type$2.Union([Type$2.Literal(false), ConstrainedSamplingSchema]))
+});
+function defineTool(tool) {
+	return tool;
+}
+const ContextSchema = Type$2.Object({
+	systemPrompt: Type$2.Optional(Type$2.String()),
+	messages: Type$2.Array(MessageSchema),
+	tools: Type$2.Optional(Type$2.Array(ToolSchema))
+});
+function isUnresolvedToolCall(toolCall) {
+	return toolCall.status === ToolStatusEnum.pending || toolCall.status === ToolStatusEnum.running;
+}
+function syntheticSkippedToolCall(toolCall) {
+	const { status: _status, partial: _partial, ...base } = toolCall;
+	return {
+		...base,
+		status: ToolStatusEnum.skipped,
+		result: {
+			content: [{
+				type: "text",
+				text: "No result provided"
+			}],
+			isError: true
+		},
+		time: {
+			...toolCall.time,
+			end: Math.max(toolCall.time.end, Date.now())
+		}
+	};
+}
+function transformMessages(messages, model, normalizeToolCallId) {
+	const toolCallIDMap = /* @__PURE__ */ new Map();
+	const transformed = [];
+	for (const msg of messages) {
+		if (msg.role === "user") {
+			transformed.push(msg);
+			continue;
+		}
+		const assistantMsg = msg;
+		const isSameModel = assistantMsg.provider.id === model.provider.id && assistantMsg.protocol === model.protocol && assistantMsg.model === model.id;
+		const parts = assistantMsg.parts.flatMap((block) => {
+			if (block.type === "thinking") {
+				if (isSameModel && block.thinkingSignature) return block;
+				if (!block.thinking || block.thinking.trim() === "") return [];
+				if (isSameModel) return block;
+				return {
 					type: "text",
-					text: "No result provided"
-				}],
-				isError: true
-			},
-			time: {
-				...toolCall.time,
-				end: Math.max(toolCall.time.end, Date.now())
+					text: block.thinking
+				};
 			}
-		};
-	}
-	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;
+			if (block.type === "text") {
+				if (isSameModel) return block;
+				return {
+					type: "text",
+					text: block.text
+				};
 			}
-			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;
 				}
-				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
-							};
-						}
+				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;
+				return normalizedToolCall;
+			}
+			return block;
+		}).map((block) => {
+			if (block.type === "toolCall" && isUnresolvedToolCall(block)) return syntheticSkippedToolCall(block);
+			return block;
+		});
+		transformed.push({
+			...assistantMsg,
+			parts
+		});
 	}
-	_Message.transformMessages = transformMessages;
-})(Message || (Message = {}));
+	return transformed;
+}
 //#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
+var event_exports = /* @__PURE__ */ __exportAll({
+	AgentEventSchema: () => AgentEventSchema,
+	AgentEventType: () => AgentEventType,
+	LLMMessageEventSchema: () => LLMMessageEventSchema,
+	LLMMessageEventType: () => LLMMessageEventType
+});
+const 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 protocol for AssistantMessageEventStream.
+*
+* Streams should emit `start` before partial updates, then terminate with either:
+* - `done` carrying the final successful AssistantMessage, or
+* - `error` carrying the final AssistantMessage with stopReason "error" or "aborted"
+*   and errorMessage.
+*/
+const LLMMessageEventSchema = Type$2.Union([
+	Type$2.Object({
+		type: Type$2.Literal(LLMMessageEventType.start),
+		partial: AssistantMessageSchema
+	}),
+	Type$2.Object({
+		type: Type$2.Literal(LLMMessageEventType.textStart),
+		partIndex: Type$2.Number(),
+		partial: AssistantMessageSchema
+	}),
+	Type$2.Object({
+		type: Type$2.Literal(LLMMessageEventType.textDelta),
+		partIndex: Type$2.Number(),
+		delta: Type$2.String(),
+		partial: AssistantMessageSchema
+	}),
+	Type$2.Object({
+		type: Type$2.Literal(LLMMessageEventType.textEnd),
+		partIndex: Type$2.Number(),
+		content: Type$2.String(),
+		partial: AssistantMessageSchema
+	}),
+	Type$2.Object({
+		type: Type$2.Literal(LLMMessageEventType.thinkingStart),
+		partIndex: Type$2.Number(),
+		partial: AssistantMessageSchema
+	}),
+	Type$2.Object({
+		type: Type$2.Literal(LLMMessageEventType.thinkingDelta),
+		partIndex: Type$2.Number(),
+		delta: Type$2.String(),
+		partial: AssistantMessageSchema
+	}),
+	Type$2.Object({
+		type: Type$2.Literal(LLMMessageEventType.thinkingEnd),
+		partIndex: Type$2.Number(),
+		content: Type$2.String(),
+		partial: AssistantMessageSchema
+	}),
+	Type$2.Object({
+		type: Type$2.Literal(LLMMessageEventType.toolcallStart),
+		partIndex: Type$2.Number(),
+		partial: AssistantMessageSchema
+	}),
+	Type$2.Object({
+		type: Type$2.Literal(LLMMessageEventType.toolcallDelta),
+		partIndex: Type$2.Number(),
+		delta: Type$2.String(),
+		partial: AssistantMessageSchema
+	}),
+	Type$2.Object({
+		type: Type$2.Literal(LLMMessageEventType.toolcallEnd),
+		partIndex: Type$2.Number(),
+		toolCall: ToolCallSchema,
+		partial: AssistantMessageSchema
+	}),
+	Type$2.Object({
+		type: Type$2.Literal(LLMMessageEventType.toolcallFinal),
+		partIndex: Type$2.Number(),
+		toolCall: ToolCallSchema,
+		partial: AssistantMessageSchema
+	}),
+	Type$2.Object({
+		type: Type$2.Literal(LLMMessageEventType.done),
+		reason: Type$2.Union([
+			Type$2.Literal("stop"),
+			Type$2.Literal("length"),
+			Type$2.Literal("toolUse")
 		]),
-		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 = {}));
+		message: AssistantMessageSchema
+	}),
+	Type$2.Object({
+		type: Type$2.Literal(LLMMessageEventType.error),
+		reason: Type$2.Union([Type$2.Literal("aborted"), Type$2.Literal("error")]),
+		error: AssistantMessageSchema
+	})
+]);
+const AgentEventType = {
+	agentStart: "agent.start",
+	agentEnd: "agent.end",
+	turnStart: "turn.start",
+	turnEnd: "turn.end",
+	messageStart: "message.start",
+	messagePartStart: "message.part.start",
+	messagePartUpdate: "message.part.update",
+	messagePartEnd: "message.part.end",
+	messageUpdate: "message.update",
+	messageEnd: "message.end",
+	toolExecutionStart: "tool.execution.start",
+	toolExecutionUpdate: "tool.execution.update",
+	toolExecutionEnd: "tool.execution.end"
+};
+const UserMessagePart = Type$2.Union([TextContentSchema, ImageContentSchema]);
+const AssistantMessagePart = Type$2.Union([
+	TextContentSchema,
+	ImageContentSchema,
+	ThinkingContentSchema,
+	ToolCallSchema
+]);
+const UserMessagePartStart = Type$2.Object({
+	type: Type$2.Literal(AgentEventType.messagePartStart),
+	message: UserMessageSchema,
+	partIndex: Type$2.Number(),
+	part: UserMessagePart
+});
+const UserMessagePartEnd = Type$2.Object({
+	type: Type$2.Literal(AgentEventType.messagePartEnd),
+	message: UserMessageSchema,
+	partIndex: Type$2.Number(),
+	part: UserMessagePart
+});
+const AssistantMessagePartStart = Type$2.Object({
+	type: Type$2.Literal(AgentEventType.messagePartStart),
+	message: AssistantMessageSchema,
+	partIndex: Type$2.Number(),
+	part: AssistantMessagePart
+});
+const AssistantMessagePartLLMUpdate = Type$2.Object({
+	type: Type$2.Literal(AgentEventType.messagePartUpdate),
+	message: AssistantMessageSchema,
+	partIndex: Type$2.Number(),
+	part: AssistantMessagePart,
+	source: Type$2.Literal("llm")
+});
+const AssistantMessagePartToolUpdate = Type$2.Object({
+	type: Type$2.Literal(AgentEventType.messagePartUpdate),
+	message: AssistantMessageSchema,
+	partIndex: Type$2.Number(),
+	part: AssistantMessagePart,
+	source: Type$2.Literal("tool")
+});
+const AssistantMessagePartEnd = Type$2.Object({
+	type: Type$2.Literal(AgentEventType.messagePartEnd),
+	message: AssistantMessageSchema,
+	partIndex: Type$2.Number(),
+	part: AssistantMessagePart
+});
+const ToolExecutionStartSchema = Type$2.Object({
+	type: Type$2.Literal(AgentEventType.toolExecutionStart),
+	messageId: Type$2.String(),
+	partIndex: Type$2.Number(),
+	toolCall: ToolCallPendingPartSchema
+});
+const ToolExecutionUpdateSchema = Type$2.Object({
+	type: Type$2.Literal(AgentEventType.toolExecutionUpdate),
+	messageId: Type$2.String(),
+	partIndex: Type$2.Number(),
+	toolCall: ToolCallRunningPartSchema
+});
+const ToolExecutionEndSchema = Type$2.Object({
+	type: Type$2.Literal(AgentEventType.toolExecutionEnd),
+	messageId: Type$2.String(),
+	partIndex: Type$2.Number(),
+	toolCall: ToolCallTerminalPartSchema
+});
+/**
+* Events emitted by the Agent lifecycle
+* These events provide fine-grained lifecycle information for messages, turns, and tool execution.
+*/
+const AgentEventSchema = Type$2.Union([
+	Type$2.Object({ type: Type$2.Literal(AgentEventType.agentStart) }),
+	Type$2.Object({
+		type: Type$2.Literal(AgentEventType.agentEnd),
+		messages: Type$2.Array(MessageSchema)
+	}),
+	Type$2.Object({ type: Type$2.Literal(AgentEventType.turnStart) }),
+	Type$2.Object({
+		type: Type$2.Literal(AgentEventType.turnEnd),
+		message: AssistantMessageSchema
+	}),
+	Type$2.Object({
+		type: Type$2.Literal(AgentEventType.messageStart),
+		message: MessageSchema
+	}),
+	Type$2.Union([UserMessagePartStart, UserMessagePartEnd]),
+	Type$2.Union([
+		AssistantMessagePartStart,
+		AssistantMessagePartLLMUpdate,
+		AssistantMessagePartToolUpdate,
+		AssistantMessagePartEnd
+	]),
+	Type$2.Object({
+		type: Type$2.Literal(AgentEventType.messageUpdate),
+		message: MessageSchema
+	}),
+	Type$2.Object({
+		type: Type$2.Literal(AgentEventType.messageEnd),
+		message: MessageSchema
+	}),
+	ToolExecutionStartSchema,
+	ToolExecutionUpdateSchema,
+	ToolExecutionEndSchema
+]);
 //#endregion
 //#region src/llm.ts
-const llmImpl = async (provider, model, overrides) => Model.getModel(provider, model, overrides);
+const llmImpl = async (provider, model, overrides) => getModel(provider, model, overrides);
 const llm = Object.assign(llmImpl, {
-	model: Model.getModel,
-	models: Model.getModels,
-	providers: Model.getProviders,
-	registry: Model.registry,
-	modelsAreEqual: Model.modelsAreEqual
+	model: getModel,
+	models: getModels,
+	providers: getProviders,
+	registry,
+	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
+var protocol_exports = /* @__PURE__ */ __exportAll({
+	ProtocolAuthError: () => ProtocolAuthError,
+	ProtocolMismatchError: () => ProtocolMismatchError,
+	ProviderProtocolNotFoundError: () => ProviderProtocolNotFoundError,
+	clearProtocolProviders: () => clearProtocolProviders,
+	complete: () => complete,
+	getProtocolProvider: () => getProtocolProvider,
+	getProtocolProviders: () => getProtocolProviders,
+	registerProtocolProvider: () => registerProtocolProvider,
+	resolveProtocolProvider: () => resolveProtocolProvider,
+	stream: () => stream$2,
+	unregisterProtocolProviders: () => unregisterProtocolProviders
+});
+const ProviderProtocolNotFoundError = NamedError.create("ProviderProtocolNotFoundError", Type$2.Object({ protocol: KnownProviderEnumSchema }));
+const ProtocolMismatchError = NamedError.create("ProtocolMismatchError", Type$2.Object({
+	actual: KnownProviderEnumSchema,
+	expected: KnownProviderEnumSchema
+}));
+const ProtocolAuthError = NamedError.create("ProtocolAuthError", Type$2.Object({
+	message: Type$2.String(),
+	protocol: Type$2.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
 		});
-	}
-	_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 = {}));
+		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 !== void 0 && { sourceId }
+	});
+}
+function getProtocolProvider(protocol) {
+	return protocolRegistry.get(protocol)?.provider;
+}
+function resolveProtocolProvider(model) {
+	const provider = getProtocolProvider(model.protocol);
+	if (!provider) throw new ProviderProtocolNotFoundError({ protocol: model.protocol });
+	return provider;
+}
+function getProtocolProviders() {
+	return Array.from(protocolRegistry.values(), (entry) => entry.provider);
+}
+function stream$2(model, context, options) {
+	return resolveProtocolProvider(model).stream(model, context, options);
+}
+async function complete(model, context, options) {
+	return stream$2(model, context, options).result();
+}
+function unregisterProtocolProviders(sourceId) {
+	for (const [protocol, entry] of protocolRegistry.entries()) if (entry.sourceId === sourceId) protocolRegistry.delete(protocol);
+}
+function clearProtocolProviders() {
+	protocolRegistry.clear();
+}
 //#endregion
 //#region src/llm/shared.ts
-const CacheRetention = Type$2.Union([
-	Type$2.Literal("none"),
-	Type$2.Literal("short"),
-	Type$2.Literal("long")
+const CacheRetention = Type$1.Union([
+	Type$1.Literal("none"),
+	Type$1.Literal("short"),
+	Type$1.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 GenerationOptions = Type$1.Object({
+	maxTokens: Type$1.Optional(Type$1.Number()),
+	temperature: Type$1.Optional(Type$1.Number()),
+	cacheRetention: Type$1.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 HelperOptions = Type$1.Object({
+	headers: Type$1.Optional(Type$1.Record(Type$1.String(), Type$1.String())),
+	sessionId: Type$1.Optional(Type$1.String()),
+	apiKey: Type$1.Optional(Type$1.String()),
+	timeoutMs: Type$1.Optional(Type$1.Number()),
+	maxRetries: Type$1.Optional(Type$1.Number()),
+	signal: Type$1.Optional(Type$1.Unsafe({})),
+	onPayload: Type$1.Optional(Type$1.Unsafe({})),
+	metadata: Type$1.Optional(Type$1.Record(Type$1.String(), Type$1.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 ThinkingBudgets = Type$1.Object({
+	minimal: Type$1.Optional(Type$1.Number()),
+	low: Type$1.Optional(Type$1.Number()),
+	medium: Type$1.Optional(Type$1.Number()),
+	high: Type$1.Optional(Type$1.Number()),
+	xhigh: Type$1.Optional(Type$1.Number()),
+	max: Type$1.Optional(Type$1.Number())
 });
-const SharedOptions = Type$2.Evaluate(Type$2.Intersect([GenerationOptions, HelperOptions]));
+const SharedOptions = Type$1.Evaluate(Type$1.Intersect([GenerationOptions, HelperOptions]));
 const DEFAULT_MAX_OUTPUT_TOKENS = 32e3;
 const CONTEXT_WINDOW_OUTPUT_TOLERANCE = 1024;
 function applyDefaultMaxTokens(model, options) {
@@ -584,16 +677,16 @@ function applyDefaultMaxTokens(model, 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())))
+Type$1.Evaluate(Type$1.Intersect([SharedOptions, Type$1.Object({
+	baseURL: Type$1.Optional(Type$1.String()),
+	method: Type$1.Optional(APIMethodEnumSchema),
+	modelId: Type$1.Optional(Type$1.String()),
+	reasoning: Type$1.Optional(ActiveThinkingLevel),
+	thinkingBudgets: Type$1.Optional(ThinkingBudgets),
+	toolChoice: Type$1.Optional(Type$1.Any()),
+	activeTools: Type$1.Optional(Type$1.Array(Type$1.String())),
+	factoryOptions: Type$1.Optional(Type$1.Record(Type$1.String(), Type$1.Unknown())),
+	providerOptions: Type$1.Optional(Type$1.Record(Type$1.String(), Type$1.Record(Type$1.String(), Type$1.Unknown())))
 })]));
 //#endregion
 //#region src/utils/eventstream.ts
@@ -603,6 +696,8 @@ var EventStream = class {
 	done = false;
 	finalResultPromise;
 	resolveFinalResult;
+	isComplete;
+	extractResult;
 	constructor(isComplete, extractResult) {
 		this.isComplete = isComplete;
 		this.extractResult = extractResult;
@@ -658,6 +753,21 @@ function createAssistantMessageEventStream() {
 	return new AssistantMessageEventStream();
 }
 //#endregion
+//#region src/utils/helpers.ts
+/**
+* Drops keys whose value is `undefined`.
+*
+* Under `exactOptionalPropertyTypes` an explicit `undefined` is not assignable to an optional
+* property, so a literal built from optional inputs has to omit the key rather than pass it
+* through. Only worth reaching for when a literal forwards many optional values at once — for a
+* handful of keys a conditional spread reads better.
+*/
+function compact(value) {
+	const result = {};
+	for (const [key, entry] of Object.entries(value)) if (entry !== void 0) result[key] = entry;
+	return result;
+}
+//#endregion
 //#region src/llm/runtime.ts
 function mergeHeaders(...headerSources) {
 	const merged = {};
@@ -705,15 +815,23 @@ async function resolveAISDKLanguageModel(model, options) {
 	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({
+		if (!baseURL) throw new 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;
 	}
-	if (npm === "@codeworksh/ai-sdk-openai-codex" && options.sessionId) factoryOptions.sessionId ??= options.sessionId;
-	return resolveLanguageModel(createProvider(factoryOptions), model, options.method);
+	if (npm === "@codeworksh/ai-sdk-openai-codex") {
+		const cacheDisabled = options.cacheRetention === "none" || typeof process !== "undefined" && process.env.CODEWORK_CACHE_RETENTION === "none";
+		if (options.sessionId && !cacheDisabled) factoryOptions.sessionId ??= options.sessionId;
+		factoryOptions.compat ??= {
+			...model.compat,
+			supportsImages: model.input.includes("image")
+		};
+	}
+	const provider = createProvider(factoryOptions);
+	return resolveLanguageModel(provider, model, options.method);
 }
 //#endregion
 //#region src/utils/jsonparse.ts
@@ -788,9 +906,7 @@ function repairInvalidJsonStringContent(input) {
 			case "	":
 				output += "\\t";
 				break;
-			default:
-				output += char;
-				break;
+			default: output += char;
 		}
 	}
 	if (escaping) output += "\\\\";
@@ -824,7 +940,7 @@ function sanitizeSurrogates(text) {
 //#endregion
 //#region src/llm/transform.ts
 function createAssistantMessage(model) {
-	return Message.createAssistantMessage({
+	return createAssistantMessage$1({
 		role: "assistant",
 		parts: [],
 		protocol: model.protocol,
@@ -863,8 +979,8 @@ function userContent(parts, supportsImages) {
 			continue;
 		}
 		if (supportsImages) content.push({
-			type: "image",
-			image: part.data,
+			type: "file",
+			data: part.data,
 			mediaType: part.mimeType
 		});
 	}
@@ -904,13 +1020,48 @@ function toolResultOutput(toolCall) {
 			type: "text",
 			text
 		}] : [], ...images.map((image) => ({
-			type: "image-data",
-			data: image.data,
+			type: "file",
+			data: {
+				type: "data",
+				data: image.data
+			},
 			mediaType: image.mimeType
 		}))]
 	};
 }
-function assistantMessages(message) {
+function normalizeOpenAICodexIdPart(value) {
+	return value.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64).replace(/_+$/, "");
+}
+function normalizeOpenAICodexToolCallId(id, model, source) {
+	if (!id.includes("|")) return normalizeOpenAICodexIdPart(id);
+	const [callId, itemId = ""] = id.split("|");
+	const normalizedCallId = normalizeOpenAICodexIdPart(callId ?? "");
+	let normalizedItemId = source.provider.id !== model.provider.id || source.protocol !== model.protocol ? `fc_${shortHash(itemId)}` : normalizeOpenAICodexIdPart(itemId);
+	if (!normalizedItemId.startsWith("fc_") && !normalizedItemId.startsWith("ctc_")) normalizedItemId = normalizeOpenAICodexIdPart(`fc_${normalizedItemId}`);
+	return `${normalizedCallId}|${normalizedItemId}`;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function encodeOpenAIReasoningSignature(providerMetadata) {
+	if (!isRecord(providerMetadata)) return;
+	const metadata = providerMetadata.openai;
+	if (!isRecord(metadata) || typeof metadata.itemId !== "string") return;
+	const signature = { itemId: metadata.itemId };
+	if (typeof metadata.reasoningEncryptedContent === "string" || metadata.reasoningEncryptedContent === null) signature.reasoningEncryptedContent = metadata.reasoningEncryptedContent;
+	return JSON.stringify(signature);
+}
+function decodeOpenAIReasoningSignature(signature) {
+	try {
+		const parsed = JSON.parse(signature);
+		if (isRecord(parsed) && typeof parsed.itemId === "string") return {
+			itemId: parsed.itemId,
+			...typeof parsed.reasoningEncryptedContent === "string" || parsed.reasoningEncryptedContent === null ? { reasoningEncryptedContent: parsed.reasoningEncryptedContent } : {}
+		};
+	} catch {}
+	return { itemId: signature };
+}
+function assistantMessages(message, model) {
 	if (message.stopReason === "error" || message.stopReason === "aborted") return [];
 	const assistantContent = [];
 	const toolResults = [];
@@ -920,33 +1071,42 @@ function assistantMessages(message) {
 			if (text.trim().length === 0) continue;
 			assistantContent.push({
 				type: "text",
-				text
+				text,
+				...part.textSignature && message.protocol === KnownProviderEnum.openaiCodex ? { providerOptions: { "openai-codex": { messageId: part.textSignature } } } : {}
 			});
 			continue;
 		}
 		if (part.type === "thinking") {
 			const thinking = sanitizeSurrogates(part.thinking);
-			if (thinking.trim().length === 0) continue;
+			if (thinking.trim().length === 0 && !part.thinkingSignature) continue;
 			const reasoning = {
 				type: "reasoning",
 				text: thinking
 			};
-			if (part.thinkingSignature) reasoning.providerOptions = { anthropic: { signature: part.thinkingSignature } };
+			if (message.protocol === KnownProviderEnum.openai) {
+				if (!part.thinkingSignature) continue;
+				reasoning.providerOptions = { openai: decodeOpenAIReasoningSignature(part.thinkingSignature) };
+			} else if (part.thinkingSignature) reasoning.providerOptions = message.protocol === KnownProviderEnum.openaiCodex ? { "openai-codex": { reasoningItem: part.thinkingSignature } } : { anthropic: { signature: part.thinkingSignature } };
 			assistantContent.push(reasoning);
 			continue;
 		}
 		if (part.type !== "toolCall") continue;
+		const codexToolMetadata = {};
+		if (part.namespace && message.protocol === KnownProviderEnum.openaiCodex) codexToolMetadata.namespace = part.namespace;
+		if (model.protocol === KnownProviderEnum.openaiCodex && message.protocol === model.protocol && message.provider.id === model.provider.id && message.model !== model.id) codexToolMetadata.omitItemId = true;
 		assistantContent.push({
 			type: "tool-call",
 			toolCallId: part.callID,
 			toolName: part.name,
-			input: sanitizeRecord(part.arguments ?? {})
+			input: sanitizeRecord(part.arguments ?? {}),
+			...Object.keys(codexToolMetadata).length > 0 ? { providerOptions: { "openai-codex": codexToolMetadata } } : {}
 		});
 		const terminal = part.status === "pending" || part.status === "running" ? void 0 : part;
 		toolResults.push({
 			type: "tool-result",
 			toolCallId: part.callID,
 			toolName: part.name,
+			...terminal?.addedToolNames?.length ? { providerOptions: { "openai-codex": { addedToolNames: terminal.addedToolNames } } } : {},
 			output: terminal ? toolResultOutput(terminal) : {
 				type: "error-text",
 				value: "No result provided"
@@ -966,23 +1126,28 @@ function assistantMessages(message) {
 }
 function convertMessages(context, model) {
 	const messages = [];
-	const transformedMessages = Message.transformMessages(context.messages, model);
+	const transformedMessages = transformMessages(context.messages, model, model.protocol === KnownProviderEnum.openaiCodex ? normalizeOpenAICodexToolCallId : void 0);
 	for (const msg of transformedMessages) {
 		if (msg.role === "user") {
 			messages.push(...userContent(msg.parts, model.input.includes("image")));
 			continue;
 		}
-		messages.push(...assistantMessages(msg));
+		messages.push(...assistantMessages(msg, model));
 	}
 	return messages;
 }
-function convertTools(tools) {
+function convertTools(tools, model) {
 	if (!tools || tools.length === 0) return;
 	const result = {};
-	for (const tool of tools) result[tool.name] = {
-		description: tool.description,
-		inputSchema: jsonSchema(tool.parameters)
-	};
+	for (const tool of tools) {
+		const constraint = model?.protocol === KnownProviderEnum.openaiCodex ? resolveOpenAICodexToolConstraint(tool, model.compat) : void 0;
+		result[tool.name] = {
+			description: tool.description,
+			inputSchema: jsonSchema(tool.parameters),
+			...constraint?.type === "json_schema" ? { strict: true } : {},
+			...constraint?.type === "grammar" ? { providerOptions: { "openai-codex": { grammar: constraint } } } : {}
+		};
+	}
 	return result;
 }
 function mapFinishReason(reason) {
@@ -995,17 +1160,19 @@ function mapFinishReason(reason) {
 		default: return "stop";
 	}
 }
-function mapUsage(usage, model) {
-	const cacheRead = usage?.inputTokenDetails?.cacheReadTokens ?? usage?.cachedInputTokens ?? 0;
+function mapUsage(usage, model, costMultiplier = 1) {
+	const cacheRead = usage?.inputTokenDetails.cacheReadTokens ?? 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 totalTokens = usage?.totalTokens ?? input + cacheRead + cacheWrite + output;
 	const result = {
 		input,
 		output,
 		cacheRead,
 		cacheWrite,
-		totalTokens: usage?.totalTokens ?? input + cacheRead + cacheWrite + output,
+		...usage?.outputTokenDetails?.reasoningTokens !== void 0 ? { reasoning: usage.outputTokenDetails.reasoningTokens } : {},
+		totalTokens,
 		cost: {
 			input: 0,
 			output: 0,
@@ -1014,7 +1181,14 @@ function mapUsage(usage, model) {
 			total: 0
 		}
 	};
-	Model.calculateCost(model, result);
+	calculateCost(model, result);
+	if (costMultiplier !== 1) {
+		result.cost.input *= costMultiplier;
+		result.cost.output *= costMultiplier;
+		result.cost.cacheRead *= costMultiplier;
+		result.cost.cacheWrite *= costMultiplier;
+		result.cost.total = result.cost.input + result.cost.output + result.cost.cacheRead + result.cost.cacheWrite;
+	}
 	return result;
 }
 function toolCallFromPart(part) {
@@ -1082,7 +1256,8 @@ const DEFAULT_THINKING_BUDGET_FRACTIONS = {
 	low: .1,
 	medium: .25,
 	high: .5,
-	xhigh: .8
+	xhigh: .8,
+	max: .95
 };
 const MIN_THINKING_BUDGET = 1024;
 function resolveThinkingBudget(model, options, level) {
@@ -1097,7 +1272,7 @@ function resolveThinkingBudget(model, options, level) {
 function reasoningProviderOptions(model, options) {
 	const requestedLevel = options.reasoning;
 	if (!requestedLevel) return {};
-	const level = Model.clampThinkingLevel(model, requestedLevel);
+	const level = clampThinkingLevel(model, requestedLevel);
 	if (level === "off") return {};
 	const mapped = model.thinkingLevelMap?.[level] ?? level;
 	if (!mapped) return {};
@@ -1125,6 +1300,11 @@ function resolveProviderOptions(model, options) {
 function partIndex(output, block) {
 	return output.parts.indexOf(block);
 }
+function openAICodexMetadata(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const metadata = value["openai-codex"];
+	return typeof metadata === "object" && metadata !== null && !Array.isArray(metadata) ? metadata : void 0;
+}
 function ensureTextBlock(output, id, stream) {
 	const existing = output.parts.find((part) => part.type === "text" && part.streamId === id);
 	if (existing) return existing;
@@ -1182,9 +1362,10 @@ function ensureToolCallBlock(output, id, name, stream, emitStart) {
 	});
 	return block;
 }
-function finishTextBlock(output, id, stream) {
+function finishTextBlock(output, id, stream, textSignature) {
 	const block = output.parts.find((part) => part.type === "text" && part.streamId === id);
 	if (!block) return;
+	if (textSignature) block.textSignature = textSignature;
 	const index = partIndex(output, block);
 	delete block.streamId;
 	stream.push({
@@ -1194,9 +1375,10 @@ function finishTextBlock(output, id, stream) {
 		partial: output
 	});
 }
-function finishThinkingBlock(output, id, stream) {
+function finishThinkingBlock(output, id, stream, thinkingSignature) {
 	const block = output.parts.find((part) => part.type === "thinking" && part.streamId === id);
 	if (!block) return;
+	if (thinkingSignature) block.thinkingSignature = thinkingSignature;
 	const index = partIndex(output, block);
 	delete block.streamId;
 	stream.push({
@@ -1224,6 +1406,8 @@ function finalizeToolCall(output, part, stream) {
 	block.callID = part.toolCallId;
 	block.name = part.toolName;
 	block.arguments = typeof part.input === "object" && part.input !== null ? part.input : {};
+	const namespace = openAICodexMetadata(part.providerMetadata)?.namespace;
+	if (typeof namespace === "string") block.namespace = namespace;
 	block.time.end = Date.now();
 	delete block.partialJson;
 	if (!existing) output.parts.push(block);
@@ -1235,7 +1419,7 @@ function finalizeToolCall(output, part, stream) {
 		partial: output
 	});
 }
-function handlePart(part, output, model, stream) {
+function handlePart(part, output, model, stream, costMultiplier) {
 	switch (part.type) {
 		case "text-start":
 			ensureTextBlock(output, part.id, stream);
@@ -1251,9 +1435,11 @@ function handlePart(part, output, model, stream) {
 			});
 			break;
 		}
-		case "text-end":
-			finishTextBlock(output, part.id, stream);
+		case "text-end": {
+			const messageId = openAICodexMetadata(part.providerMetadata)?.messageId;
+			finishTextBlock(output, part.id, stream, typeof messageId === "string" ? messageId : void 0);
 			break;
+		}
 		case "reasoning-start":
 			ensureThinkingBlock(output, part.id, stream);
 			break;
@@ -1270,9 +1456,12 @@ function handlePart(part, output, model, stream) {
 			});
 			break;
 		}
-		case "reasoning-end":
-			finishThinkingBlock(output, part.id, stream);
+		case "reasoning-end": {
+			const reasoningItem = openAICodexMetadata(part.providerMetadata)?.reasoningItem;
+			const openAISignature = encodeOpenAIReasoningSignature(part.providerMetadata);
+			finishThinkingBlock(output, part.id, stream, typeof reasoningItem === "string" ? reasoningItem : openAISignature);
 			break;
+		}
 		case "tool-input-start":
 			ensureToolCallBlock(output, part.id, part.toolName, stream, true);
 			break;
@@ -1296,20 +1485,30 @@ function handlePart(part, output, model, stream) {
 		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.usage = mapUsage(part.usage, model, costMultiplier);
 			output.stopReason = mapFinishReason(part.finishReason);
 			break;
 		case "finish":
-			output.usage = mapUsage(part.totalUsage, model);
+			output.usage = mapUsage(part.totalUsage, model, costMultiplier);
 			output.stopReason = mapFinishReason(part.finishReason);
 			break;
 		case "abort":
 			output.stopReason = "aborted";
-			output.errorMessage = part.reason;
+			if (part.reason !== void 0) output.errorMessage = part.reason;
 			break;
 		case "error": throw part.error instanceof Error ? part.error : new Error(formatThrownError(part.error));
 	}
 }
+function resolveCostMultiplier(model, options, providerOptions) {
+	if (providerOptionsKey(model) !== "openai-codex") return 1;
+	const providerTier = providerOptions["openai-codex"]?.serviceTier;
+	const factoryTier = options.factoryOptions?.serviceTier;
+	const modelTier = model.options?.serviceTier;
+	const serviceTier = providerTier ?? factoryTier ?? modelTier;
+	if (serviceTier === "flex") return .5;
+	if (serviceTier === "priority") return model.id === "gpt-5.5" ? 2.5 : 2;
+	return 1;
+}
 /**
 * 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.
@@ -1332,11 +1531,12 @@ const stream$1 = (model, context, options) => {
 		const output = createAssistantMessage(model);
 		try {
 			const languageModel = await resolveAISDKLanguageModel(model, runtimeOptions);
-			const tools = convertTools(context.tools);
+			const tools = convertTools(context.tools, model);
 			const messages = convertMessages(context, model);
 			const providerOptions = resolveProviderOptions(model, runtimeOptions);
+			const costMultiplier = resolveCostMultiplier(model, runtimeOptions, providerOptions);
 			const activeTools = runtimeOptions.activeTools?.filter((name) => !tools || name in tools);
-			let params = {
+			let params = compact({
 				model: languageModel,
 				system: context.systemPrompt,
 				messages,
@@ -1350,7 +1550,7 @@ const stream$1 = (model, context, options) => {
 				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);
@@ -1358,7 +1558,7 @@ const stream$1 = (model, context, options) => {
 				type: "start",
 				partial: output
 			});
-			for await (const part of result.fullStream) handlePart(part, output, model, stream);
+			for await (const part of result.fullStream) handlePart(part, output, model, stream, costMultiplier);
 			if (runtimeOptions.signal?.aborted || output.stopReason === "aborted") throw new Error(output.errorMessage || "Request was aborted");
 			if (output.stopReason === "error") throw new Error(output.errorMessage || "Provider returned an error stop reason");
 			output.time.completed = Date.now();
@@ -1396,22 +1596,22 @@ function createAISDKProtocol(protocol) {
 	};
 }
 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.openaiCodex));
-	Protocol.registerProtocolProvider(createAISDKProtocol(Model.KnownProviderEnum.openrouter));
-	Protocol.registerProtocolProvider(createAISDKProtocol(Model.KnownProviderEnum.xai));
+	registerProtocolProvider(createAISDKProtocol(KnownProviderEnum.anthropic));
+	registerProtocolProvider(createAISDKProtocol(KnownProviderEnum.google));
+	registerProtocolProvider(createAISDKProtocol(KnownProviderEnum.googleVertex));
+	registerProtocolProvider(createAISDKProtocol(KnownProviderEnum.googleVertexAnthropic));
+	registerProtocolProvider(createAISDKProtocol(KnownProviderEnum.openai));
+	registerProtocolProvider(createAISDKProtocol(KnownProviderEnum.openaiCompatible));
+	registerProtocolProvider(createAISDKProtocol(KnownProviderEnum.openaiCodex));
+	registerProtocolProvider(createAISDKProtocol(KnownProviderEnum.openrouter));
+	registerProtocolProvider(createAISDKProtocol(KnownProviderEnum.xai));
 }
 //#endregion
 //#region src/llm/register.ts
 registerAISDKProtocols();
 //#endregion
 //#region src/stream.ts
-const streamImpl = (model, context, options) => Protocol.stream(model, context, options);
+const streamImpl = (model, context, options) => stream$2(model, context, options);
 /**
 * Start a streaming assistant response for a model/context pair.
 *
@@ -1422,10 +1622,9 @@ const streamImpl = (model, context, options) => Protocol.stream(model, context,
 * - `stream.resolveProtocolProvider(...)` exposes protocol resolution for advanced integrations.
 */
 const stream = Object.assign(streamImpl, {
-	complete: Protocol.complete,
-	resolveProtocolProvider: Protocol.resolveProtocolProvider
+	complete,
+	resolveProtocolProvider
 });
-Protocol.complete;
 //#endregion
 //#region src/utils/validation.ts
 const validators = /* @__PURE__ */ new WeakMap();
@@ -1478,6 +1677,6 @@ function validateToolArguments(tool, toolExecution) {
 	return validateSchema(tool.parameters, toolExecution.rawArgs, `Tool "${toolExecution.name}"`);
 }
 //#endregion
-export { Event, EventStream, Message, Model, Protocol, ThinkingBudgets, Type, createAssistantMessageEventStream, createOpenAICodex, llm, openaiCodex, stream, validateSchema, validateToolArguments, validateToolCall };
+export { event_exports as Event, EventStream, message_exports as Message, model_exports as Model, protocol_exports as Protocol, ThinkingBudgets, Type, createAssistantMessageEventStream, createOpenAICodex, llm, openAICodexTools, openaiCodex, stream, validateSchema, validateToolArguments, validateToolCall };
 
 //# sourceMappingURL=index.mjs.map