@codeworksh/aikit 0.1.0 → 0.2.1

package/index.mjs

@@ -0,0 +1,2342 @@
+import { Filesystem, NamedError, lazy } from "@codeworksh/utils";
+import { Type } from "@sinclair/typebox";
+import { uuidv7 } from "uuidv7";
+import { keys, mapValues, pick, pipe } from "remeda";
+import Anthropic from "@anthropic-ai/sdk";
+import { parse } from "partial-json";
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+//#region src/provider/provider.ts
+let Provider;
+(function(_Provider) {
+	const KnownProviderEnum = _Provider.KnownProviderEnum = {
+		anthropic: "anthropic",
+		openai: "openai"
+	};
+	const KnownProviderSchema = _Provider.KnownProviderSchema = Type.Union([Type.Literal(KnownProviderEnum.anthropic), Type.Literal(KnownProviderEnum.openai)]);
+	_Provider.Info = Type.Object({
+		id: KnownProviderSchema,
+		name: Type.String(),
+		env: Type.Array(Type.String()),
+		key: Type.Optional(Type.String()),
+		options: Type.Optional(Type.Record(Type.String(), Type.Any()))
+	});
+	_Provider.ReasoningEffortMapSchema = Type.Object({
+		minimal: Type.Optional(Type.String()),
+		low: Type.Optional(Type.String()),
+		medium: Type.Optional(Type.String()),
+		high: Type.Optional(Type.String()),
+		xhigh: Type.Optional(Type.String())
+	});
+	_Provider.OpenRouterRoutingSchema = Type.Object({
+		only: Type.Optional(Type.Array(Type.String())),
+		order: Type.Optional(Type.Array(Type.String()))
+	});
+	_Provider.VercelGatewayRoutingSchema = Type.Object({
+		only: Type.Optional(Type.Array(Type.String())),
+		order: Type.Optional(Type.Array(Type.String()))
+	});
+})(Provider || (Provider = {}));
+//#endregion
+//#region src/model/catalog.ts
+let ModelCatalog;
+(function(_ModelCatalog) {
+	function modelsDevURL() {
+		return process.env.OPENCODE_MODELS_URL || "https://models.dev";
+	}
+	function modelsDevPath() {
+		return process.env.CODEWORK_AIKIT_MODELS_PATH;
+	}
+	const modelsDevData = _ModelCatalog.modelsDevData = lazy(async () => {
+		const path = modelsDevPath();
+		if (path) {
+			const result = await Filesystem.readJson(path).catch(() => void 0);
+			if (result) return result;
+		}
+		const json = await fetch(`${modelsDevURL()}/api.json`).then((x) => x.text());
+		return JSON.parse(json);
+	});
+	async function get() {
+		return modelsDevData();
+	}
+	_ModelCatalog.get = get;
+	async function refresh() {
+		const result = await fetch(`${modelsDevURL()}/api.json`, { signal: AbortSignal.timeout(10 * 1e3) }).catch(() => void 0);
+		if (!result?.ok) return;
+		const json = await result.text();
+		const path = modelsDevPath();
+		if (path) await Filesystem.write(path, json);
+		modelsDevData.reset();
+	}
+	_ModelCatalog.refresh = refresh;
+	ModelCatalog.refresh();
+	setInterval(async () => {
+		await ModelCatalog.refresh();
+	}, 60 * 1e3 * 60).unref();
+})(ModelCatalog || (ModelCatalog = {}));
+//#endregion
+//#region src/model/model.ts
+let Model;
+(function(_Model) {
+	const KnownProtocolEnum = _Model.KnownProtocolEnum = {
+		anthropicMessages: "anthropic-messages",
+		openaiCompletions: "openai-completions",
+		openaiResponses: "openai-responses"
+	};
+	_Model.KnownProtocolSchema = Type.Union([
+		Type.Literal(KnownProtocolEnum.anthropicMessages),
+		Type.Literal(KnownProtocolEnum.openaiCompletions),
+		Type.Literal(KnownProtocolEnum.openaiResponses)
+	]);
+	const InputSchema = Type.Array(Type.Union([Type.Literal("text"), Type.Literal("image")]));
+	const CostSchema = Type.Object({
+		input: Type.Number(),
+		output: Type.Number(),
+		cacheRead: Type.Number(),
+		cacheWrite: Type.Number()
+	});
+	const HeadersSchema = Type.Optional(Type.Record(Type.String(), Type.String()));
+	const BaseSchema = _Model.BaseSchema = Type.Object({
+		id: Type.String(),
+		name: Type.String(),
+		provider: Provider.Info,
+		baseUrl: Type.String(),
+		reasoning: Type.Boolean(),
+		input: InputSchema,
+		cost: CostSchema,
+		contextWindow: Type.Number(),
+		maxTokens: Type.Number(),
+		headers: HeadersSchema
+	});
+	const OpenAICompletionsCompatSchema = _Model.OpenAICompletionsCompatSchema = Type.Object({
+		supportsStore: Type.Optional(Type.Boolean()),
+		supportsDeveloperRole: Type.Optional(Type.Boolean()),
+		supportsReasoningEffort: Type.Optional(Type.Boolean()),
+		reasoningEffortMap: Type.Optional(Provider.ReasoningEffortMapSchema),
+		supportsUsageInStreaming: Type.Optional(Type.Boolean()),
+		maxTokensField: Type.Optional(Type.Union([Type.Literal("max_completion_tokens"), Type.Literal("max_tokens")])),
+		requiresToolResultName: Type.Optional(Type.Boolean()),
+		requiresAssistantAfterToolResult: Type.Optional(Type.Boolean()),
+		requiresThinkingAsText: Type.Optional(Type.Boolean()),
+		thinkingFormat: Type.Optional(Type.Union([
+			Type.Literal("openai"),
+			Type.Literal("openrouter"),
+			Type.Literal("zai"),
+			Type.Literal("qwen"),
+			Type.Literal("qwen-chat-template")
+		])),
+		openRouterRouting: Type.Optional(Provider.OpenRouterRoutingSchema),
+		vercelGatewayRouting: Type.Optional(Provider.VercelGatewayRoutingSchema),
+		supportsStrictMode: Type.Optional(Type.Boolean())
+	});
+	const OpenAIResponsesCompatSchema = _Model.OpenAIResponsesCompatSchema = Type.Object({});
+	_Model.OpenAICompatSchema = Type.Union([OpenAICompletionsCompatSchema, OpenAIResponsesCompatSchema]);
+	const AnthropicSchema = _Model.AnthropicSchema = Type.Composite([BaseSchema, Type.Object({ protocol: Type.Literal(KnownProtocolEnum.anthropicMessages) })]);
+	const OpenAICompletionsSchema = _Model.OpenAICompletionsSchema = Type.Composite([BaseSchema, Type.Object({
+		protocol: Type.Literal(KnownProtocolEnum.openaiCompletions),
+		compat: Type.Optional(OpenAICompletionsCompatSchema)
+	})]);
+	const OpenAIResponsesSchema = _Model.OpenAIResponsesSchema = Type.Composite([BaseSchema, Type.Object({
+		protocol: Type.Literal(KnownProtocolEnum.openaiResponses),
+		compat: Type.Optional(OpenAIResponsesCompatSchema)
+	})]);
+	_Model.Schema = Type.Union([
+		AnthropicSchema,
+		OpenAICompletionsSchema,
+		OpenAIResponsesSchema
+	]);
+	const BUILTINS = keys(Provider.KnownProviderEnum);
+	function calculateCost(model, usage) {
+		usage.cost.input = usage.input / 1e6 * model.cost.input;
+		usage.cost.output = usage.output / 1e6 * model.cost.output;
+		usage.cost.cacheRead = usage.cacheRead / 1e6 * model.cost.cacheRead;
+		usage.cost.cacheWrite = usage.cacheWrite / 1e6 * model.cost.cacheWrite;
+		usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+	}
+	_Model.calculateCost = calculateCost;
+	function resolveProtocol(providerId) {
+		switch (providerId) {
+			case Provider.KnownProviderEnum.anthropic: return KnownProtocolEnum.anthropicMessages;
+			case Provider.KnownProviderEnum.openai: return KnownProtocolEnum.openaiResponses;
+		}
+	}
+	function normalizeInput(input) {
+		const normalized = /* @__PURE__ */ new Set();
+		for (const modality of input ?? ["text"]) if (modality === "text" || modality === "image") normalized.add(modality);
+		if (normalized.size === 0) normalized.add("text");
+		return [...normalized];
+	}
+	function toProviderInfo(providerId, provider) {
+		return {
+			id: providerId,
+			name: provider.name,
+			env: provider.env,
+			key: provider.key,
+			options: provider.headers
+		};
+	}
+	function toModelValue(providerId, provider, model) {
+		const baseUrl = model.baseUrl ?? provider.baseUrl ?? provider.api;
+		return {
+			id: model.id,
+			name: model.name,
+			provider: toProviderInfo(providerId, provider),
+			baseUrl,
+			reasoning: Boolean(model.reasoning),
+			input: normalizeInput(model.modalities.input),
+			cost: {
+				input: model.cost?.input ?? 0,
+				output: model.cost?.output ?? 0,
+				cacheRead: model.cost?.cache_read ?? 0,
+				cacheWrite: model.cost?.cache_write ?? 0
+			},
+			contextWindow: model.limit?.context ?? 0,
+			maxTokens: model.limit?.output ?? 0,
+			headers: model.headers ?? provider.headers,
+			protocol: resolveProtocol(providerId)
+		};
+	}
+	async function getBuiltInModels() {
+		return pipe(await ModelCatalog.get(), pick(BUILTINS), mapValues((provider, providerId) => mapValues(provider.models, (model) => toModelValue(providerId, provider, model))));
+	}
+	_Model.getBuiltInModels = getBuiltInModels;
+	const registry = _Model.registry = lazy(async () => {
+		const registry = /* @__PURE__ */ new Map();
+		const models = await getBuiltInModels();
+		for (const [provider, value] of Object.entries(models)) {
+			const providerModels = /* @__PURE__ */ new Map();
+			for (const [id, model] of Object.entries(value)) providerModels.set(id, model);
+			registry.set(provider, providerModels);
+		}
+		return registry;
+	});
+	async function getModel(provider, model) {
+		return (await registry()).get(provider)?.get(model);
+	}
+	_Model.getModel = getModel;
+	async function getProviders() {
+		const data = await registry();
+		return Array.from(data.keys());
+	}
+	_Model.getProviders = getProviders;
+	async function getModels(provider) {
+		const models = (await registry()).get(provider);
+		return models ? Array.from(models.values()) : [];
+	}
+	_Model.getModels = getModels;
+	function isGpt5OrLater(modelID) {
+		const match = /^gpt-(\d+)/.exec(modelID);
+		if (!match) return false;
+		return Number(match[1]) >= 5;
+	}
+	function supportsXhigh(model) {
+		return isGpt5OrLater(model.id);
+	}
+	_Model.supportsXhigh = supportsXhigh;
+	function modelsAreEqual(a, b) {
+		if (!a || !b) return false;
+		return a.id === b.id && a.provider.id === b.provider.id;
+	}
+	_Model.modelsAreEqual = modelsAreEqual;
+})(Model || (Model = {}));
+//#endregion
+//#region src/message/message.ts
+let Message;
+(function(_Message) {
+	const TextContentSchema = _Message.TextContentSchema = Type.Object({
+		type: Type.Literal("text"),
+		text: Type.String(),
+		textSignature: Type.Optional(Type.String())
+	});
+	const ImageContentSchema = _Message.ImageContentSchema = Type.Object({
+		type: Type.Literal("image"),
+		data: Type.String(),
+		mimeType: Type.String()
+	});
+	const ThinkingContentSchema = _Message.ThinkingContentSchema = Type.Object({
+		type: Type.Literal("thinking"),
+		thinking: Type.String(),
+		thinkingSignature: Type.Optional(Type.String()),
+		redacted: Type.Optional(Type.Boolean())
+	});
+	const ToolCallBaseSchema = _Message.ToolCallBaseSchema = Type.Object({
+		type: Type.Literal("toolCall"),
+		callID: Type.String(),
+		name: Type.String(),
+		arguments: Type.Record(Type.String(), Type.Any()),
+		thoughtSignature: Type.Optional(Type.String()),
+		time: Type.Object({
+			start: Type.Number(),
+			end: Type.Number()
+		})
+	});
+	const ToolSuccessResult = _Message.ToolSuccessResult = Type.Object({
+		content: Type.Array(Type.Union([TextContentSchema, ImageContentSchema])),
+		details: Type.Optional(Type.Any()),
+		isError: Type.Literal(false)
+	});
+	const ToolErrorResult = _Message.ToolErrorResult = Type.Object({
+		content: Type.Array(Type.Union([TextContentSchema, ImageContentSchema])),
+		details: Type.Optional(Type.Any()),
+		isError: Type.Literal(true)
+	});
+	const ToolRunningPartial = _Message.ToolRunningPartial = Type.Object({
+		content: Type.Optional(Type.Array(Type.Union([TextContentSchema, ImageContentSchema]))),
+		details: Type.Optional(Type.Any())
+	});
+	const ToolStatusEnum = _Message.ToolStatusEnum = {
+		pending: "pending",
+		running: "running",
+		completed: "completed",
+		error: "error",
+		skipped: "skipped",
+		aborted: "aborted"
+	};
+	const ToolRunningSchema = _Message.ToolRunningSchema = Type.Object({
+		status: Type.Literal(ToolStatusEnum.running),
+		partial: Type.Optional(ToolRunningPartial)
+	});
+	const ToolCompletedSchema = _Message.ToolCompletedSchema = Type.Object({
+		status: Type.Literal(ToolStatusEnum.completed),
+		result: ToolSuccessResult
+	});
+	const ToolErrorSchema = _Message.ToolErrorSchema = Type.Object({
+		status: Type.Literal(ToolStatusEnum.error),
+		result: ToolErrorResult
+	});
+	const ToolSkippedSchema = _Message.ToolSkippedSchema = Type.Object({
+		status: Type.Literal(ToolStatusEnum.skipped),
+		result: ToolErrorResult
+	});
+	const ToolAbortedSchema = _Message.ToolAbortedSchema = Type.Object({
+		status: Type.Literal(ToolStatusEnum.aborted),
+		result: ToolErrorResult
+	});
+	const ToolCallPendingPart = Type.Intersect([ToolCallBaseSchema, Type.Object({ status: Type.Literal(ToolStatusEnum.pending) })]);
+	const ToolCallRunningPart = Type.Composite([ToolCallBaseSchema, ToolRunningSchema]);
+	const ToolCallCompletedPart = Type.Composite([ToolCallBaseSchema, ToolCompletedSchema]);
+	const ToolCallErrorPart = Type.Composite([ToolCallBaseSchema, ToolErrorSchema]);
+	const ToolCallSkippedPart = Type.Composite([ToolCallBaseSchema, ToolSkippedSchema]);
+	const ToolCallAbortedPart = Type.Composite([ToolCallBaseSchema, ToolAbortedSchema]);
+	const ToolCallSchema = _Message.ToolCallSchema = Type.Union([
+		ToolCallPendingPart,
+		ToolCallRunningPart,
+		ToolCallCompletedPart,
+		ToolCallErrorPart,
+		ToolCallSkippedPart,
+		ToolCallAbortedPart
+	]);
+	const UsageSchema = _Message.UsageSchema = Type.Object({
+		input: Type.Number(),
+		output: Type.Number(),
+		cacheRead: Type.Number(),
+		cacheWrite: Type.Number(),
+		totalTokens: Type.Number(),
+		cost: Type.Object({
+			input: Type.Number(),
+			output: Type.Number(),
+			cacheRead: Type.Number(),
+			cacheWrite: Type.Number(),
+			total: Type.Number()
+		})
+	});
+	const StopReasonSchema = _Message.StopReasonSchema = Type.Union([
+		Type.Literal("stop"),
+		Type.Literal("length"),
+		Type.Literal("toolUse"),
+		Type.Literal("error"),
+		Type.Literal("aborted")
+	]);
+	const UserMessageSchema = _Message.UserMessageSchema = Type.Object({
+		messageId: Type.String(),
+		role: Type.Literal("user"),
+		time: Type.Object({ created: Type.Number() }),
+		parts: Type.Array(Type.Union([TextContentSchema, ImageContentSchema]))
+	});
+	const AssistantMessageSchema = _Message.AssistantMessageSchema = Type.Object({
+		role: Type.Literal("assistant"),
+		protocol: Model.KnownProtocolSchema,
+		provider: Provider.Info,
+		model: Type.String(),
+		usage: UsageSchema,
+		stopReason: StopReasonSchema,
+		errorMessage: Type.Optional(Type.String()),
+		time: Type.Object({
+			created: Type.Number(),
+			completed: Type.Number()
+		}),
+		parts: Type.Array(Type.Union([
+			TextContentSchema,
+			ImageContentSchema,
+			ThinkingContentSchema,
+			ToolCallSchema
+		])),
+		responseId: Type.Optional(Type.String()),
+		messageId: Type.String()
+	});
+	const MessageSchema = _Message.MessageSchema = Type.Union([UserMessageSchema, AssistantMessageSchema]);
+	function createMessageId() {
+		return uuidv7();
+	}
+	_Message.createMessageId = createMessageId;
+	function createUserMessage(message) {
+		const { messageId = createMessageId(), ...rest } = message;
+		return {
+			messageId,
+			...rest
+		};
+	}
+	_Message.createUserMessage = createUserMessage;
+	function createAssistantMessage(message) {
+		const { messageId = createMessageId(), ...rest } = message;
+		return {
+			messageId,
+			...rest
+		};
+	}
+	_Message.createAssistantMessage = createAssistantMessage;
+	const ToolSchema = _Message.ToolSchema = Type.Object({
+		name: Type.String(),
+		description: Type.String(),
+		parameters: Type.Unsafe()
+	});
+	function defineTool(tool) {
+		return tool;
+	}
+	_Message.defineTool = defineTool;
+	_Message.ContextSchema = Type.Object({
+		systemPrompt: Type.Optional(Type.String()),
+		messages: Type.Array(MessageSchema),
+		tools: Type.Optional(Type.Array(ToolSchema))
+	});
+	function transformMessages(messages, model, normalizeToolCallId) {
+		const toolCallIDMap = /* @__PURE__ */ new Map();
+		const transformed = [];
+		for (const msg of messages) {
+			if (msg.role === "user") {
+				transformed.push(msg);
+				continue;
+			}
+			const assistantMsg = msg;
+			const isSameModel = assistantMsg.provider.id === model.provider.id && assistantMsg.protocol === model.protocol && assistantMsg.model === model.id;
+			const parts = assistantMsg.parts.flatMap((block) => {
+				if (block.type === "thinking") {
+					if (isSameModel && block.thinkingSignature) return block;
+					if (!block.thinking || block.thinking.trim() === "") return [];
+					if (isSameModel) return block;
+					return {
+						type: "text",
+						text: block.thinking
+					};
+				}
+				if (block.type === "text") {
+					if (isSameModel) return block;
+					return {
+						type: "text",
+						text: block.text
+					};
+				}
+				if (block.type === "toolCall") {
+					const toolCall = block;
+					let normalizedToolCall = toolCall;
+					if (!isSameModel && toolCall.thoughtSignature) {
+						normalizedToolCall = { ...toolCall };
+						delete normalizedToolCall.thoughtSignature;
+					}
+					const normalizedID = toolCallIDMap.get(block.callID);
+					if (normalizedID && normalizedID !== block.callID) normalizedToolCall = {
+						...normalizedToolCall,
+						callID: normalizedID
+					};
+					else if (!isSameModel && normalizeToolCallId) {
+						const nextID = normalizeToolCallId(toolCall.callID, model, assistantMsg);
+						if (nextID !== toolCall.callID) {
+							toolCallIDMap.set(toolCall.callID, nextID);
+							normalizedToolCall = {
+								...normalizedToolCall,
+								callID: nextID
+							};
+						}
+					}
+					return normalizedToolCall;
+				}
+				return block;
+			});
+			transformed.push({
+				...assistantMsg,
+				parts
+			});
+		}
+		return transformed;
+	}
+	_Message.transformMessages = transformMessages;
+})(Message || (Message = {}));
+//#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");
+		});
+	}
+};
+//#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 {
+		try {
+			return parse(partialJson) ?? {};
+		} catch {
+			return {};
+		}
+	}
+}
+//#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/provider/stream.ts
+let Stream;
+(function(_Stream) {
+	const ProtocolProviderNotFoundError = _Stream.ProtocolProviderNotFoundError = NamedError.create("ProtocolProviderNotFoundError", Type.Object({ protocol: Model.KnownProtocolSchema }));
+	const ProtocolMismatchError = _Stream.ProtocolMismatchError = NamedError.create("ProtocolMismatchError", Type.Object({
+		actual: Model.KnownProtocolSchema,
+		expected: Model.KnownProtocolSchema
+	}));
+	const ThinkingLevelEnum = _Stream.ThinkingLevelEnum = {
+		off: "off",
+		minimal: "minimal",
+		low: "low",
+		medium: "medium",
+		high: "high",
+		xhigh: "xhigh"
+	};
+	const ThinkingLevelSchema = _Stream.ThinkingLevelSchema = Type.Union([
+		Type.Literal(ThinkingLevelEnum.off),
+		Type.Literal(ThinkingLevelEnum.minimal),
+		Type.Literal(ThinkingLevelEnum.low),
+		Type.Literal(ThinkingLevelEnum.medium),
+		Type.Literal(ThinkingLevelEnum.high),
+		Type.Literal(ThinkingLevelEnum.xhigh)
+	]);
+	const ThinkingBudgetsSchema = _Stream.ThinkingBudgetsSchema = Type.Object({
+		off: Type.Optional(Type.Number()),
+		minimal: Type.Optional(Type.Number()),
+		low: Type.Optional(Type.Number()),
+		medium: Type.Optional(Type.Number()),
+		high: Type.Optional(Type.Number())
+	});
+	const CacheRetentionSchema = _Stream.CacheRetentionSchema = Type.Union([
+		Type.Literal("none"),
+		Type.Literal("short"),
+		Type.Literal("long")
+	]);
+	const TransportSchema = _Stream.TransportSchema = Type.Union([
+		Type.Literal("sse"),
+		Type.Literal("websocket"),
+		Type.Literal("auto")
+	]);
+	const OptionsSchema = _Stream.OptionsSchema = Type.Object({
+		temperature: Type.Optional(Type.Number()),
+		maxTokens: Type.Optional(Type.Number()),
+		signal: Type.Optional(Type.Unsafe()),
+		apiKey: Type.Optional(Type.String()),
+		transport: Type.Optional(TransportSchema),
+		cacheRetention: Type.Optional(CacheRetentionSchema),
+		sessionId: Type.Optional(Type.String()),
+		onPayload: Type.Optional(Type.Unsafe()),
+		headers: Type.Optional(Type.Record(Type.String(), Type.String())),
+		maxRetryDelayMs: Type.Optional(Type.Number()),
+		metadata: Type.Optional(Type.Record(Type.String(), Type.Unknown()))
+	});
+	_Stream.SimpleOptionsSchema = Type.Composite([OptionsSchema, Type.Object({
+		reasoning: Type.Optional(ThinkingLevelSchema),
+		thinkingBudgets: Type.Optional(ThinkingBudgetsSchema)
+	})]);
+	function buildBaseOptions(model, options, apiKey) {
+		return {
+			temperature: options?.temperature,
+			maxTokens: options?.maxTokens || Math.min(model.maxTokens, 32e3),
+			signal: options?.signal,
+			apiKey: apiKey || options?.apiKey,
+			transport: options?.transport,
+			cacheRetention: options?.cacheRetention,
+			sessionId: options?.sessionId,
+			headers: options?.headers,
+			onPayload: options?.onPayload,
+			maxRetryDelayMs: options?.maxRetryDelayMs,
+			metadata: options?.metadata
+		};
+	}
+	_Stream.buildBaseOptions = buildBaseOptions;
+	function clampReasoning(effort) {
+		return effort === ThinkingLevelEnum.xhigh ? ThinkingLevelEnum.high : effort;
+	}
+	_Stream.clampReasoning = clampReasoning;
+	function adjustMaxTokensForThinking(baseMaxTokens, modelMaxTokens, reasoningLevel, customBudgets) {
+		const budgets = {
+			minimal: 1024,
+			low: 2048,
+			medium: 8192,
+			high: 16384,
+			...customBudgets
+		};
+		const minOutputTokens = 1024;
+		let thinkingBudget = budgets[clampReasoning(reasoningLevel)];
+		const maxTokens = Math.min(baseMaxTokens + thinkingBudget, modelMaxTokens);
+		if (maxTokens <= thinkingBudget) thinkingBudget = Math.max(0, maxTokens - minOutputTokens);
+		return {
+			maxTokens,
+			thinkingBudget
+		};
+	}
+	_Stream.adjustMaxTokensForThinking = adjustMaxTokensForThinking;
+	const protocolProviderRegistry = /* @__PURE__ */ new Map();
+	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 wrapStreamSimple(protocol, streamSimple) {
+		return (model, context, options) => {
+			if (model.protocol !== protocol) throw new ProtocolMismatchError({
+				actual: model.protocol,
+				expected: protocol
+			});
+			return streamSimple(model, context, options);
+		};
+	}
+	function registerProtocolProvider(provider, sourceId) {
+		protocolProviderRegistry.set(provider.protocol, {
+			provider: {
+				protocol: provider.protocol,
+				stream: wrapStream(provider.protocol, provider.stream),
+				streamSimple: wrapStreamSimple(provider.protocol, provider.streamSimple)
+			},
+			sourceId
+		});
+	}
+	_Stream.registerProtocolProvider = registerProtocolProvider;
+	function getProtocolProvider(protocol) {
+		return protocolProviderRegistry.get(protocol)?.provider;
+	}
+	_Stream.getProtocolProvider = getProtocolProvider;
+	function resolveProtocolProvider(model) {
+		const provider = getProtocolProvider(model.protocol);
+		if (!provider) throw new ProtocolProviderNotFoundError({ protocol: model.protocol });
+		return provider;
+	}
+	_Stream.resolveProtocolProvider = resolveProtocolProvider;
+	function stream(model, context, options) {
+		return resolveProtocolProvider(model).stream(model, context, options);
+	}
+	_Stream.stream = stream;
+	async function complete(model, context, options) {
+		return stream(model, context, options).result();
+	}
+	_Stream.complete = complete;
+	function streamSimple(model, context, options) {
+		return resolveProtocolProvider(model).streamSimple(model, context, options);
+	}
+	_Stream.streamSimple = streamSimple;
+	async function completeSimple(model, context, options) {
+		return streamSimple(model, context, options).result();
+	}
+	_Stream.completeSimple = completeSimple;
+	function getApiProviders() {
+		return Array.from(protocolProviderRegistry.values(), (entry) => entry.provider);
+	}
+	_Stream.getApiProviders = getApiProviders;
+	function unregisterProtocolProviders(sourceId) {
+		for (const [api, entry] of protocolProviderRegistry.entries()) if (entry.sourceId === sourceId) protocolProviderRegistry.delete(api);
+	}
+	_Stream.unregisterProtocolProviders = unregisterProtocolProviders;
+	function clearProtocolProviders() {
+		protocolProviderRegistry.clear();
+	}
+	_Stream.clearProtocolProviders = clearProtocolProviders;
+})(Stream || (Stream = {}));
+//#endregion
+//#region src/provider/providers/anthropic/index.ts
+function getEnvApiKey(_provider) {}
+function resolveCacheRetention(cacheRetention) {
+	if (cacheRetention) return cacheRetention;
+	if (typeof process !== "undefined" && process.env.CODEWORK_CACHE_RETENTION === "long") return "long";
+	return "short";
+}
+function getCacheControl(baseUrl, cacheRetention) {
+	const retention = resolveCacheRetention(cacheRetention);
+	if (retention === "none") return { retention };
+	const ttl = retention === "long" && baseUrl.includes("api.anthropic.com") ? "1h" : void 0;
+	return {
+		retention,
+		cacheControl: {
+			type: "ephemeral",
+			...ttl && { ttl }
+		}
+	};
+}
+const claudeCodeVersion = "2.1.2";
+const ccToolLookup = new Map([
+	"Read",
+	"Write",
+	"Edit",
+	"Bash",
+	"Grep",
+	"Glob",
+	"AskUserQuestion",
+	"EnterPlanMode",
+	"ExitPlanMode",
+	"KillShell",
+	"NotebookEdit",
+	"Skill",
+	"Task",
+	"TaskOutput",
+	"TodoWrite",
+	"WebFetch",
+	"WebSearch"
+].map((t) => [t.toLowerCase(), t]));
+const toClaudeCodeName = (name) => ccToolLookup.get(name.toLowerCase()) ?? name;
+const fromClaudeCodeName = (name, tools) => {
+	if (tools && tools.length > 0) {
+		const lowerName = name.toLowerCase();
+		const matchedTool = tools.find((tool) => tool.name.toLowerCase() === lowerName);
+		if (matchedTool) return matchedTool.name;
+	}
+	return name;
+};
+function convertContentBlocks(content) {
+	if (!content.some((c) => c.type === "image")) return sanitizeSurrogates(content.map((c) => c.text).join("\n"));
+	const blocks = content.map((block) => {
+		if (block.type === "text") return {
+			type: "text",
+			text: sanitizeSurrogates(block.text)
+		};
+		return {
+			type: "image",
+			source: {
+				type: "base64",
+				media_type: block.mimeType,
+				data: block.data
+			}
+		};
+	});
+	if (!blocks.some((b) => b.type === "text")) blocks.unshift({
+		type: "text",
+		text: "(see attached image)"
+	});
+	return blocks;
+}
+function mergeHeaders(...headerSources) {
+	const merged = {};
+	for (const headers of headerSources) if (headers) Object.assign(merged, headers);
+	return merged;
+}
+function isOAuthToken(apiKey) {
+	return apiKey.includes("sk-ant-oat");
+}
+function createClient(model, apiKey, interleavedThinking, optionsHeaders) {
+	const betaFeatures = ["fine-grained-tool-streaming-2025-05-14"];
+	if (interleavedThinking) betaFeatures.push("interleaved-thinking-2025-05-14");
+	if (isOAuthToken(apiKey)) {
+		const defaultHeaders = mergeHeaders({
+			accept: "application/json",
+			"anthropic-dangerous-direct-browser-access": "true",
+			"anthropic-beta": `claude-code-20250219,oauth-2025-04-20,${betaFeatures.join(",")}`,
+			"user-agent": `claude-cli/${claudeCodeVersion} (external, cli)`,
+			"x-app": "cli"
+		}, model.headers, optionsHeaders);
+		return {
+			client: new Anthropic({
+				apiKey: null,
+				authToken: apiKey,
+				baseURL: model.baseUrl,
+				defaultHeaders,
+				dangerouslyAllowBrowser: true
+			}),
+			isOAuthToken: true
+		};
+	}
+	const defaultHeaders = mergeHeaders({
+		accept: "application/json",
+		"anthropic-dangerous-direct-browser-access": "true",
+		"anthropic-beta": betaFeatures.join(",")
+	}, model.headers, optionsHeaders);
+	return {
+		client: new Anthropic({
+			apiKey,
+			baseURL: model.baseUrl,
+			dangerouslyAllowBrowser: true,
+			defaultHeaders
+		}),
+		isOAuthToken: false
+	};
+}
+function normalizeToolCallId(id) {
+	return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+}
+function assertReplayableAssistant(message) {
+	let sawToolCall = false;
+	let sawNonTerminalToolCall = false;
+	let sawTerminalToolCall = false;
+	for (const part of message.parts) {
+		if (part.type === "image") throw new Error("Anthropic replay does not support assistant image parts");
+		if (part.type === "toolCall") {
+			sawToolCall = true;
+			if (part.status === "pending" || part.status === "running") sawNonTerminalToolCall = true;
+			else sawTerminalToolCall = true;
+			continue;
+		}
+		if (sawToolCall) throw new Error("Assistant parts after a toolCall are not replayable for Anthropic");
+	}
+	if (sawToolCall && message.stopReason !== "toolUse") throw new Error("Assistant message with tool calls must have stopReason 'toolUse'");
+	if (!sawToolCall && message.stopReason === "toolUse") throw new Error("Assistant message with stopReason 'toolUse' must contain at least one toolCall");
+	if (sawTerminalToolCall && sawNonTerminalToolCall) throw new Error("Assistant message cannot mix terminal and non-terminal toolCall states");
+}
+function buildSyntheticToolResult(block) {
+	return {
+		type: "tool_result",
+		tool_use_id: block.callID,
+		content: convertContentBlocks([{
+			type: "text",
+			text: [
+				"<result>",
+				"No Result Provided",
+				"</result>"
+			].join("\n")
+		}]),
+		is_error: true
+	};
+}
+function convertMessages(messages, model, isOAuthToken, cacheControl) {
+	const params = [];
+	const transformedMessages = Message.transformMessages(messages, model, normalizeToolCallId);
+	for (const msg of transformedMessages) {
+		if (msg.role === "user") {
+			const blocks = msg.parts.map((item) => {
+				if (item.type === "text") return {
+					type: "text",
+					text: sanitizeSurrogates(item.text)
+				};
+				return {
+					type: "image",
+					source: {
+						type: "base64",
+						media_type: item.mimeType,
+						data: item.data
+					}
+				};
+			});
+			let filteredBlocks = !model.input.includes("image") ? blocks.filter((b) => b.type !== "image") : blocks;
+			filteredBlocks = filteredBlocks.filter((b) => b.type === "text" ? b.text.trim().length > 0 : true);
+			if (filteredBlocks.length === 0) continue;
+			params.push({
+				role: "user",
+				content: filteredBlocks
+			});
+			continue;
+		}
+		if (msg.stopReason === "error" || msg.stopReason === "aborted") continue;
+		assertReplayableAssistant(msg);
+		const assistantBlocks = [];
+		const toolResults = [];
+		for (const block of msg.parts) if (block.type === "text") {
+			if (block.text.trim().length === 0) continue;
+			assistantBlocks.push({
+				type: "text",
+				text: sanitizeSurrogates(block.text)
+			});
+		} else if (block.type === "thinking") {
+			if (block.thinking.trim().length === 0) continue;
+			if (!block.thinkingSignature || block.thinkingSignature.trim().length === 0) assistantBlocks.push({
+				type: "text",
+				text: sanitizeSurrogates(block.thinking)
+			});
+			else assistantBlocks.push({
+				type: "thinking",
+				thinking: sanitizeSurrogates(block.thinking),
+				signature: block.thinkingSignature
+			});
+		} else if (block.type === "toolCall") {
+			assistantBlocks.push({
+				type: "tool_use",
+				id: block.callID,
+				name: isOAuthToken ? toClaudeCodeName(block.name) : block.name,
+				input: block.arguments ?? {}
+			});
+			if (block.status === "pending" || block.status === "running") toolResults.push(buildSyntheticToolResult(block));
+			else toolResults.push({
+				type: "tool_result",
+				tool_use_id: block.callID,
+				content: convertContentBlocks(block.result.content),
+				is_error: block.result.isError
+			});
+		}
+		if (assistantBlocks.length > 0) params.push({
+			role: "assistant",
+			content: assistantBlocks
+		});
+		if (toolResults.length > 0) params.push({
+			role: "user",
+			content: toolResults
+		});
+	}
+	if (cacheControl && params.length > 0) {
+		const lastMessage = params[params.length - 1];
+		if (lastMessage.role === "user") {
+			if (Array.isArray(lastMessage.content)) {
+				const lastBlock = lastMessage.content[lastMessage.content.length - 1];
+				if (lastBlock && (lastBlock.type === "text" || lastBlock.type === "image" || lastBlock.type === "tool_result")) lastBlock.cache_control = cacheControl;
+			} else if (typeof lastMessage.content === "string") lastMessage.content = [{
+				type: "text",
+				text: lastMessage.content,
+				cache_control: cacheControl
+			}];
+		}
+	}
+	return params;
+}
+function convertTools(tools, isOAuthToken) {
+	if (!tools) return [];
+	return tools.map((tool) => {
+		const jsonSchema = tool.parameters;
+		return {
+			name: isOAuthToken ? toClaudeCodeName(tool.name) : tool.name,
+			description: tool.description,
+			input_schema: {
+				type: "object",
+				properties: jsonSchema.properties || {},
+				required: jsonSchema.required || []
+			}
+		};
+	});
+}
+function mapStopReason(reason) {
+	switch (reason) {
+		case "end_turn": return "stop";
+		case "max_tokens": return "length";
+		case "tool_use": return "toolUse";
+		case "pause_turn":
+		case "stop_sequence": return "stop";
+		case "refusal":
+		case "sensitive": return "error";
+		default: throw new Error("Unhandled Anthropic stop reason");
+	}
+}
+function buildParams(model, context, isOAuthToken, options) {
+	const { cacheControl } = getCacheControl(model.baseUrl, options?.cacheRetention);
+	const params = {
+		model: model.id,
+		messages: convertMessages(context.messages, model, isOAuthToken, cacheControl),
+		max_tokens: options?.maxTokens || model.maxTokens / 3 | 0,
+		stream: true
+	};
+	if (isOAuthToken) {
+		params.system = [{
+			type: "text",
+			text: "You are Claude Code, Anthropic's official CLI for Claude.",
+			...cacheControl ? { cache_control: cacheControl } : {}
+		}];
+		if (context.systemPrompt) params.system.push({
+			type: "text",
+			text: sanitizeSurrogates(context.systemPrompt),
+			...cacheControl ? { cache_control: cacheControl } : {}
+		});
+	} else if (context.systemPrompt) params.system = [{
+		type: "text",
+		text: sanitizeSurrogates(context.systemPrompt),
+		...cacheControl ? { cache_control: cacheControl } : {}
+	}];
+	if (options?.temperature !== void 0 && !options?.thinkingEnabled) params.temperature = options.temperature;
+	if (context.tools) params.tools = convertTools(context.tools, isOAuthToken);
+	if (options?.thinkingEnabled && model.reasoning) params.thinking = {
+		type: "enabled",
+		budget_tokens: options.thinkingBudgetTokens || 1024
+	};
+	if (options?.metadata) {
+		const userId = options.metadata.user_id;
+		if (typeof userId === "string") params.metadata = { user_id: userId };
+	}
+	if (options?.toolChoice) params.tool_choice = typeof options.toolChoice === "string" ? { type: options.toolChoice } : options.toolChoice;
+	return params;
+}
+const streamAnthropic = (model, context, options) => {
+	const stream = new AssistantMessageEventStream();
+	(async () => {
+		const output = Message.createAssistantMessage({
+			role: "assistant",
+			parts: [],
+			protocol: model.protocol,
+			provider: model.provider,
+			model: model.id,
+			usage: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				totalTokens: 0,
+				cost: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					total: 0
+				}
+			},
+			stopReason: "stop",
+			time: {
+				created: Date.now(),
+				completed: Date.now()
+			}
+		});
+		try {
+			let client;
+			let isOAuthToken;
+			if (options?.client) {
+				client = options.client;
+				isOAuthToken = false;
+			} else {
+				const apiKey = options?.apiKey ?? getEnvApiKey(model.provider);
+				if (!apiKey) throw new Error(`No API key for provider: ${model.provider.id}`);
+				const created = createClient(model, apiKey, options?.interleavedThinking ?? true, options?.headers);
+				client = created.client;
+				isOAuthToken = created.isOAuthToken;
+			}
+			let params = buildParams(model, context, isOAuthToken, options);
+			const nextParams = await options?.onPayload?.(params, model);
+			if (nextParams !== void 0) params = nextParams;
+			const anthropicStream = client.messages.stream({
+				...params,
+				stream: true
+			}, { signal: options?.signal });
+			stream.push({
+				type: "start",
+				partial: output
+			});
+			const blocks = output.parts;
+			for await (const event of anthropicStream) if (event.type === "message_start") {
+				output.responseId = event.message.id;
+				output.usage.input = event.message.usage.input_tokens || 0;
+				output.usage.output = event.message.usage.output_tokens || 0;
+				output.usage.cacheRead = event.message.usage.cache_read_input_tokens || 0;
+				output.usage.cacheWrite = event.message.usage.cache_creation_input_tokens || 0;
+				output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
+				Model.calculateCost(model, output.usage);
+			} else if (event.type === "content_block_start") {
+				if (event.content_block.type === "text") {
+					const block = {
+						type: "text",
+						text: "",
+						index: event.index
+					};
+					output.parts.push(block);
+					stream.push({
+						type: "text.start",
+						partIndex: output.parts.length - 1,
+						partial: output
+					});
+				} else if (event.content_block.type === "thinking") {
+					const block = {
+						type: "thinking",
+						thinking: "",
+						thinkingSignature: "",
+						index: event.index
+					};
+					output.parts.push(block);
+					stream.push({
+						type: "thinking.start",
+						partIndex: output.parts.length - 1,
+						partial: output
+					});
+				} else if (event.content_block.type === "redacted_thinking") {
+					const block = {
+						type: "thinking",
+						thinking: "[Reasoning redacted]",
+						thinkingSignature: event.content_block.data,
+						redacted: true,
+						index: event.index
+					};
+					output.parts.push(block);
+					stream.push({
+						type: "thinking.start",
+						partIndex: output.parts.length - 1,
+						partial: output
+					});
+				} else if (event.content_block.type === "tool_use") {
+					const block = {
+						type: "toolCall",
+						callID: event.content_block.id,
+						name: isOAuthToken ? fromClaudeCodeName(event.content_block.name, context.tools) : event.content_block.name,
+						arguments: event.content_block.input ?? {},
+						partialJson: "",
+						status: "pending",
+						time: {
+							start: Date.now(),
+							end: Date.now()
+						},
+						index: event.index
+					};
+					output.parts.push(block);
+					stream.push({
+						type: "toolcall.start",
+						partIndex: output.parts.length - 1,
+						partial: output
+					});
+				}
+			} else if (event.type === "content_block_delta") {
+				const partIndex = blocks.findIndex((b) => b.index === event.index);
+				const block = blocks[partIndex];
+				if (!block) continue;
+				if (event.delta.type === "text_delta" && block.type === "text") {
+					block.text += event.delta.text;
+					stream.push({
+						type: "text.delta",
+						partIndex,
+						delta: event.delta.text,
+						partial: output
+					});
+				} else if (event.delta.type === "thinking_delta" && block.type === "thinking") {
+					block.thinking += event.delta.thinking;
+					stream.push({
+						type: "thinking.delta",
+						partIndex,
+						delta: event.delta.thinking,
+						partial: output
+					});
+				} else if (event.delta.type === "input_json_delta" && block.type === "toolCall") {
+					block.partialJson += event.delta.partial_json;
+					block.arguments = parseStreamingJson(block.partialJson);
+					stream.push({
+						type: "toolcall.delta",
+						partIndex,
+						delta: event.delta.partial_json,
+						partial: output
+					});
+				} else if (event.delta.type === "signature_delta" && block.type === "thinking") {
+					block.thinkingSignature = block.thinkingSignature || "";
+					block.thinkingSignature += event.delta.signature;
+				}
+			} else if (event.type === "content_block_stop") {
+				const partIndex = blocks.findIndex((b) => b.index === event.index);
+				const block = blocks[partIndex];
+				if (block) {
+					delete block.index;
+					if (block.type === "text") stream.push({
+						type: "text.end",
+						partIndex,
+						content: block.text,
+						partial: output
+					});
+					else if (block.type === "thinking") stream.push({
+						type: "thinking.end",
+						partIndex,
+						content: block.thinking,
+						partial: output
+					});
+					else if (block.type === "toolCall") {
+						block.arguments = parseStreamingJson(block.partialJson);
+						delete block.partialJson;
+						stream.push({
+							type: "toolcall.end",
+							partIndex,
+							toolCall: block,
+							partial: output
+						});
+					}
+				}
+			} else if (event.type === "message_delta") {
+				if (event.delta.stop_reason) output.stopReason = mapStopReason(event.delta.stop_reason);
+				if (event.usage.input_tokens != null) output.usage.input = event.usage.input_tokens;
+				if (event.usage.output_tokens != null) output.usage.output = event.usage.output_tokens;
+				if (event.usage.cache_read_input_tokens != null) output.usage.cacheRead = event.usage.cache_read_input_tokens;
+				if (event.usage.cache_creation_input_tokens != null) output.usage.cacheWrite = event.usage.cache_creation_input_tokens;
+				output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
+				Model.calculateCost(model, output.usage);
+			}
+			if (options?.signal?.aborted) throw new Error("Request was aborted");
+			if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error("An unknown error occurred");
+			output.time.completed = Date.now();
+			stream.push({
+				type: "done",
+				reason: output.stopReason,
+				message: output
+			});
+			stream.end();
+		} catch (error) {
+			for (const block of output.parts) delete block.index;
+			output.time.completed = Date.now();
+			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+			output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+			stream.push({
+				type: "error",
+				reason: output.stopReason,
+				error: output
+			});
+			stream.end();
+		}
+	})();
+	return stream;
+};
+const streamSimpleAnthropic = (model, context, options) => {
+	const apiKey = options?.apiKey || getEnvApiKey(model.provider);
+	if (!apiKey) throw new Error(`No API key for provider: ${model.provider.id}`);
+	const base = Stream.buildBaseOptions(model, options, apiKey);
+	if (!options?.reasoning) return streamAnthropic(model, context, {
+		...base,
+		thinkingEnabled: false
+	});
+	const adjusted = Stream.adjustMaxTokensForThinking(base.maxTokens || 0, model.maxTokens, options.reasoning, options.thinkingBudgets);
+	return streamAnthropic(model, context, {
+		...base,
+		maxTokens: adjusted.maxTokens,
+		thinkingEnabled: true,
+		thinkingBudgetTokens: adjusted.thinkingBudget
+	});
+};
+//#endregion
+//#region src/provider/register.ts
+const providerModules = [["providers/anthropic/index.ts", {
+	protocol: Model.KnownProtocolEnum.anthropicMessages,
+	stream: streamAnthropic,
+	streamSimple: streamSimpleAnthropic
+}]];
+for (const [path, provider] of providerModules) Stream.registerProtocolProvider(provider, path);
+//#endregion
+//#region src/utils/validation.ts
+/**
+* @description Validation powered by ajv, TypeBox natively doesn't provide data validation.
+*/
+const ajv = new Ajv({
+	allErrors: true,
+	strict: false,
+	coerceTypes: true
+});
+addFormats(ajv);
+/**
+* Validates tool call arguments against the tool's TypeBox schema
+*/
+function validateToolArguments(tool, toolExecution) {
+	const validate = ajv.compile(tool.parameters);
+	const args = structuredClone(toolExecution.rawArgs);
+	if (validate(args)) return args;
+	const errors = validate.errors?.map((err) => {
+		return ` - ${err.instancePath ? err.instancePath.substring(1) : err.params?.missingProperty || "root"}: ${err.message}`;
+	}).join("\n") || "Unknown Validation Error";
+	throw new Error([
+		`Validation Failed For Tool "${toolExecution.name}"`,
+		`${errors}\n`,
+		"Received Arguments:",
+		`${JSON.stringify(toolExecution.rawArgs, null, 2)}\n`
+	].join("\n"));
+}
+//#endregion
+//#region src/agent/loop.ts
+let Loop;
+(function(_Loop) {
+	function createAgentStream() {
+		return new EventStream((event) => event.type === "agent.end", (event) => event.type === "agent.end" ? event.messages : []);
+	}
+	const AgentContextError = _Loop.AgentContextError = NamedError.create("AgentContextError", Type.Object({ message: Type.String() }));
+	function snapshotAssistantMessage(message) {
+		return structuredClone(message);
+	}
+	function snapshotAssistantPartEvent(message, partIndex) {
+		const snapshot = snapshotAssistantMessage(message);
+		const part = snapshot.parts[partIndex];
+		if (!part) throw new Error(`Assistant message part at index ${partIndex} was not found`);
+		return {
+			message: snapshot,
+			part
+		};
+	}
+	async function emitEvent(emit, event) {
+		await emit(event);
+	}
+	async function streamAssistantResponse(config, context, emit, streamFn, signal) {
+		let messages = context.messages;
+		if (config.transformContext) messages = await config.transformContext(messages, signal);
+		const llmMessages = await config.convertToLlm(messages);
+		const llmContext = {
+			systemPrompt: context.systemPrompt,
+			messages: llmMessages,
+			tools: context.tools
+		};
+		const streamFunction = streamFn || Stream.streamSimple;
+		const resolvedApiKey = (config.getApiKey ? await config.getApiKey(config.model.provider) : void 0) || config.apiKey;
+		const events = await streamFunction(config.model, llmContext, {
+			...config,
+			apiKey: resolvedApiKey,
+			signal
+		});
+		let partialMessage = null;
+		let started = false;
+		const ensureMessageStarted = async (message) => {
+			if (started) return;
+			started = true;
+			await emitEvent(emit, {
+				type: "message.start",
+				message: snapshotAssistantMessage(message)
+			});
+		};
+		const emitMessageUpdate = async (message) => {
+			await emitEvent(emit, {
+				type: "message.update",
+				message: snapshotAssistantMessage(message)
+			});
+		};
+		const emitPartStart = async (message, partIndex) => {
+			await emitEvent(emit, {
+				type: "message.part.start",
+				partIndex,
+				...snapshotAssistantPartEvent(message, partIndex)
+			});
+		};
+		const emitPartUpdate = async (message, partIndex) => {
+			await emitEvent(emit, {
+				type: "message.part.update",
+				partIndex,
+				...snapshotAssistantPartEvent(message, partIndex),
+				source: "llm"
+			});
+		};
+		const emitPartEnd = async (message, partIndex) => {
+			await emitEvent(emit, {
+				type: "message.part.end",
+				partIndex,
+				...snapshotAssistantPartEvent(message, partIndex)
+			});
+		};
+		for await (const event of events) switch (event.type) {
+			case "start":
+				partialMessage = event.partial;
+				await ensureMessageStarted(partialMessage);
+				break;
+			case "text.start":
+			case "thinking.start":
+			case "toolcall.start":
+				partialMessage = event.partial;
+				await ensureMessageStarted(partialMessage);
+				await emitPartStart(partialMessage, event.partIndex);
+				break;
+			case "text.delta":
+			case "thinking.delta":
+			case "toolcall.delta":
+				partialMessage = event.partial;
+				await ensureMessageStarted(partialMessage);
+				await emitPartUpdate(partialMessage, event.partIndex);
+				break;
+			case "text.end":
+			case "thinking.end":
+			case "toolcall.end":
+				partialMessage = event.partial;
+				await ensureMessageStarted(partialMessage);
+				await emitPartEnd(partialMessage, event.partIndex);
+				await emitMessageUpdate(partialMessage);
+				break;
+			case "done":
+				await ensureMessageStarted(event.message);
+				await emitEvent(emit, {
+					type: "message.end",
+					message: snapshotAssistantMessage(event.message)
+				});
+				return event.message;
+			case "error":
+				await ensureMessageStarted(event.error);
+				await emitEvent(emit, {
+					type: "message.end",
+					message: snapshotAssistantMessage(event.error)
+				});
+				return event.error;
+		}
+		const finalMessage = await events.result();
+		await ensureMessageStarted(finalMessage);
+		await emitEvent(emit, {
+			type: "message.end",
+			message: snapshotAssistantMessage(finalMessage)
+		});
+		return finalMessage;
+	}
+	async function executeToolCalls(config, currentContext, message, toolCalls, emit, signal) {
+		if (config.toolExecution === "sequential") return executeToolCallsSequential(config, currentContext, message, toolCalls, emit, signal);
+		return executeToolCallsParallel(config, currentContext, message, toolCalls, emit, signal);
+	}
+	async function executeToolCallsSequential(config, currentContext, message, toolCalls, emit, signal) {
+		for (const toolCall of toolCalls) {
+			const toolCallInFlight = {
+				callID: toolCall.callID,
+				name: toolCall.name,
+				rawArgs: toolCall.arguments
+			};
+			await emitEvent(emit, {
+				type: "tool.execution.start",
+				...toolCallInFlight
+			});
+			const prepared = await prepareToolCall(config, currentContext, message, toolCallInFlight, signal);
+			if (prepared.error) {
+				const error = {
+					status: "error",
+					result: {
+						content: [{
+							type: "text",
+							text: prepared.error.message
+						}],
+						details: prepared.error.details,
+						isError: true
+					}
+				};
+				await emitToolCallTerminalResult(toolCall, prepared.runnable, message, emit, error);
+			} else {
+				const runnable = {
+					toolCall,
+					runnable: prepared.runnable,
+					tool: prepared.tool
+				};
+				const executed = await executeRunnableToolCall(runnable, message, emit, signal);
+				if (executed.error) {
+					const error = {
+						status: "error",
+						result: {
+							content: [{
+								type: "text",
+								text: executed.error.message
+							}],
+							details: executed.error.details,
+							isError: true
+						}
+					};
+					await emitToolCallTerminalResult(runnable.toolCall, runnable.runnable, message, emit, error);
+				} else await finalizeExecutedToolCall(config, currentContext, runnable.toolCall, runnable.runnable, message, emit, executed.result);
+			}
+		}
+	}
+	async function executeToolCallsParallel(config, currentContext, message, toolCalls, emit, signal) {
+		const runnables = [];
+		for (const toolCall of toolCalls) {
+			const toolCallInFlight = {
+				callID: toolCall.callID,
+				name: toolCall.name,
+				rawArgs: toolCall.arguments
+			};
+			await emitEvent(emit, {
+				type: "tool.execution.start",
+				...toolCallInFlight
+			});
+			const prepared = await prepareToolCall(config, currentContext, message, toolCallInFlight, signal);
+			if (prepared.error) {
+				const error = {
+					status: "error",
+					result: {
+						content: [{
+							type: "text",
+							text: prepared.error.message
+						}],
+						details: prepared.error.details,
+						isError: true
+					}
+				};
+				await emitToolCallTerminalResult(toolCall, prepared.runnable, message, emit, error);
+			} else runnables.push({
+				toolCall,
+				runnable: prepared.runnable,
+				tool: prepared.tool
+			});
+		}
+		const runningExecutions = runnables.map((runnable) => ({
+			runnable,
+			execution: executeRunnableToolCall(runnable, message, emit, signal)
+		}));
+		for (const running of runningExecutions) {
+			const executed = await running.execution;
+			const { runnable } = running;
+			if (executed.error) {
+				const error = {
+					status: "error",
+					result: {
+						content: [{
+							type: "text",
+							text: executed.error.message
+						}],
+						details: executed.error.details,
+						isError: true
+					}
+				};
+				await emitToolCallTerminalResult(runnable.toolCall, runnable.runnable, message, emit, error);
+			} else await finalizeExecutedToolCall(config, currentContext, runnable.toolCall, runnable.runnable, message, emit, executed.result);
+		}
+	}
+	async function prepareToolCall(config, currentContext, assistantMessage, toolCallInFlight, signal) {
+		const tool = currentContext.tools?.find((t) => t.name === toolCallInFlight.name);
+		if (!tool) return {
+			error: {
+				kind: "error",
+				message: `Tool ${toolCallInFlight.name} Not Found`
+			},
+			runnable: toolCallInFlight
+		};
+		try {
+			toolCallInFlight.args = validateToolArguments(tool, toolCallInFlight);
+			if (config.beforeToolExecution) {
+				const beforeResult = await config.beforeToolExecution({
+					context: currentContext,
+					assistantMessage,
+					toolCall: toolCallInFlight
+				}, signal);
+				if (beforeResult?.block) return {
+					error: {
+						kind: "blocked",
+						message: beforeResult?.reason || "Tool Execution was Blocked",
+						details: beforeResult?.details
+					},
+					runnable: toolCallInFlight
+				};
+			}
+			return {
+				runnable: toolCallInFlight,
+				tool
+			};
+		} catch (err) {
+			return {
+				error: {
+					kind: "error",
+					message: err instanceof Error ? err.message : String(err)
+				},
+				runnable: toolCallInFlight
+			};
+		}
+	}
+	async function executeRunnableToolCall(toolCallRunnable, message, emit, signal) {
+		const { toolCall, runnable, tool } = toolCallRunnable;
+		const { partIndex, ...pendingPart } = toolCall;
+		try {
+			return { result: await tool.execute(runnable.callID, runnable.args, signal, async (result) => {
+				const runningResult = {
+					status: "running",
+					partial: result.partial
+				};
+				await emitEvent(emit, {
+					type: "tool.execution.update",
+					...runnable,
+					...runningResult
+				});
+				const runningPart = {
+					...pendingPart,
+					...runningResult
+				};
+				message.parts[partIndex] = runningPart;
+				await emitEvent(emit, {
+					type: "message.part.update",
+					message,
+					partIndex,
+					part: runningPart,
+					source: "tool"
+				});
+			}) };
+		} catch (err) {
+			return { error: { message: err instanceof Error ? err.message : String(err) } };
+		}
+	}
+	async function emitToolCallTerminalResult(toolCall, runnable, message, emit, result) {
+		const { partIndex, ...pendingPart } = toolCall;
+		const { time } = pendingPart;
+		await emitEvent(emit, {
+			type: "tool.execution.end",
+			...runnable,
+			...result
+		});
+		const part = {
+			...pendingPart,
+			...result,
+			time: {
+				start: time.start,
+				end: Date.now()
+			}
+		};
+		message.parts[partIndex] = part;
+		await emitEvent(emit, {
+			type: "message.part.start",
+			message,
+			partIndex,
+			part
+		});
+		await emitEvent(emit, {
+			type: "message.part.end",
+			message,
+			partIndex,
+			part
+		});
+		await emitEvent(emit, {
+			type: "message.update",
+			message
+		});
+	}
+	async function finalizeExecutedToolCall(config, currentContext, toolCall, runnable, message, emit, result, signal) {
+		if (config.afterToolExecution) {
+			const afterResult = await config.afterToolExecution({
+				context: currentContext,
+				assistantMessage: message,
+				toolCall: runnable,
+				result
+			}, signal);
+			if (afterResult) {
+				await emitToolCallTerminalResult(toolCall, runnable, message, emit, afterResult);
+				return;
+			}
+		}
+		await emitToolCallTerminalResult(toolCall, runnable, message, emit, result);
+	}
+	/**
+	* Main core loop shared by run and runContinue.
+	*/
+	async function runLoop(config, currentContext, newMessages, emit, streamFn, signal) {
+		let firstTurn = true;
+		let pendingMessages = await config.getSteeringMessages?.() || [];
+		while (true) {
+			let hasMoreToolCalls = true;
+			while (hasMoreToolCalls || pendingMessages.length > 0) {
+				if (!firstTurn) await emitEvent(emit, { type: "turn.start" });
+				else firstTurn = false;
+				if (pendingMessages.length > 0) {
+					for (const message of pendingMessages) {
+						await emitEvent(emit, {
+							type: "message.start",
+							message
+						});
+						for (const [partIndex, part] of message.parts.entries()) {
+							await emitEvent(emit, {
+								type: "message.part.start",
+								message,
+								partIndex,
+								part
+							});
+							await emitEvent(emit, {
+								type: "message.part.end",
+								message,
+								partIndex,
+								part
+							});
+							await emitEvent(emit, {
+								type: "message.update",
+								message
+							});
+						}
+						await emitEvent(emit, {
+							type: "message.end",
+							message
+						});
+						currentContext.messages.push(message);
+						newMessages.push(message);
+					}
+					pendingMessages = [];
+				}
+				const message = await streamAssistantResponse(config, currentContext, emit, streamFn, signal);
+				if (message.stopReason === "error" || message.stopReason === "aborted") {
+					currentContext.messages.push(message);
+					newMessages.push(message);
+					await emitEvent(emit, {
+						type: "turn.end",
+						message
+					});
+					await emitEvent(emit, {
+						type: "agent.end",
+						messages: newMessages
+					});
+					return;
+				}
+				const toolCalls = message.parts.map((part, index) => ({
+					...part,
+					partIndex: index
+				})).filter((part) => part.type === "toolCall" && part.status === "pending");
+				hasMoreToolCalls = toolCalls.length > 0;
+				if (hasMoreToolCalls) await executeToolCalls(config, currentContext, message, toolCalls, emit, signal);
+				currentContext.messages.push(message);
+				newMessages.push(message);
+				await emitEvent(emit, {
+					type: "turn.end",
+					message
+				});
+				pendingMessages = await config.getSteeringMessages?.() || [];
+			}
+			const followUpMessages = await config.getFollowUpMessages?.() || [];
+			if (followUpMessages.length > 0) {
+				pendingMessages = followUpMessages;
+				continue;
+			}
+			break;
+		}
+		await emitEvent(emit, {
+			type: "agent.end",
+			messages: newMessages
+		});
+	}
+	async function runAgentLoop(config, context, prompts, emit, streamFn, signal) {
+		/**
+		* maintain 2 arrays to represent state, `context` the actual full state sent to the LLM,
+		* `newMessages` for intermediate current loop state.
+		* think of newMessages as subset of context.messages for the running current loop.
+		* they do move at the same speed staring with initial user prompts.
+		* */
+		const newMessages = [...prompts];
+		const currentContext = {
+			...context,
+			messages: [...context.messages, ...prompts]
+		};
+		await emitEvent(emit, { type: "agent.start" });
+		await emitEvent(emit, { type: "turn.start" });
+		for (const prompt of prompts) {
+			await emitEvent(emit, {
+				type: "message.start",
+				message: prompt
+			});
+			for (const [partIndex, part] of prompt.parts.entries()) {
+				await emitEvent(emit, {
+					type: "message.part.start",
+					message: prompt,
+					partIndex,
+					part
+				});
+				await emitEvent(emit, {
+					type: "message.part.end",
+					message: prompt,
+					partIndex,
+					part
+				});
+			}
+			await emitEvent(emit, {
+				type: "message.end",
+				message: prompt
+			});
+		}
+		await runLoop(config, currentContext, newMessages, emit, streamFn, signal);
+		return newMessages;
+	}
+	_Loop.runAgentLoop = runAgentLoop;
+	async function runAgentLoopContinue(config, context, emit, streamFn, signal) {
+		if (context.messages.length === 0) throw new AgentContextError({ message: "connot continue: no messages in context" });
+		if (context.messages[context.messages.length - 1]?.role === "assistant") throw new AgentContextError({ message: "cannot continue from message role: assistant" });
+		const newMessages = [];
+		const currentContext = { ...context };
+		await emitEvent(emit, { type: "agent.start" });
+		await emitEvent(emit, { type: "turn.start" });
+		await runLoop(config, currentContext, newMessages, emit, streamFn, signal);
+		return newMessages;
+	}
+	_Loop.runAgentLoopContinue = runAgentLoopContinue;
+	function run(config, context, prompts, streamFn, signal) {
+		const stream = createAgentStream();
+		runAgentLoop(config, context, prompts, async (event) => {
+			stream.push(event);
+		}, streamFn, signal).then((messages) => {
+			stream.end(messages);
+		});
+		return stream;
+	}
+	_Loop.run = run;
+	function runContinue(config, context, streamFn, signal) {
+		const stream = createAgentStream();
+		runAgentLoopContinue(config, context, async (event) => {
+			stream.push(event);
+		}, streamFn, signal).then((messages) => {
+			stream.end(messages);
+		});
+		return stream;
+	}
+	_Loop.runContinue = runContinue;
+})(Loop || (Loop = {}));
+//#endregion
+//#region src/agent/agent.ts
+let Agent;
+(function(_Agent) {
+	_Agent.ToolTerminalResultSchema = Type.Union([Message.ToolCompletedSchema, Message.ToolErrorSchema]);
+	_Agent.ToolResultSchema = Type.Union([
+		Message.ToolRunningSchema,
+		Message.ToolCompletedSchema,
+		Message.ToolErrorSchema
+	]);
+	function defineTool(tool) {
+		return tool;
+	}
+	_Agent.defineTool = defineTool;
+	_Agent.ToolCallInFlightSchema = Type.Object({
+		callID: Type.String(),
+		name: Type.String(),
+		rawArgs: Type.Record(Type.String(), Type.Unknown()),
+		args: Type.Optional(Type.Unknown())
+	});
+	const ModelNotFoundErr = _Agent.ModelNotFoundErr = NamedError.create("ModelNotFoundErr", Type.Object({
+		message: Type.String(),
+		provider: Type.String(),
+		model: Type.String()
+	}));
+	const ModelNotConfiguredErr = _Agent.ModelNotConfiguredErr = NamedError.create("ModelNotConfiguredErr", Type.Object({ message: Type.String() }));
+	const AgentInStreamingErr = _Agent.AgentInStreamingErr = NamedError.create("AgentInStreamingErr", Type.Object({
+		message: Type.String(),
+		name: Type.String()
+	}));
+	class Instance {
+		_state;
+		listeners = /* @__PURE__ */ new Set();
+		abortController;
+		convertToLlm;
+		transformContext;
+		steeringQueue = [];
+		followUpQueue = [];
+		steeringMode;
+		followUpMode;
+		streamFn;
+		_sessionId;
+		getApiKey;
+		_onPayload;
+		runningPrompt;
+		resolveRunningPrompt;
+		_thinkingBudgets;
+		_transport;
+		_maxRetryDelayMs;
+		_toolExecution;
+		_beforeToolExecution;
+		_afterToolExecution;
+		constructor(name, model, opts = {}) {
+			this._state = {
+				systemPrompt: "",
+				thinkingLevel: "off",
+				tools: [],
+				messages: [],
+				isStreaming: false,
+				streamMessage: null,
+				pendingToolCalls: /* @__PURE__ */ new Set(),
+				error: void 0,
+				...opts.initialState,
+				name,
+				model
+			};
+			/**
+			* Transformation logic to prepare messages for the LLM.
+			* * @remarks
+			* Currently just forwards messages as-is. Modify this logic when
+			* specific formatting or filtering is required.
+			* A good example is using user message parts with custom content
+			* * @default
+			* forwards messages as is.
+			*/
+			this.convertToLlm = opts.convertToLlm || ((messages) => messages);
+			this.transformContext = opts.transformContext;
+			this.steeringMode = opts.steeringMode || "one-at-a-time";
+			this.followUpMode = opts.followUpMode || "one-at-a-time";
+			this.streamFn = opts.streamFn || Stream.streamSimple;
+			this._sessionId = opts.sessionId;
+			this.getApiKey = opts.getApiKey;
+			this._onPayload = opts.onPayload;
+			this._thinkingBudgets = opts.thinkingBudgets;
+			this._transport = opts.transport ?? "sse";
+			this._maxRetryDelayMs = opts.maxRetryDelayMs;
+			this._toolExecution = opts.toolExecution ?? "parallel";
+			this._beforeToolExecution = opts.beforeToolExecution;
+			this._afterToolExecution = opts.afterToolExecution;
+		}
+		/**
+		* Get the current session ID used for provider caching.
+		*/
+		get sessionId() {
+			return this._sessionId;
+		}
+		/**
+		* Set the session ID for provider caching.
+		* Call this when switching sessions (new session, branch, resume, etc).
+		*/
+		set sessionId(value) {
+			this._sessionId = value;
+		}
+		/**
+		* Get the current thinking budgets.
+		*/
+		get thinkingBudgets() {
+			return this._thinkingBudgets;
+		}
+		/**
+		* Set custom thinking budgets for token-based providers.
+		*/
+		set thinkingBudgets(value) {
+			this._thinkingBudgets = value;
+		}
+		/**
+		* Get the current preferred transport.
+		*/
+		get transport() {
+			return this._transport;
+		}
+		/**
+		* Set the preferred transport.
+		*/
+		setTransport(value) {
+			this._transport = value;
+		}
+		/**
+		* Get the current max retry delay in milliseconds.
+		*/
+		get maxRetryDelayMs() {
+			return this._maxRetryDelayMs;
+		}
+		/**
+		* Set the maximum delay to wait for server-requested retries.
+		* Set to 0 to disable the cap.
+		*/
+		set maxRetryDelayMs(value) {
+			this._maxRetryDelayMs = value;
+		}
+		get toolExecution() {
+			return this._toolExecution;
+		}
+		setToolExecution(value) {
+			this._toolExecution = value;
+		}
+		setBeforeToolExecution(value) {
+			this._beforeToolExecution = value;
+		}
+		setAfterToolExecution(value) {
+			this._afterToolExecution = value;
+		}
+		get state() {
+			return this._state;
+		}
+		subscribe(fn) {
+			this.listeners.add(fn);
+			return () => this.listeners.delete(fn);
+		}
+		setSystemPrompt(v) {
+			this._state.systemPrompt = v;
+		}
+		setModel(m) {
+			this._state.model = m;
+		}
+		setThinkingLevel(l) {
+			this._state.thinkingLevel = l;
+		}
+		setSteeringMode(mode) {
+			this.steeringMode = mode;
+		}
+		getSteeringMode() {
+			return this.steeringMode;
+		}
+		setFollowUpMode(mode) {
+			this.followUpMode = mode;
+		}
+		getFollowUpMode() {
+			return this.followUpMode;
+		}
+		setTools(t) {
+			this._state.tools = t;
+		}
+		replaceMessages(ms) {
+			this._state.messages = ms.slice();
+		}
+		appendMessage(m) {
+			this._state.messages = [...this._state.messages, m];
+		}
+		findMessageIndexById(messageId) {
+			return this._state.messages.findIndex((message) => message.messageId === messageId);
+		}
+		replaceMessageById(message) {
+			const messageIndex = this.findMessageIndexById(message.messageId);
+			if (messageIndex === -1) return false;
+			const messages = this._state.messages.slice();
+			messages[messageIndex] = message;
+			this._state.messages = messages;
+			return true;
+		}
+		upsertMessage(message) {
+			if (this.replaceMessageById(message)) return;
+			this.appendMessage(message);
+		}
+		patchStoredAssistantPart(messageId, partIndex, part) {
+			const messageIndex = this.findMessageIndexById(messageId);
+			if (messageIndex === -1) return false;
+			const messages = this._state.messages.slice();
+			const existing = messages[messageIndex];
+			if (!existing || existing.role !== "assistant") return false;
+			const nextParts = existing.parts.slice();
+			nextParts[partIndex] = part;
+			messages[messageIndex] = {
+				...existing,
+				parts: nextParts
+			};
+			this._state.messages = messages;
+			return true;
+		}
+		/**
+		* Queue a steering message while the agent is running.
+		* Delivered after the current assistant turn finishes executing its tool calls,
+		* before the next LLM call.
+		*/
+		steer(m) {
+			this.steeringQueue.push(m);
+		}
+		/**
+		* Queue a follow-up message to be processed after the agent finishes.
+		* Delivered only when agent has no more tool calls or steering messages.
+		*/
+		followUp(m) {
+			this.followUpQueue.push(m);
+		}
+		clearSteeringQueue() {
+			this.steeringQueue = [];
+		}
+		clearFollowUpQueue() {
+			this.followUpQueue = [];
+		}
+		clearAllQueues() {
+			this.steeringQueue = [];
+			this.followUpQueue = [];
+		}
+		hasQueuedMessages() {
+			return this.steeringQueue.length > 0 || this.followUpQueue.length > 0;
+		}
+		dequeueSteeringMessages() {
+			if (this.steeringMode === "one-at-a-time") {
+				if (this.steeringQueue.length > 0) {
+					const first = this.steeringQueue[0];
+					this.steeringQueue = this.steeringQueue.slice(1);
+					return [first];
+				}
+				return [];
+			}
+			const steering = this.steeringQueue.slice();
+			this.steeringQueue = [];
+			return steering;
+		}
+		dequeueFollowUpMessages() {
+			if (this.followUpMode === "one-at-a-time") {
+				if (this.followUpQueue.length > 0) {
+					const first = this.followUpQueue[0];
+					this.followUpQueue = this.followUpQueue.slice(1);
+					return [first];
+				}
+				return [];
+			}
+			const followUp = this.followUpQueue.slice();
+			this.followUpQueue = [];
+			return followUp;
+		}
+		clearMessages() {
+			this._state.messages = [];
+		}
+		abort() {
+			this.abortController?.abort();
+		}
+		waitForIdle() {
+			return this.runningPrompt ?? Promise.resolve();
+		}
+		reset() {
+			this._state.messages = [];
+			this._state.isStreaming = false;
+			this._state.streamMessage = null;
+			this._state.pendingToolCalls = /* @__PURE__ */ new Set();
+			this._state.error = void 0;
+			this.steeringQueue = [];
+			this.followUpQueue = [];
+		}
+		getName() {
+			return this._state.name;
+		}
+		ensureIdle() {
+			if (this._state.isStreaming) throw new AgentInStreamingErr({
+				message: "agent is already processing a prompt. Use steer() or followup() to queue messages, or wait for completion.",
+				name: this._state.name
+			});
+		}
+		async _runLoop(messages, opts) {
+			const model = this._state.model;
+			if (!model) throw new ModelNotConfiguredErr({ message: "no model configured yet" });
+			this.runningPrompt = new Promise((resolve) => {
+				this.resolveRunningPrompt = resolve;
+			});
+			this.abortController = new AbortController();
+			this._state.isStreaming = true;
+			this._state.streamMessage = null;
+			this._state.error = void 0;
+			const reasoning = this.state.thinkingLevel === "off" ? void 0 : this._state.thinkingLevel;
+			const context = {
+				systemPrompt: this._state.systemPrompt,
+				messages: this._state.messages.slice(),
+				tools: this._state.tools
+			};
+			let skipInitialSteeringPoll = opts?.skipInitialSteeringPoll === true;
+			const config = {
+				model,
+				reasoning,
+				sessionId: this._sessionId,
+				onPayload: this._onPayload,
+				transport: this._transport,
+				thinkingBudgets: this._thinkingBudgets,
+				maxRetryDelayMs: this._maxRetryDelayMs,
+				toolExecution: this._toolExecution,
+				beforeToolExecution: this._beforeToolExecution,
+				afterToolExecution: this._afterToolExecution,
+				convertToLlm: this.convertToLlm,
+				transformContext: this.transformContext,
+				getApiKey: this.getApiKey,
+				getSteeringMessages: async () => {
+					if (skipInitialSteeringPoll) {
+						skipInitialSteeringPoll = false;
+						return [];
+					}
+					return this.dequeueSteeringMessages();
+				},
+				getFollowUpMessages: async () => this.dequeueFollowUpMessages()
+			};
+			try {
+				if (messages) await Loop.runAgentLoop(config, context, messages, async (e) => this._processLoopEvent(e), this.streamFn, this.abortController.signal);
+				else await Loop.runAgentLoopContinue(config, context, async (e) => this._processLoopEvent(e), this.streamFn, this.abortController.signal);
+			} catch (err) {
+				const message = Message.createAssistantMessage({
+					role: "assistant",
+					protocol: model.protocol,
+					provider: model.provider,
+					model: model.id,
+					usage: {
+						input: 0,
+						output: 0,
+						cacheRead: 0,
+						cacheWrite: 0,
+						totalTokens: 0,
+						cost: {
+							input: 0,
+							output: 0,
+							cacheRead: 0,
+							cacheWrite: 0,
+							total: 0
+						}
+					},
+					stopReason: this.abortController.signal.aborted ? "aborted" : "error",
+					errorMessage: err?.message || String(err),
+					time: {
+						created: Date.now(),
+						completed: Date.now()
+					},
+					parts: []
+				});
+				this.appendMessage(message);
+				this._state.error = err?.message || String(err);
+				this.emit({
+					type: "agent.end",
+					messages: [message]
+				});
+			} finally {
+				this._state.isStreaming = false;
+				this._state.streamMessage = null;
+				this._state.pendingToolCalls = /* @__PURE__ */ new Set();
+				this.abortController = void 0;
+				this.resolveRunningPrompt?.();
+				this.runningPrompt = void 0;
+				this.resolveRunningPrompt = void 0;
+			}
+		}
+		async loop(messages) {
+			this.ensureIdle();
+			await this._runLoop(messages);
+		}
+		async loopContinue() {
+			this.ensureIdle();
+			await this._runLoop();
+		}
+		async prompt(messages, images) {
+			this.ensureIdle();
+			if (!this._state.model) throw new ModelNotConfiguredErr({ message: "no model configured yet." });
+			const message = Message.createUserMessage({
+				role: "user",
+				time: { created: Date.now() },
+				parts: [...messages, ...images ?? []]
+			});
+			await this.loop([message]);
+		}
+		_processLoopEvent(event) {
+			switch (event.type) {
+				case "message.start":
+					this._state.streamMessage = event.message;
+					break;
+				case "message.part.start":
+				case "message.part.update":
+				case "message.part.end":
+					this._state.streamMessage = event.message;
+					if (event.message.role === "assistant") this.patchStoredAssistantPart(event.message.messageId, event.partIndex, event.part);
+					break;
+				case "message.update":
+					this._state.streamMessage = event.message;
+					this.replaceMessageById(event.message);
+					break;
+				case "message.end":
+					this._state.streamMessage = null;
+					this.upsertMessage(event.message);
+					break;
+				case "tool.execution.start": {
+					const pendingToolCalls = new Set(this._state.pendingToolCalls);
+					pendingToolCalls.add(event.callID);
+					this._state.pendingToolCalls = pendingToolCalls;
+					break;
+				}
+				case "tool.execution.end": {
+					const pendingToolCalls = new Set(this._state.pendingToolCalls);
+					pendingToolCalls.delete(event.callID);
+					this._state.pendingToolCalls = pendingToolCalls;
+					break;
+				}
+				case "turn.end":
+					if (event.message.role === "assistant" && event.message.parts.length > 0) this._state.error = event.message.errorMessage;
+					break;
+				case "agent.end":
+					this._state.isStreaming = false;
+					this._state.streamMessage = null;
+					break;
+			}
+			this.emit(event);
+		}
+		emit(e) {
+			for (const listener of this.listeners) listener(e);
+		}
+	}
+	_Agent.Instance = Instance;
+	async function create(options) {
+		let resolvedModel;
+		if ("provider" in options) {
+			const result = await Model.getModel(options.provider, options.model);
+			if (!result) throw new ModelNotFoundErr({
+				message: "model not found or not configured yet",
+				provider: options.provider,
+				model: options.model
+			});
+			resolvedModel = result;
+		} else resolvedModel = options.model;
+		return new Instance(options.name ?? "main", resolvedModel, options);
+	}
+	_Agent.create = create;
+})(Agent || (Agent = {}));
+//#endregion
+//#region src/agent.ts
+const agent = {
+	loop: Loop.run,
+	loopContinue: Loop.runContinue
+};
+//#endregion
+//#region src/llm.ts
+const llmImpl = async (provider, model) => Model.getModel(provider, model);
+const llm = Object.assign(llmImpl, {
+	model: Model.getModel,
+	models: Model.getModels,
+	providers: Model.getProviders,
+	registry: Model.registry,
+	supportsXhigh: Model.supportsXhigh,
+	modelsAreEqual: Model.modelsAreEqual
+});
+//#endregion
+//#region src/stream.ts
+const streamImpl = (model, context, options) => Stream.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.simple(...)` uses `Stream.SimpleOptions` for higher-level reasoning controls.
+* - `stream.completeSimple(...)` is the non-streaming counterpart to `stream.simple(...)`.
+* - `stream.resolveProtocolProvider(...)` exposes protocol resolution for advanced integrations.
+*/
+const stream = Object.assign(streamImpl, {
+	complete: Stream.complete,
+	simple: Stream.streamSimple,
+	completeSimple: Stream.completeSimple,
+	resolveProtocolProvider: Stream.resolveProtocolProvider
+});
+Stream.complete;
+Stream.streamSimple;
+Stream.completeSimple;
+//#endregion
+export { Agent, Message, agent, llm, stream };
+
+//# sourceMappingURL=index.mjs.map