@onkernel/cua-ai 0.1.0 → 0.2.1

package/dist/index.js

@@ -1,13 +1,2001 @@
-import { registerCuaProviders } from "./providers";
+import { t as __exportAll } from "./chunk-D7D4PA-g.js";
+import { Type, createAssistantMessageEventStream, getModel, getModels, registerApiProvider } from "@earendil-works/pi-ai";
+import Lightcone from "@tzafon/lightcone";
+import OpenAI from "openai";
 export * from "@earendil-works/pi-ai";
-export * from "./models";
-export * from "./api-keys";
-export * from "./runtime-spec";
-export * from "./providers/common";
-export * as anthropic from "./providers/anthropic/index";
-export * as gemini from "./providers/gemini/index";
-export * as openai from "./providers/openai/index";
-export * as tzafon from "./providers/tzafon/index";
-export * as yutori from "./providers/yutori/index";
+//#region src/providers/common.ts
+const CUA_ACTION_TYPES = [
+	"click",
+	"double_click",
+	"mouse_down",
+	"mouse_up",
+	"type",
+	"keypress",
+	"scroll",
+	"move",
+	"drag",
+	"wait",
+	"screenshot",
+	"goto",
+	"back",
+	"forward",
+	"url",
+	"cursor_position"
+];
+const PointSchema = Type.Object({
+	x: Type.Number(),
+	y: Type.Number()
+}, { additionalProperties: false });
+const CUA_ACTION_SCHEMA_BY_TYPE = {
+	click: Type.Object({
+		type: Type.Literal("click"),
+		x: Type.Number(),
+		y: Type.Number(),
+		button: Type.Optional(Type.String()),
+		hold_keys: Type.Optional(Type.Array(Type.String()))
+	}, { additionalProperties: false }),
+	double_click: Type.Object({
+		type: Type.Literal("double_click"),
+		x: Type.Number(),
+		y: Type.Number(),
+		hold_keys: Type.Optional(Type.Array(Type.String()))
+	}, { additionalProperties: false }),
+	mouse_down: Type.Object({
+		type: Type.Literal("mouse_down"),
+		x: Type.Number(),
+		y: Type.Number(),
+		button: Type.Optional(Type.String()),
+		hold_keys: Type.Optional(Type.Array(Type.String()))
+	}, { additionalProperties: false }),
+	mouse_up: Type.Object({
+		type: Type.Literal("mouse_up"),
+		x: Type.Number(),
+		y: Type.Number(),
+		button: Type.Optional(Type.String()),
+		hold_keys: Type.Optional(Type.Array(Type.String()))
+	}, { additionalProperties: false }),
+	type: Type.Object({
+		type: Type.Literal("type"),
+		text: Type.String()
+	}, { additionalProperties: false }),
+	keypress: Type.Object({
+		type: Type.Literal("keypress"),
+		keys: Type.Array(Type.String()),
+		duration: Type.Optional(Type.Number())
+	}, { additionalProperties: false }),
+	scroll: Type.Object({
+		type: Type.Literal("scroll"),
+		x: Type.Optional(Type.Number()),
+		y: Type.Optional(Type.Number()),
+		scroll_x: Type.Optional(Type.Number()),
+		scroll_y: Type.Optional(Type.Number()),
+		hold_keys: Type.Optional(Type.Array(Type.String()))
+	}, { additionalProperties: false }),
+	move: Type.Object({
+		type: Type.Literal("move"),
+		x: Type.Number(),
+		y: Type.Number()
+	}, { additionalProperties: false }),
+	drag: Type.Object({
+		type: Type.Literal("drag"),
+		path: Type.Array(PointSchema, { minItems: 2 }),
+		button: Type.Optional(Type.String()),
+		hold_keys: Type.Optional(Type.Array(Type.String()))
+	}, { additionalProperties: false }),
+	wait: Type.Object({
+		type: Type.Literal("wait"),
+		ms: Type.Optional(Type.Number())
+	}, { additionalProperties: false }),
+	screenshot: Type.Object({ type: Type.Literal("screenshot") }, { additionalProperties: false }),
+	goto: Type.Object({
+		type: Type.Literal("goto"),
+		url: Type.String()
+	}, { additionalProperties: false }),
+	back: Type.Object({ type: Type.Literal("back") }, { additionalProperties: false }),
+	forward: Type.Object({ type: Type.Literal("forward") }, { additionalProperties: false }),
+	url: Type.Object({ type: Type.Literal("url") }, { additionalProperties: false }),
+	cursor_position: Type.Object({ type: Type.Literal("cursor_position") }, { additionalProperties: false })
+};
+function createCuaActionArgumentSchema(action) {
+	const { type: _type, ...properties } = CUA_ACTION_SCHEMA_BY_TYPE[action].properties;
+	return Type.Object(properties, { additionalProperties: false });
+}
+function createCuaActionSchema(actions = CUA_ACTION_TYPES) {
+	if (actions.length === 0) throw new Error("actions must include at least one CUA action type");
+	if (actions.length === 1) return CUA_ACTION_SCHEMA_BY_TYPE[actions[0]];
+	return Type.Union(actions.map((action) => CUA_ACTION_SCHEMA_BY_TYPE[action]));
+}
+function createCuaActionToolDefinitions(actions = CUA_ACTION_TYPES) {
+	return actions.map((action) => ({
+		name: action,
+		description: `Execute one ${action} computer action.`,
+		parameters: createCuaActionArgumentSchema(action)
+	}));
+}
+const CuaActionSchema = createCuaActionSchema();
+function createCuaBatchSchema(actions) {
+	return Type.Object({ actions: Type.Array(createCuaActionSchema(actions), { description: "Ordered computer actions to execute." }) });
+}
+const CuaBatchSchema = createCuaBatchSchema();
+const CuaNavigationSchema = Type.Object({
+	action: Type.Union([
+		Type.Literal("goto"),
+		Type.Literal("back"),
+		Type.Literal("forward"),
+		Type.Literal("url")
+	]),
+	url: Type.Optional(Type.String())
+}, { additionalProperties: false });
+/**
+* Default name for batch computer-action tools created by
+* {@link createCuaBatchToolDefinition} and the name Anthropic's batch tool
+* ships under (the only provider that includes one by default).
+*/
+const CUA_BATCH_TOOL_NAME = "computer_batch";
+const CUA_NAVIGATION_TOOL_NAME = "computer_use_extra";
+const CUA_BATCH_TOOL_DESCRIPTION = [
+	"Execute multiple computer actions in sequence, including ordered read steps like url(), cursor_position(), and screenshot().",
+	"Prefer this tool for predictable browser interaction sequences such as click-then-type, typing a URL, keyboard navigation, drag paths, and mixed write/read batches.",
+	"If no explicit read step is included, the tool returns one fresh screenshot after execution."
+].join("\n");
+const CUA_NAVIGATION_TOOL_DESCRIPTION = "High-level browser navigation helpers for goto, back, forward, and url.";
+/**
+* Build the provider's CUA computer-use tools.
+*
+* Use this when calling `complete()` or `stream()` directly and you need an
+* array of `Tool` objects for browser actions. Pass `actions` to expose only a
+* smaller set, such as `["click"]`.
+*/
+function computerTools(options = {}) {
+	return createCuaActionToolDefinitions(options.actions);
+}
+/** Build execution adapters for individual canonical CUA action tools. */
+function createCuaActionToolExecutors(actions = CUA_ACTION_TYPES) {
+	return createCuaActionToolDefinitions(actions).map((definition) => {
+		const actionType = definition.name;
+		return {
+			definition,
+			toActions(args) {
+				return [{
+					...args && typeof args === "object" ? args : {},
+					type: actionType
+				}];
+			}
+		};
+	});
+}
+/** Return the canonical tool name that should execute a normalized CUA action. */
+function canonicalToolCallName(action) {
+	return action.type;
+}
+/** Convert a normalized CUA action into tool-call arguments by removing its `type` tag. */
+function canonicalToolCallArguments(action) {
+	const { type: _type, ...args } = action;
+	return args;
+}
+/** Prefix bare hostnames/paths with `https://` before browser navigation. */
+function normalizeGotoUrl(value) {
+	if (typeof value !== "string") return void 0;
+	const url = value.trim();
+	if (!url) return void 0;
+	return /^[a-z][a-z0-9+.-]*:\/\//i.test(url) ? url : `https://${url}`;
+}
+function createCuaBatchToolDefinition(actions, options = {}) {
+	return {
+		name: options.name ?? "computer_batch",
+		description: options.description ?? CUA_BATCH_TOOL_DESCRIPTION,
+		parameters: createCuaBatchSchema(actions)
+	};
+}
+/** Build an execution adapter for a batch tool whose input is `{ actions }`. */
+function createCuaBatchToolExecutor(actions, options = {}) {
+	return {
+		definition: createCuaBatchToolDefinition(actions, options),
+		toActions(args) {
+			if (!isBatchInput(args)) throw new Error("invalid batch tool parameters");
+			return args.actions;
+		}
+	};
+}
+/** Build the provider's default CUA tool execution adapters. */
+function computerToolExecutors(options = {}) {
+	return createCuaActionToolExecutors(options.actions);
+}
+function isBatchInput(value) {
+	return Boolean(value && typeof value === "object" && Array.isArray(value.actions));
+}
+function createCuaNavigationToolDefinition() {
+	return {
+		name: CUA_NAVIGATION_TOOL_NAME,
+		description: CUA_NAVIGATION_TOOL_DESCRIPTION,
+		parameters: CuaNavigationSchema
+	};
+}
+//#endregion
+//#region src/providers/tzafon/provider.ts
+const TZAFON_RESPONSES_API = "tzafon-responses";
+const TZAFON_COMPUTER_USE_TOOL = {
+	type: "computer_use",
+	display_width: 1920,
+	display_height: 1080,
+	environment: "browser"
+};
+const TZAFON_LOCAL_ACTION_TOOL_NAMES = new Set(CUA_ACTION_TYPES);
+const streamSimpleTzafonResponses = (model, context, options) => {
+	return streamTzafonResponses(model, context, options);
+};
+const streamTzafonResponses = (model, context, options) => {
+	const stream = createAssistantMessageEventStream();
+	const output = initialAssistantMessage$1(model);
+	(async () => {
+		try {
+			const apiKey = options?.apiKey || process.env.TZAFON_API_KEY;
+			if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
+			const client = new Lightcone({ apiKey });
+			const payload = {
+				model: model.id,
+				input: convertContextMessages(context),
+				tools: convertTools$1(context.tools ?? []),
+				instructions: context.systemPrompt,
+				temperature: options?.temperature ?? 0,
+				max_output_tokens: options?.maxTokens ?? model.maxTokens
+			};
+			const tzafonPayload = tzafonComputerUseOnPayload(payload, model, { keepToolNames: [...keepToolNamesFromContext$1(context), ...options?.keepToolNames ?? []] });
+			const nextPayload = await options?.onPayload?.(tzafonPayload ?? payload, model);
+			if (options?.signal?.aborted) throw new Error("Request was aborted");
+			const response = await client.responses.create(nextPayload ?? tzafonPayload ?? payload, { signal: options?.signal });
+			if (options?.signal?.aborted) throw new Error("Request was aborted");
+			stream.push({
+				type: "start",
+				partial: output
+			});
+			output.responseId = getString(response, "id") || void 0;
+			output.usage = usageFromTzafon(getValue(response, "usage"));
+			for (const item of getArray(response, "output")) {
+				const type = getString(item, "type");
+				if (type === "message") {
+					const text = extractMessageText(item);
+					if (text) emitText$1(stream, output, text);
+					continue;
+				}
+				if (type === "function_call") {
+					emitToolCall(stream, output, {
+						type: "toolCall",
+						id: getString(item, "call_id"),
+						name: getString(item, "name"),
+						arguments: parseArguments$1(getValue(item, "arguments"))
+					});
+					continue;
+				}
+				if (type === "computer_call") {
+					const callId = getString(item, "call_id") || getString(item, "id") || `computer_call_${output.content.length}`;
+					let actionIndex = 0;
+					for (const action of toCanonicalActions$1(getValue(item, "action"))) {
+						if (action.type === "answer") {
+							emitText$1(stream, output, action.text);
+							continue;
+						}
+						emitToolCall(stream, output, {
+							type: "toolCall",
+							id: tzafonToolCallId(callId, actionIndex),
+							name: canonicalToolCallName(action),
+							arguments: canonicalToolCallArguments(action)
+						});
+						actionIndex += 1;
+					}
+				}
+			}
+			output.stopReason = output.content.some((part) => part.type === "toolCall") ? "toolUse" : "stop";
+			stream.push({
+				type: "done",
+				reason: output.stopReason,
+				message: output
+			});
+			stream.end();
+		} catch (err) {
+			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+			output.errorMessage = err instanceof Error ? err.message : String(err);
+			stream.push({
+				type: "error",
+				reason: output.stopReason,
+				error: output
+			});
+			stream.end();
+		}
+	})();
+	return stream;
+};
+function tzafonComputerUseOnPayload(payload, _model, context) {
+	if (!payload || typeof payload !== "object") return void 0;
+	const current = payload;
+	const keepToolNames = new Set(context?.keepToolNames ?? []);
+	const existingTools = Array.isArray(current.tools) ? current.tools : [];
+	const shouldAddComputerUse = existingTools.some((tool) => {
+		const name = readToolName$1(tool);
+		return Boolean(name && TZAFON_LOCAL_ACTION_TOOL_NAMES.has(name) && !keepToolNames.has(name));
+	});
+	const tools = existingTools.filter((tool) => {
+		const name = readToolName$1(tool);
+		return !name || keepToolNames.has(name) || !TZAFON_LOCAL_ACTION_TOOL_NAMES.has(name);
+	});
+	return {
+		...payload,
+		tools: shouldAddComputerUse ? [TZAFON_COMPUTER_USE_TOOL, ...tools] : tools
+	};
+}
+/** Derive a unique canonical tool-call id for a Tzafon computer action. */
+function tzafonToolCallId(callId, actionIndex) {
+	return actionIndex === 0 ? callId : `${callId}:${actionIndex}`;
+}
+function initialAssistantMessage$1(model) {
+	return {
+		role: "assistant",
+		content: [],
+		api: model.api,
+		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",
+		timestamp: Date.now()
+	};
+}
+function emitText$1(stream, output, text) {
+	const contentIndex = output.content.length;
+	const content = {
+		type: "text",
+		text
+	};
+	output.content.push(content);
+	stream.push({
+		type: "text_start",
+		contentIndex,
+		partial: output
+	});
+	stream.push({
+		type: "text_delta",
+		contentIndex,
+		delta: text,
+		partial: output
+	});
+	stream.push({
+		type: "text_end",
+		contentIndex,
+		content: text,
+		partial: output
+	});
+}
+function emitToolCall(stream, output, toolCall) {
+	const contentIndex = output.content.length;
+	output.content.push(toolCall);
+	stream.push({
+		type: "toolcall_start",
+		contentIndex,
+		partial: output
+	});
+	stream.push({
+		type: "toolcall_end",
+		contentIndex,
+		toolCall,
+		partial: output
+	});
+}
+/** Normalize one Tzafon `computer_call.action` payload into canonical CUA actions. */
+function toCanonicalActions$1(action) {
+	if (!action || typeof action !== "object") return [];
+	const current = action;
+	const type = getString(current, "type");
+	const x = readOptionalNumber(current, "x");
+	const y = readOptionalNumber(current, "y");
+	switch (type) {
+		case "click":
+		case "left_click": return x !== void 0 && y !== void 0 ? [{
+			type: "click",
+			x,
+			y
+		}] : [];
+		case "right_click": return x !== void 0 && y !== void 0 ? [{
+			type: "click",
+			x,
+			y,
+			button: "right"
+		}] : [];
+		case "double_click": return x !== void 0 && y !== void 0 ? [{
+			type: "double_click",
+			x,
+			y
+		}] : [];
+		case "triple_click": return x !== void 0 && y !== void 0 ? [{
+			type: "double_click",
+			x,
+			y
+		}, {
+			type: "click",
+			x,
+			y
+		}] : [];
+		case "move":
+		case "hover": return x !== void 0 && y !== void 0 ? [{
+			type: "move",
+			x,
+			y
+		}] : [];
+		case "drag": return toDragAction(current);
+		case "type": return [{
+			type: "type",
+			text: getString(current, "text")
+		}];
+		case "keypress":
+		case "key": return toKeypressAction$1(current);
+		case "scroll": return [toScrollAction$1(current)];
+		case "hscroll": return [{
+			type: "scroll",
+			scroll_x: readOptionalNumber(current, "scroll_x") ?? readOptionalNumber(current, "amount") ?? 0
+		}];
+		case "navigate": return [{
+			type: "goto",
+			url: getString(current, "url")
+		}];
+		case "wait": return [{
+			type: "wait",
+			ms: readOptionalNumber(current, "ms") ?? secondsToMs$1(readOptionalNumber(current, "seconds"))
+		}];
+		case "screenshot": return [{ type: "screenshot" }];
+		case "answer":
+		case "done":
+		case "terminate": return [{
+			type: "answer",
+			text: getString(current, "result") || getString(current, "text") || getString(current, "status")
+		}];
+		default: return [];
+	}
+}
+function toDragAction(action) {
+	const path = getArray(action, "path").map((point) => {
+		if (!point || typeof point !== "object") return void 0;
+		const x = readOptionalNumber(point, "x");
+		const y = readOptionalNumber(point, "y");
+		return x !== void 0 && y !== void 0 ? {
+			x,
+			y
+		} : void 0;
+	}).filter((point) => Boolean(point));
+	if (path.length >= 2) return [{
+		type: "drag",
+		path
+	}];
+	const x = readOptionalNumber(action, "x");
+	const y = readOptionalNumber(action, "y");
+	const endX = readOptionalNumber(action, "end_x") ?? readOptionalNumber(action, "x2");
+	const endY = readOptionalNumber(action, "end_y") ?? readOptionalNumber(action, "y2");
+	if (x === void 0 || y === void 0 || endX === void 0 || endY === void 0) return [];
+	return [{
+		type: "drag",
+		path: [{
+			x,
+			y
+		}, {
+			x: endX,
+			y: endY
+		}]
+	}];
+}
+function toKeypressAction$1(action) {
+	const keys = getArray(action, "keys").map((key) => typeof key === "string" ? key : void 0).filter((key) => Boolean(key));
+	const key = getString(action, "key");
+	const text = getString(action, "text");
+	const value = keys.length > 0 ? keys : key ? [key] : text ? [text] : [];
+	return value.length > 0 ? [{
+		type: "keypress",
+		keys: value
+	}] : [];
+}
+function toScrollAction$1(action) {
+	return {
+		type: "scroll",
+		x: readOptionalNumber(action, "x"),
+		y: readOptionalNumber(action, "y"),
+		scroll_x: readOptionalNumber(action, "scroll_x"),
+		scroll_y: readOptionalNumber(action, "scroll_y") ?? readOptionalNumber(action, "amount")
+	};
+}
+function secondsToMs$1(seconds) {
+	return seconds === void 0 ? void 0 : seconds * 1e3;
+}
+function convertTools$1(tools) {
+	return tools.map((tool) => ({
+		type: "function",
+		name: tool.name,
+		description: tool.description,
+		parameters: tool.parameters
+	}));
+}
+function keepToolNamesFromContext$1(context) {
+	return (context.tools ?? []).map((tool) => tool.name).filter((name) => !TZAFON_LOCAL_ACTION_TOOL_NAMES.has(name));
+}
+function readToolName$1(tool) {
+	if (!tool || typeof tool !== "object") return void 0;
+	const direct = getString(tool, "name");
+	if (direct) return direct;
+	return getString(getValue(tool, "function"), "name");
+}
+function convertContextMessages(context) {
+	const items = [];
+	for (const message of context.messages) {
+		if (message.role === "user") {
+			items.push({
+				role: "user",
+				content: convertUserContent(message.content)
+			});
+			continue;
+		}
+		if (message.role === "assistant") {
+			const text = message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n").trim();
+			if (text) items.push({
+				role: "assistant",
+				content: text
+			});
+			for (const part of message.content) {
+				if (part.type !== "toolCall") continue;
+				items.push({
+					type: "function_call",
+					call_id: part.id,
+					name: part.name,
+					arguments: JSON.stringify(part.arguments ?? {})
+				});
+			}
+			continue;
+		}
+		if (message.role === "toolResult") {
+			const text = message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n").trim();
+			items.push({
+				type: "function_call_output",
+				call_id: message.toolCallId,
+				output: message.isError ? `Error: ${text || "tool execution failed"}` : text || "ok"
+			});
+			const image = [...message.content].reverse().find((part) => part.type === "image");
+			if (image) items.push({
+				role: "user",
+				content: [{
+					type: "input_text",
+					text: "screenshot"
+				}, {
+					type: "input_image",
+					image_url: `data:${image.mimeType};base64,${image.data}`,
+					detail: "auto"
+				}]
+			});
+		}
+	}
+	return items;
+}
+function convertUserContent(content) {
+	if (typeof content === "string") return [{
+		type: "input_text",
+		text: content
+	}];
+	return content.map((part) => {
+		if (part.type === "text") return {
+			type: "input_text",
+			text: part.text
+		};
+		return {
+			type: "input_image",
+			image_url: `data:${part.mimeType};base64,${part.data}`,
+			detail: "auto"
+		};
+	});
+}
+function extractMessageText(item) {
+	return getArray(item, "content").map((block) => getString(block, "text")).filter(Boolean).join("\n").trim();
+}
+function parseArguments$1(value) {
+	const top = typeof value === "string" && value.trim() ? safeJsonParse(value) : value && typeof value === "object" ? value : {};
+	if (!top || typeof top !== "object") return {};
+	const out = {};
+	for (const [key, val] of Object.entries(top)) out[key] = normalizeArgumentValue(key, val);
+	return out;
+}
+const NUMERIC_ARGUMENT_KEYS = new Set([
+	"x",
+	"y",
+	"scroll_x",
+	"scroll_y",
+	"ms",
+	"duration"
+]);
+function normalizeArgumentValue(key, value) {
+	const parsed = typeof value === "string" && looksLikeJson(value) ? safeJsonParse(value) ?? value : value;
+	if (typeof parsed === "string" && NUMERIC_ARGUMENT_KEYS.has(key)) {
+		const number = Number.parseFloat(parsed);
+		return Number.isFinite(number) ? number : parsed;
+	}
+	if (Array.isArray(parsed)) return parsed.map((item) => normalizeArgumentValue(key, item));
+	if (parsed && typeof parsed === "object") return Object.fromEntries(Object.entries(parsed).map(([childKey, childValue]) => [childKey, normalizeArgumentValue(childKey, childValue)]));
+	return parsed;
+}
+function safeJsonParse(value) {
+	try {
+		const parsed = JSON.parse(value);
+		return parsed && typeof parsed === "object" ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function looksLikeJson(value) {
+	const trimmed = value.trim();
+	return trimmed.startsWith("[") || trimmed.startsWith("{");
+}
+function usageFromTzafon(usage) {
+	const input = readUsageNumber(usage, "input_tokens");
+	const output = readUsageNumber(usage, "output_tokens");
+	return {
+		input,
+		output,
+		cacheRead: readUsageNumber(getValue(usage, "input_tokens_details"), "cached_tokens"),
+		cacheWrite: 0,
+		totalTokens: readUsageNumber(usage, "total_tokens") || input + output,
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			total: 0
+		}
+	};
+}
+function readUsageNumber(obj, key) {
+	return readOptionalNumber(obj, key) ?? 0;
+}
+function readOptionalNumber(obj, key) {
+	if (!obj || typeof obj !== "object") return void 0;
+	const value = obj[key];
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string" && value.trim()) {
+		const number = Number(value);
+		return Number.isFinite(number) ? number : void 0;
+	}
+}
+function getArray(obj, key) {
+	const value = getValue(obj, key);
+	return Array.isArray(value) ? value : [];
+}
+function getString(obj, key) {
+	const value = getValue(obj, key);
+	return typeof value === "string" ? value : "";
+}
+function getValue(obj, key) {
+	if (!obj || typeof obj !== "object") return void 0;
+	return obj[key];
+}
+//#endregion
+//#region src/providers/yutori/actions.ts
+/**
+* Native Yutori Navigator n1.5 tool-set ids.
+*
+* Source of truth:
+* - https://docs.yutori.com/reference/n1-5
+* - https://docs.yutori.com/llm-quickstart.md
+*/
+const YUTORI_N15_CORE_TOOL_SET = "browser_tools_core-20260403";
+const YUTORI_N15_EXPANDED_TOOL_SET = "browser_tools_expanded-20260403";
+/**
+* DOM/ref-backed Navigator n1.5 actions. We intentionally disable these until
+* CuaAgent has the ref/DOM execution path that Yutori documents for the
+* expanded tool set.
+*/
+const YUTORI_N15_EXPANDED_ACTION_TYPES = [
+	"extract_elements",
+	"find",
+	"set_element_value",
+	"execute_js"
+];
+/**
+* Navigator n1's fixed legacy browser action space.
+*
+* Source of truth: https://docs.yutori.com/reference/n1
+*/
+const YUTORI_N1_ACTION_TYPES = [
+	"left_click",
+	"double_click",
+	"right_click",
+	"triple_click",
+	"type",
+	"key_press",
+	"scroll",
+	"hover",
+	"drag",
+	"goto_url",
+	"go_back",
+	"refresh",
+	"wait"
+];
+/**
+* Navigator n1.5 core visual action space. These are the actions available
+* when `tool_set` is `browser_tools_core-20260403`, which keeps CuaAgent in the
+* pure screenshot/coordinate path and avoids DOM refs.
+*
+* Source of truth: https://docs.yutori.com/reference/n1-5
+*/
+const YUTORI_N15_CORE_ACTION_TYPES = [
+	"left_click",
+	"double_click",
+	"triple_click",
+	"middle_click",
+	"right_click",
+	"mouse_move",
+	"mouse_down",
+	"mouse_up",
+	"drag",
+	"scroll",
+	"type",
+	"key_press",
+	"hold_key",
+	"goto_url",
+	"go_back",
+	"go_forward",
+	"refresh",
+	"wait"
+];
+const YUTORI_N15_ACTION_TYPES = [...YUTORI_N15_CORE_ACTION_TYPES, ...YUTORI_N15_EXPANDED_ACTION_TYPES];
+/**
+* Canonical CUA action types Yutori's native actions normalize into. These are
+* the tool-call names {@link streamYutori} emits and the local executors
+* CuaAgent installs for Yutori models.
+*/
+const YUTORI_CUA_ACTION_TYPES = [
+	"click",
+	"double_click",
+	"mouse_down",
+	"mouse_up",
+	"type",
+	"keypress",
+	"scroll",
+	"move",
+	"drag",
+	"wait",
+	"goto",
+	"back",
+	"forward"
+];
+const DEFAULT_SCROLL_AMOUNT = 3;
+const SCROLL_AMOUNT_PER_NOTCH = 120;
+const DEFAULT_WAIT_MS = 2e3;
+const NAVIGATION_WAIT_MS = 1500;
+const GOTO_WAIT_MS = 2e3;
+function resolveYutoriActions(actions) {
+	const resolved = actions ?? YUTORI_CUA_ACTION_TYPES;
+	const supported = [];
+	const unsupported = [];
+	for (const action of resolved) if (isYutoriCanonicalAction(action)) supported.push(action);
+	else unsupported.push(action);
+	if (unsupported.length > 0) throw new Error(`unsupported Yutori canonical action(s): ${unsupported.join(", ")}`);
+	return supported;
+}
+function isYutoriCanonicalAction(action) {
+	return YUTORI_CUA_ACTION_TYPES.includes(action);
+}
+/** Build the TypeBox schema for Yutori-supported canonical browser actions. */
+function createActionSchema$1(actions) {
+	return createCuaActionSchema(resolveYutoriActions(actions));
+}
+/**
+* Build local mirrors of the canonical action tools Yutori models call.
+*
+* These definitions are never sent to the API: `streamYutori` strips them from
+* the outbound payload and selects Yutori's native `tool_set` instead, then
+* normalizes the model's native tool calls back into these canonical names.
+* Install them locally so the normalized calls have matching executors —
+* `providerModule.toolDefinitions()` is intentionally `[]`. Pass `actions` to
+* mirror only a supported subset, such as `["click"]`.
+*/
+function computerTools$2(options = {}) {
+	return createCuaActionToolDefinitions(resolveYutoriActions(options.actions));
+}
+/** Build the local execution adapters used by CuaAgent and CuaAgentHarness. */
+function computerToolExecutors$2(options = {}) {
+	return createCuaActionToolExecutors(resolveYutoriActions(options.actions));
+}
+function yutoriToolSetForModel(modelId) {
+	return modelId.startsWith("n1.5") ? YUTORI_N15_CORE_TOOL_SET : void 0;
+}
+function yutoriNativeActionsForModel(modelId) {
+	return modelId.startsWith("n1.5") ? YUTORI_N15_CORE_ACTION_TYPES : YUTORI_N1_ACTION_TYPES;
+}
+function isYutoriLocalActionToolName(name) {
+	return YUTORI_CUA_ACTION_TYPES.includes(name);
+}
+function toCanonicalActions(name, args) {
+	const coords = readPoint(args.coordinates);
+	switch (name) {
+		case "left_click": return coords ? [{
+			type: "click",
+			x: coords.x,
+			y: coords.y,
+			...holdKeys(args.modifier)
+		}] : void 0;
+		case "right_click": return coords ? [{
+			type: "click",
+			x: coords.x,
+			y: coords.y,
+			button: "right",
+			...holdKeys(args.modifier)
+		}] : void 0;
+		case "middle_click": return coords ? [{
+			type: "click",
+			x: coords.x,
+			y: coords.y,
+			button: "middle",
+			...holdKeys(args.modifier)
+		}] : void 0;
+		case "double_click": return coords ? [{
+			type: "double_click",
+			x: coords.x,
+			y: coords.y,
+			...holdKeys(args.modifier)
+		}] : void 0;
+		case "triple_click": return coords ? [{
+			type: "double_click",
+			x: coords.x,
+			y: coords.y,
+			...holdKeys(args.modifier)
+		}, {
+			type: "click",
+			x: coords.x,
+			y: coords.y,
+			...holdKeys(args.modifier)
+		}] : void 0;
+		case "mouse_move":
+		case "hover": return coords ? [{
+			type: "move",
+			x: coords.x,
+			y: coords.y
+		}] : void 0;
+		case "mouse_down": return coords ? [{
+			type: "mouse_down",
+			x: coords.x,
+			y: coords.y,
+			...holdKeys(args.modifier)
+		}] : void 0;
+		case "mouse_up": return coords ? [{
+			type: "mouse_up",
+			x: coords.x,
+			y: coords.y,
+			...holdKeys(args.modifier)
+		}] : void 0;
+		case "drag": {
+			const start = readPoint(args.start_coordinates);
+			return start && coords ? [{
+				type: "drag",
+				path: [start, coords],
+				button: "left"
+			}] : void 0;
+		}
+		case "scroll": return toScrollAction(args, coords);
+		case "type": return toTypeActions(args);
+		case "key_press": return toKeypressAction(args);
+		case "hold_key": return toHoldKeyAction(args);
+		case "goto_url": {
+			const url = normalizeGotoUrl(args.url);
+			return url ? [{
+				type: "goto",
+				url
+			}, {
+				type: "wait",
+				ms: GOTO_WAIT_MS
+			}] : void 0;
+		}
+		case "go_back": return [{ type: "back" }, {
+			type: "wait",
+			ms: NAVIGATION_WAIT_MS
+		}];
+		case "go_forward": return [{ type: "forward" }, {
+			type: "wait",
+			ms: NAVIGATION_WAIT_MS
+		}];
+		case "refresh": return [{
+			type: "keypress",
+			keys: ["f5"]
+		}, {
+			type: "wait",
+			ms: DEFAULT_WAIT_MS
+		}];
+		case "wait": return [{
+			type: "wait",
+			ms: secondsToMs(args.duration, DEFAULT_WAIT_MS)
+		}];
+		default: return;
+	}
+}
+function readPoint(value) {
+	if (!Array.isArray(value) || value.length < 2) return void 0;
+	const x = Number(value[0]);
+	const y = Number(value[1]);
+	if (!Number.isFinite(x) || !Number.isFinite(y)) return void 0;
+	return {
+		x,
+		y
+	};
+}
+function toScrollAction(args, coords) {
+	if (!coords) return void 0;
+	const direction = typeof args.direction === "string" ? args.direction : "down";
+	const amount = typeof args.amount === "number" ? args.amount : DEFAULT_SCROLL_AMOUNT;
+	const ticks = Math.max(1, Math.trunc(amount)) * SCROLL_AMOUNT_PER_NOTCH;
+	const scroll_x = direction === "left" ? -ticks : direction === "right" ? ticks : 0;
+	const scroll_y = direction === "up" ? -ticks : direction === "down" ? ticks : 0;
+	return [{
+		type: "scroll",
+		x: coords.x,
+		y: coords.y,
+		scroll_x,
+		scroll_y,
+		...holdKeys(args.modifier)
+	}];
+}
+function toTypeActions(args) {
+	const text = typeof args.text === "string" ? args.text : void 0;
+	if (text === void 0) return void 0;
+	const actions = [];
+	if (args.clear_before_typing === true) actions.push({
+		type: "keypress",
+		keys: ["ctrl", "a"]
+	}, {
+		type: "keypress",
+		keys: ["backspace"]
+	});
+	actions.push({
+		type: "type",
+		text
+	});
+	if (args.press_enter_after === true) actions.push({
+		type: "keypress",
+		keys: ["enter"]
+	});
+	return actions;
+}
+function toKeypressAction(args) {
+	const sequence = readKeySequence(args.key_comb ?? args.key);
+	return sequence.length > 0 ? sequence.map((keys) => ({
+		type: "keypress",
+		keys
+	})) : void 0;
+}
+function toHoldKeyAction(args) {
+	const keys = readKeyCombo(args.key_comb ?? args.key);
+	return keys.length > 0 ? [{
+		type: "keypress",
+		keys,
+		duration: secondsToMs(args.duration, 1e3)
+	}] : void 0;
+}
+function readKeyCombo(value) {
+	if (typeof value !== "string") return [];
+	return value.split("+").map((part) => part.trim()).filter(Boolean);
+}
+function readKeySequence(value) {
+	if (typeof value !== "string") return [];
+	return value.trim().split(/\s+/).map((part) => readKeyCombo(part)).filter((combo) => combo.length > 0);
+}
+function holdKeys(value) {
+	if (typeof value !== "string") return {};
+	const key = value.trim();
+	return key ? { hold_keys: [key] } : {};
+}
+function secondsToMs(value, fallback) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return fallback;
+	return Math.round(value * 1e3);
+}
+//#endregion
+//#region src/providers/yutori/provider.ts
+const YUTORI_CHAT_COMPLETIONS_API = "yutori-chat-completions";
+const streamYutori = (model, context, options) => {
+	const stream = createAssistantMessageEventStream();
+	runYutoriStream(stream, model, context, options);
+	return stream;
+};
+const streamSimpleYutori = (model, context, options) => streamYutori(model, context, options);
+function yutoriNativeToolSetOnPayload(payload, model, context) {
+	if (!payload || typeof payload !== "object") return void 0;
+	const current = payload;
+	const keepToolNames = new Set(context?.keepToolNames ?? []);
+	const tools = Array.isArray(current.tools) ? current.tools.filter((tool) => {
+		const name = readToolName(tool);
+		return !name || keepToolNames.has(name) || !isYutoriLocalActionToolName(name);
+	}) : void 0;
+	const toolSet = model ? yutoriToolSetForModel(model.id) : void 0;
+	return {
+		...payload,
+		...toolSet ? {
+			tool_set: toolSet,
+			disable_tools: [...YUTORI_N15_EXPANDED_ACTION_TYPES]
+		} : {},
+		...tools && tools.length > 0 ? { tools } : { tools: void 0 }
+	};
+}
+/**
+* CUA payload middleware for yutori: map local executor tools onto the native
+* tool set, then append a fresh screenshot to the latest user/tool message per
+* yutori's screenshot policy.
+*/
+async function yutoriCuaOnPayload(payload, model, context) {
+	const next = yutoriNativeToolSetOnPayload(payload, model, context) ?? payload;
+	return await appendScreenshotToLatestMessage(next, context?.getScreenshot) ?? next;
+}
+async function appendScreenshotToLatestMessage(payload, getScreenshot) {
+	if (!getScreenshot) return void 0;
+	if (!payload || typeof payload !== "object") return void 0;
+	const current = payload;
+	if (!Array.isArray(current.messages) || current.messages.length === 0) return void 0;
+	const last = current.messages[current.messages.length - 1];
+	if (!last || typeof last !== "object") return void 0;
+	const lastMessage = last;
+	if (lastMessage.role !== "user" && lastMessage.role !== "tool") return void 0;
+	if (contentHasImage(lastMessage.content)) return void 0;
+	const screenshot = await getScreenshot();
+	const content = normalizePayloadContent(lastMessage.content);
+	const nextMessages = current.messages.slice();
+	nextMessages[nextMessages.length - 1] = {
+		...last,
+		content: [
+			...content,
+			{
+				type: "text",
+				text: "\n\n"
+			},
+			{
+				type: "image_url",
+				image_url: {
+					url: `data:${screenshot.mimeType};base64,${screenshot.data.toString("base64")}`,
+					detail: "high"
+				}
+			}
+		]
+	};
+	return {
+		...payload,
+		messages: nextMessages
+	};
+}
+function normalizePayloadContent(content) {
+	if (typeof content === "string") return [{
+		type: "text",
+		text: content
+	}];
+	if (Array.isArray(content)) return content.filter((part) => Boolean(part) && typeof part === "object");
+	return [];
+}
+function contentHasImage(content) {
+	return Array.isArray(content) && content.some((part) => {
+		return Boolean(part) && typeof part === "object" && part.type === "image_url";
+	});
+}
+async function runYutoriStream(stream, model, context, options) {
+	const output = initialAssistantMessage(model);
+	try {
+		const apiKey = options?.apiKey || process.env.YUTORI_API_KEY;
+		if (!apiKey) throw new Error("missing Yutori API key");
+		const client = new OpenAI({
+			apiKey,
+			baseURL: model.baseUrl || "https://api.yutori.com/v1",
+			defaultHeaders: model.headers
+		});
+		let payload = {
+			model: model.id,
+			messages: convertMessages(context),
+			max_completion_tokens: options?.maxTokens ?? model.maxTokens,
+			temperature: options?.temperature ?? .3
+		};
+		const tools = convertTools(context);
+		if (tools.length > 0) payload.tools = tools;
+		payload = yutoriNativeToolSetOnPayload(payload, model, { keepToolNames: [...keepToolNamesFromContext(context), ...options?.keepToolNames ?? []] });
+		const nextPayload = await options?.onPayload?.(payload, model);
+		if (nextPayload !== void 0) payload = nextPayload;
+		const { data: response, response: rawResponse } = await client.chat.completions.create(payload, { signal: options?.signal }).withResponse();
+		const completion = response;
+		await options?.onResponse?.({
+			status: rawResponse.status,
+			headers: headersToRecord(rawResponse.headers)
+		}, model);
+		stream.push({
+			type: "start",
+			partial: output
+		});
+		const choice = completion.choices?.[0];
+		const message = choice?.message;
+		output.responseId = completion.id;
+		output.usage = usageFromYutori(completion.usage);
+		if (choice?.finish_reason === "tool_calls") output.stopReason = "toolUse";
+		else if (choice?.finish_reason === "length") output.stopReason = "length";
+		const text = typeof message?.content === "string" ? message.content : "";
+		if (text) emitText(stream, output, text);
+		for (const call of message?.tool_calls ?? []) {
+			if (call.type !== "function") continue;
+			const args = parseArguments(call.function.arguments);
+			const canonical = toCanonicalActions(call.function.name, args);
+			if (canonical && canonical.length > 0) {
+				for (let i = 0; i < canonical.length; i++) {
+					const action = canonical[i];
+					const contentIndex = output.content.length;
+					const toolCall = {
+						type: "toolCall",
+						id: canonical.length === 1 ? call.id : `${call.id}_${i}`,
+						name: canonicalToolCallName(action),
+						arguments: canonicalToolCallArguments(action)
+					};
+					output.content.push(toolCall);
+					output.stopReason = "toolUse";
+					stream.push({
+						type: "toolcall_start",
+						contentIndex,
+						partial: output
+					});
+					stream.push({
+						type: "toolcall_delta",
+						contentIndex,
+						delta: JSON.stringify(toolCall.arguments),
+						partial: output
+					});
+					stream.push({
+						type: "toolcall_end",
+						contentIndex,
+						toolCall,
+						partial: output
+					});
+				}
+				continue;
+			}
+			const contentIndex = output.content.length;
+			const toolCall = {
+				type: "toolCall",
+				id: call.id,
+				name: call.function.name,
+				arguments: args
+			};
+			output.content.push(toolCall);
+			output.stopReason = "toolUse";
+			stream.push({
+				type: "toolcall_start",
+				contentIndex,
+				partial: output
+			});
+			stream.push({
+				type: "toolcall_delta",
+				contentIndex,
+				delta: call.function.arguments ?? "",
+				partial: output
+			});
+			stream.push({
+				type: "toolcall_end",
+				contentIndex,
+				toolCall,
+				partial: output
+			});
+		}
+		stream.push({
+			type: "done",
+			reason: output.stopReason,
+			message: output
+		});
+		stream.end();
+	} catch (err) {
+		output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+		output.errorMessage = err instanceof Error ? err.message : String(err);
+		stream.push({
+			type: "error",
+			reason: output.stopReason,
+			error: output
+		});
+		stream.end();
+	}
+}
+function keepToolNamesFromContext(context) {
+	return (context.tools ?? []).map((tool) => tool.name).filter((name) => !isYutoriLocalActionToolName(name));
+}
+function initialAssistantMessage(model) {
+	return {
+		role: "assistant",
+		content: [],
+		api: model.api,
+		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",
+		timestamp: Date.now()
+	};
+}
+function convertMessages(context) {
+	const messages = [];
+	if (context.systemPrompt) messages.push({
+		role: "system",
+		content: context.systemPrompt
+	});
+	for (const message of context.messages) if (message.role === "user") messages.push({
+		role: "user",
+		content: typeof message.content === "string" ? message.content : message.content.map(toOpenAIContentPart)
+	});
+	else if (message.role === "assistant") {
+		const text = message.content.filter((part) => part.type === "text").map((part) => part.text).join("");
+		const toolCalls = message.content.filter((part) => part.type === "toolCall").map((part) => ({
+			id: part.id,
+			type: "function",
+			function: {
+				name: part.name,
+				arguments: JSON.stringify(part.arguments ?? {})
+			}
+		}));
+		messages.push({
+			role: "assistant",
+			content: text || null,
+			...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+		});
+	} else if (message.role === "toolResult") messages.push({
+		role: "tool",
+		tool_call_id: message.toolCallId,
+		content: message.content.map(toOpenAIContentPart)
+	});
+	return messages;
+}
+function convertTools(context) {
+	return (context.tools ?? []).map((tool) => ({
+		type: "function",
+		function: {
+			name: tool.name,
+			description: tool.description,
+			parameters: tool.parameters
+		}
+	}));
+}
+function emitText(stream, output, text) {
+	const contentIndex = output.content.length;
+	const content = {
+		type: "text",
+		text
+	};
+	output.content.push(content);
+	stream.push({
+		type: "text_start",
+		contentIndex,
+		partial: output
+	});
+	stream.push({
+		type: "text_delta",
+		contentIndex,
+		delta: text,
+		partial: output
+	});
+	stream.push({
+		type: "text_end",
+		contentIndex,
+		content: text,
+		partial: output
+	});
+}
+function toOpenAIContentPart(part) {
+	if (part.type === "text") return {
+		type: "text",
+		text: part.text
+	};
+	return {
+		type: "image_url",
+		image_url: { url: `data:${part.mimeType};base64,${part.data}` }
+	};
+}
+function parseArguments(value) {
+	if (!value?.trim()) return {};
+	try {
+		const parsed = JSON.parse(value);
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+function usageFromYutori(usage) {
+	const input = readNumber(usage, "prompt_tokens");
+	const output = readNumber(usage, "completion_tokens");
+	return {
+		input,
+		output,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens: readNumber(usage, "total_tokens") || input + output,
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			total: 0
+		}
+	};
+}
+function readToolName(tool) {
+	if (!tool || typeof tool !== "object") return void 0;
+	const obj = tool;
+	if (typeof obj.function?.name === "string") return obj.function.name;
+	if (typeof obj.name === "string") return obj.name;
+}
+function readNumber(value, key) {
+	if (!value || typeof value !== "object") return 0;
+	const n = value[key];
+	return typeof n === "number" && Number.isFinite(n) ? n : 0;
+}
+function headersToRecord(headers) {
+	const out = {};
+	headers.forEach((value, key) => {
+		out[key] = value;
+	});
+	return out;
+}
+//#endregion
+//#region src/providers.ts
+/**
+* Register the Yutori and Tzafon stream providers with pi-ai's global API
+* registry. Importing `@onkernel/cua-ai` calls this automatically.
+*
+* The pi-ai registry mutators this package re-exports (`clearApiProviders`,
+* `resetApiProviders`, `unregisterApiProviders`) deregister these providers,
+* after which Yutori/Tzafon streaming fails until they are registered again.
+* Call this to restore them; it is idempotent and safe to call repeatedly.
+*/
+function registerCuaProviders() {
+	registerApiProvider({
+		api: YUTORI_CHAT_COMPLETIONS_API,
+		stream: streamYutori,
+		streamSimple: streamSimpleYutori
+	});
+	registerApiProvider({
+		api: TZAFON_RESPONSES_API,
+		stream: streamTzafonResponses,
+		streamSimple: streamSimpleTzafonResponses
+	});
+}
+//#endregion
+//#region src/models.ts
+/** All providers this package curates computer-use models for. */
+const CUA_PROVIDERS = [
+	"openai",
+	"anthropic",
+	"google",
+	"tzafon",
+	"yutori"
+];
+/**
+* Per-provider computer-use support annotations.
+*
+* pi-ai's model registry is generated from models.dev (see
+* node_modules/@earendil-works/pi-ai/scripts/generate-models.ts) and lists every
+* model a provider offers. Only some of those models support computer-use, so
+* this table layers per-provider CUA-support annotations on top of the
+* registry. Each entry cites the official source documenting CUA support.
+*
+* To verify support and add new entries, follow the `update-models` skill at
+* .agents/skills/update-models/SKILL.md.
+*/
+const CUA_MODEL_ANNOTATIONS = {
+	openai: [{
+		match: {
+			kind: "family",
+			family: "gpt-5.4"
+		},
+		source: "https://developers.openai.com/api/docs/models/gpt-5.4"
+	}, {
+		match: {
+			kind: "family",
+			family: "gpt-5.5"
+		},
+		source: "https://developers.openai.com/api/docs/models/gpt-5.5"
+	}],
+	anthropic: [
+		{
+			match: {
+				kind: "family",
+				family: "claude-3-7-sonnet"
+			},
+			source: "https://docs.anthropic.com/en/docs/build-with-claude/computer-use"
+		},
+		{
+			match: {
+				kind: "family",
+				family: "claude-opus-4"
+			},
+			source: "https://docs.anthropic.com/en/docs/build-with-claude/computer-use"
+		},
+		{
+			match: {
+				kind: "family",
+				family: "claude-sonnet-4"
+			},
+			source: "https://docs.anthropic.com/en/docs/build-with-claude/computer-use"
+		},
+		{
+			match: {
+				kind: "family",
+				family: "claude-haiku-4"
+			},
+			source: "https://docs.anthropic.com/en/docs/build-with-claude/computer-use"
+		},
+		{
+			match: {
+				kind: "family",
+				family: "claude-fable-5"
+			},
+			source: "https://docs.anthropic.com/en/docs/build-with-claude/computer-use"
+		}
+	],
+	google: [{
+		match: {
+			kind: "exact",
+			id: "gemini-3-flash-preview"
+		},
+		source: "https://ai.google.dev/gemini-api/docs/computer-use"
+	}, {
+		match: {
+			kind: "exact",
+			id: "gemini-3-pro-preview"
+		},
+		source: "https://ai.google.dev/gemini-api/docs/computer-use"
+	}],
+	tzafon: [{
+		match: {
+			kind: "exact",
+			id: "tzafon.northstar-cua-fast"
+		},
+		source: "https://huggingface.co/Tzafon/Northstar-CUA-Fast"
+	}],
+	yutori: [
+		{
+			match: {
+				kind: "exact",
+				id: "n1-latest"
+			},
+			source: "https://docs.yutori.com/reference/navigator"
+		},
+		{
+			match: {
+				kind: "exact",
+				id: "n1-20260203"
+			},
+			source: "https://docs.yutori.com/reference/navigator"
+		},
+		{
+			match: {
+				kind: "exact",
+				id: "n1.5-latest"
+			},
+			source: "https://docs.yutori.com/reference/navigator"
+		},
+		{
+			match: {
+				kind: "exact",
+				id: "n1.5-20260428"
+			},
+			source: "https://docs.yutori.com/reference/navigator"
+		}
+	]
+};
+const CUA_MODEL_OVERRIDES = {
+	openai: [cuaModel("openai", "gpt-5.5", "GPT-5.5"), cuaModel("openai", "gpt-5.5-2026-04-23", "GPT-5.5 (2026-04-23)")],
+	anthropic: [],
+	google: [],
+	tzafon: [cuaModel("tzafon", "tzafon.northstar-cua-fast", "Tzafon Northstar CUA Fast")],
+	yutori: [
+		cuaModel("yutori", "n1.5-latest", "Yutori Navigator n1.5"),
+		cuaModel("yutori", "n1.5-20260428", "Yutori Navigator n1.5 (2026-04-28)"),
+		cuaModel("yutori", "n1-latest", "Yutori Navigator n1"),
+		cuaModel("yutori", "n1-20260203", "Yutori Navigator n1 (2026-02-03)")
+	]
+};
+/**
+* Split a provider-qualified ref like `"openai:gpt-5.5"` into its parts.
+*
+* `"gemini:"` is accepted as an alias for the canonical `"google:"` prefix
+* and normalizes to provider `"google"`. Throws when the ref is unqualified
+* or names an unsupported provider.
+*/
+function parseCuaModelRef(ref) {
+	const idx = ref.indexOf(":");
+	if (idx <= 0 || idx === ref.length - 1) throw new Error(`CUA model ref must be provider-qualified as "<provider>:<model>"; got "${ref}"`);
+	const prefix = ref.slice(0, idx);
+	const provider = prefix === "gemini" ? "google" : prefix;
+	const model = ref.slice(idx + 1);
+	if (!isCuaProvider(provider)) throw new Error(`unsupported CUA provider "${prefix}" (expected one of: ${CUA_PROVIDERS.join(", ")})`);
+	return {
+		provider,
+		model
+	};
+}
+/** Join a provider and model id into a {@link CuaModelRef}. */
+function formatCuaModelRef(provider, model) {
+	return `${provider}:${model}`;
+}
+/**
+* List the computer-use-capable models this package curates, optionally
+* filtered to one provider. Merges pi-ai's registry with local overrides and
+* keeps only models annotated in {@link CUA_MODEL_ANNOTATIONS}.
+*/
+function listCuaModels(provider) {
+	const providers = provider ? [provider] : [...CUA_PROVIDERS];
+	const byRef = /* @__PURE__ */ new Map();
+	for (const p of providers) {
+		for (const model of CUA_MODEL_OVERRIDES[p]) {
+			const ref = formatCuaModelRef(p, model.id);
+			byRef.set(ref, {
+				ref,
+				provider: p,
+				model: model.id,
+				name: model.name
+			});
+		}
+		for (const model of getModels(p)) {
+			if (!supportsCuaProvider(p, model.id)) continue;
+			const ref = formatCuaModelRef(p, model.id);
+			if (byRef.has(ref)) continue;
+			byRef.set(ref, {
+				ref,
+				provider: p,
+				model: model.id,
+				name: model.name
+			});
+		}
+	}
+	return [...byRef.values()].sort(compareCuaModels);
+}
+/**
+* Resolve a {@link CuaModelRef} to a concrete pi-ai model.
+*
+* Throws when the ref is unqualified, names an unsupported provider, or names
+* a model without a CUA-support annotation. `"gemini:"` refs are accepted as
+* an alias for `"google:"` (see {@link parseCuaModelRef}).
+*/
+function getCuaModel(ref) {
+	const { provider, model: modelId } = parseCuaModelRef(ref);
+	if (!supportsCuaProvider(provider, modelId)) throw new Error(`unsupported CUA model "${ref}"`);
+	const fromRegistry = getModel(provider, modelId);
+	if (fromRegistry) return fromRegistry;
+	const override = CUA_MODEL_OVERRIDES[provider].find((m) => m.id === modelId);
+	if (override) return override;
+	throw new Error(`CUA model "${ref}" is supported but not registered. Add it to pi-ai (models.dev) or CUA_MODEL_OVERRIDES.`);
+}
+/** Return the {@link CuaProvider} for a concrete model, or throw when it is not a CUA provider. */
+function providerForModel(model) {
+	if (!isCuaProvider(model.provider)) throw new Error(`unsupported CUA model provider "${model.provider}" (expected one of: ${CUA_PROVIDERS.join(", ")})`);
+	return model.provider;
+}
+/** Narrow an arbitrary string to {@link CuaProvider}. */
+function isCuaProvider(value) {
+	return CUA_PROVIDERS.includes(value);
+}
+function supportsCuaProvider(provider, modelId) {
+	return findCuaAnnotation(provider, modelId) !== void 0;
+}
+/** Find the CUA-support annotation covering a model id, if any. */
+function findCuaAnnotation(provider, modelId) {
+	const id = modelId.toLowerCase();
+	for (const annotation of CUA_MODEL_ANNOTATIONS[provider]) if (annotation.match.kind === "exact") {
+		if (id === annotation.match.id.toLowerCase()) return annotation;
+	} else if (isCuaFamilyMatch(id, annotation.match.family.toLowerCase())) return annotation;
+}
+function isCuaFamilyMatch(id, family) {
+	if (id === family) return true;
+	if (!id.startsWith(`${family}-`)) return false;
+	return id.slice(family.length + 1).split("-").every((segment) => /^\d+$/.test(segment));
+}
+function cuaModel(provider, id, name) {
+	const base = {
+		id,
+		name,
+		provider,
+		reasoning: provider === "openai" || provider === "anthropic" || provider === "google",
+		input: ["text", "image"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		}
+	};
+	switch (provider) {
+		case "openai": return {
+			...base,
+			api: "openai-responses",
+			baseUrl: "https://api.openai.com/v1",
+			contextWindow: 4e5,
+			maxTokens: 32768
+		};
+		case "anthropic": return {
+			...base,
+			api: "anthropic-messages",
+			baseUrl: "https://api.anthropic.com",
+			contextWindow: 2e5,
+			maxTokens: 64e3
+		};
+		case "google": return {
+			...base,
+			api: "google-generative-ai",
+			baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+			contextWindow: 1048576,
+			maxTokens: 65536
+		};
+		case "tzafon": return {
+			...base,
+			api: "tzafon-responses",
+			baseUrl: "https://api.lightcone.ai",
+			contextWindow: 128e3,
+			maxTokens: 4096
+		};
+		case "yutori": return {
+			...base,
+			api: "yutori-chat-completions",
+			baseUrl: "https://api.yutori.com/v1",
+			contextWindow: 128e3,
+			maxTokens: 4096
+		};
+	}
+}
+function compareCuaModels(a, b) {
+	if (a.provider !== b.provider) return CUA_PROVIDERS.indexOf(a.provider) - CUA_PROVIDERS.indexOf(b.provider);
+	return a.model.localeCompare(b.model);
+}
+//#endregion
+//#region src/api-keys.ts
+/**
+* Environment variables accepted for each CUA provider.
+*
+* This mirrors pi-ai's approach: model lookup is pure, while auth is resolved
+* when streaming. These helpers let callers share one readable convention for
+* explicit `getApiKey` wiring (especially useful for `google` vs `gemini`).
+*/
+const CUA_PROVIDER_API_KEY_ENV_VARS = {
+	openai: ["OPENAI_API_KEY"],
+	anthropic: ["ANTHROPIC_OAUTH_TOKEN", "ANTHROPIC_API_KEY"],
+	google: ["GOOGLE_API_KEY", "GEMINI_API_KEY"],
+	tzafon: ["TZAFON_API_KEY"],
+	yutori: ["YUTORI_API_KEY"]
+};
+/**
+* List the environment variables checked for a provider's API key, in
+* precedence order. Accepts `"gemini"` as an alias for `"google"`; returns an
+* empty list for unknown providers.
+*/
+function cuaApiKeyEnvVarsForProvider(provider) {
+	if (provider === "gemini") return CUA_PROVIDER_API_KEY_ENV_VARS.google;
+	return CUA_PROVIDER_API_KEY_ENV_VARS[provider] ?? [];
+}
+/** Read a provider's API key from the environment, or return undefined when unset. */
+function getCuaEnvApiKey(provider) {
+	for (const envVar of cuaApiKeyEnvVarsForProvider(provider)) {
+		const value = process.env[envVar];
+		if (value?.trim()) return value;
+	}
+}
+/** Read a provider's API key from the environment, or throw naming the variables to set. */
+function requireCuaEnvApiKey(provider) {
+	const apiKey = getCuaEnvApiKey(provider);
+	if (apiKey) return apiKey;
+	const envVars = cuaApiKeyEnvVarsForProvider(provider);
+	if (envVars.length === 0) throw new Error(`No known API key environment variables for provider "${provider}"`);
+	throw new Error(`Missing API key for "${provider}". Set one of: ${envVars.join(", ")}`);
+}
+/** {@link getCuaEnvApiKey} keyed by a model ref or concrete model instead of a provider name. */
+function getCuaEnvApiKeyForModel(input) {
+	return getCuaEnvApiKey(typeof input === "string" ? parseCuaModelRef(input).provider : providerForModel(input));
+}
+/** {@link requireCuaEnvApiKey} keyed by a model ref or concrete model instead of a provider name. */
+function requireCuaEnvApiKeyForModel(input) {
+	return requireCuaEnvApiKey(typeof input === "string" ? parseCuaModelRef(input).provider : providerForModel(input));
+}
+//#endregion
+//#region src/providers/anthropic/actions.ts
+/**
+* Canonical CUA action types Anthropic browser computer-use tools support.
+*
+* Source of truth: Anthropic's computer-use best-practices quickstart
+* computer/browser tool action enums. These are the browser actions Anthropic
+* currently accepts under CUA's canonical individual tool names.
+* https://github.com/anthropics/claude-quickstarts/blob/main/computer-use-best-practices/computer_use/tools/computer.py
+* https://github.com/anthropics/claude-quickstarts/blob/main/computer-use-best-practices/computer_use/tools/browser.py
+*/
+const ANTHROPIC_CUA_ACTION_TYPES = [
+	"click",
+	"double_click",
+	"mouse_down",
+	"mouse_up",
+	"type",
+	"keypress",
+	"scroll",
+	"move",
+	"drag",
+	"wait",
+	"screenshot",
+	"goto",
+	"cursor_position"
+];
+const ANTHROPIC_CANONICAL_ACTION_TYPE_SET = new Set(ANTHROPIC_CUA_ACTION_TYPES);
+/** Name of the batch tool included by default in Anthropic computer-use tools. */
+const ANTHROPIC_BATCH_TOOL_NAME = CUA_BATCH_TOOL_NAME;
+const ANTHROPIC_BATCH_TOOL_DESCRIPTION = [CUA_BATCH_TOOL_DESCRIPTION, "Coordinates in a batch refer to the screenshot taken before the batch call."].join("\n");
+function resolveAnthropicActions(actions) {
+	const resolved = actions ?? ANTHROPIC_CUA_ACTION_TYPES;
+	const supported = [];
+	const unsupported = [];
+	for (const action of resolved) if (isAnthropicCanonicalAction(action)) supported.push(action);
+	else unsupported.push(action);
+	if (unsupported.length > 0) throw new Error(`unsupported Anthropic canonical action(s): ${unsupported.join(", ")}`);
+	return supported;
+}
+function isAnthropicCanonicalAction(action) {
+	return ANTHROPIC_CANONICAL_ACTION_TYPE_SET.has(action);
+}
+/** Build the TypeBox schema for Anthropic-supported canonical browser actions. */
+function createActionSchema(actions) {
+	return createCuaActionSchema(resolveAnthropicActions(actions));
+}
+/**
+* Build Anthropic CUA computer-use tools.
+*
+* Use this when calling `complete()` or `stream()` directly and you need an
+* array of `Tool` objects for Anthropic browser actions. Pass `actions` to
+* expose only a supported subset, such as `["click"]`. Anthropic includes a
+* batch tool by default; pass `excludeBatch: true` to omit it.
+*/
+function computerTools$1(options = {}) {
+	const actions = resolveAnthropicActions(options.actions);
+	const tools = createCuaActionToolDefinitions(actions);
+	if (!options.excludeBatch) tools.push(createCuaBatchToolDefinition(actions, {
+		name: ANTHROPIC_BATCH_TOOL_NAME,
+		description: ANTHROPIC_BATCH_TOOL_DESCRIPTION
+	}));
+	return tools;
+}
+/** Build the local execution adapters used by CuaAgent and CuaAgentHarness. */
+function computerToolExecutors$1(options = {}) {
+	const actions = resolveAnthropicActions(options.actions);
+	const executors = createCuaActionToolExecutors(actions);
+	if (!options.excludeBatch) executors.push(createCuaBatchToolExecutor(actions, {
+		name: ANTHROPIC_BATCH_TOOL_NAME,
+		description: ANTHROPIC_BATCH_TOOL_DESCRIPTION
+	}));
+	return executors;
+}
+//#endregion
+//#region src/providers/anthropic/index.ts
+var anthropic_exports = /* @__PURE__ */ __exportAll({
+	ANTHROPIC_BATCH_TOOL_NAME: () => ANTHROPIC_BATCH_TOOL_NAME,
+	ANTHROPIC_COMPUTER_INSTRUCTIONS: () => ANTHROPIC_COMPUTER_INSTRUCTIONS,
+	ANTHROPIC_CUA_ACTION_TYPES: () => ANTHROPIC_CUA_ACTION_TYPES,
+	buildAnthropicSystemPrompt: () => buildAnthropicSystemPrompt,
+	computerToolExecutors: () => computerToolExecutors$1,
+	computerTools: () => computerTools$1,
+	coordinateSystem: () => coordinateSystem$4,
+	createActionSchema: () => createActionSchema,
+	providerModule: () => providerModule$4
+});
+function coordinateSystem$4() {
+	return { type: "pixel" };
+}
+const ANTHROPIC_COMPUTER_INSTRUCTIONS = `You control a Kernel cloud browser through individual browser tools. Use keyboard navigation where possible, and request screenshots when you need to inspect state.`;
+function buildAnthropicSystemPrompt(opts = {}) {
+	return [ANTHROPIC_COMPUTER_INSTRUCTIONS, opts.suffix].filter(Boolean).join("\n\n");
+}
+const providerModule$4 = {
+	toolDefinitions: computerTools$1,
+	toolExecutors: computerToolExecutors$1,
+	coordinateSystem: coordinateSystem$4,
+	buildSystemPrompt: buildAnthropicSystemPrompt
+};
+//#endregion
+//#region src/providers/gemini/index.ts
+var gemini_exports = /* @__PURE__ */ __exportAll({
+	GEMINI_COMPUTER_INSTRUCTIONS: () => GEMINI_COMPUTER_INSTRUCTIONS,
+	GEMINI_CUA_ACTION_TYPES: () => CUA_ACTION_TYPES,
+	buildGeminiSystemPrompt: () => buildGeminiSystemPrompt,
+	computerToolExecutors: () => computerToolExecutors,
+	computerTools: () => computerTools,
+	coordinateSystem: () => coordinateSystem$3,
+	createActionSchema: () => createCuaActionSchema,
+	providerModule: () => providerModule$3
+});
+function coordinateSystem$3() {
+	return {
+		type: "normalized",
+		range: [0, 999]
+	};
+}
+const GEMINI_COMPUTER_INSTRUCTIONS = `You control a Kernel cloud browser through individual browser tools. Use the provider coordinate system for tool calls, and request screenshots or URL reads when state changes.`;
+function buildGeminiSystemPrompt(opts = {}) {
+	return [GEMINI_COMPUTER_INSTRUCTIONS, opts.suffix].filter(Boolean).join("\n\n");
+}
+const providerModule$3 = {
+	toolDefinitions: computerTools,
+	toolExecutors: computerToolExecutors,
+	coordinateSystem: coordinateSystem$3,
+	buildSystemPrompt: buildGeminiSystemPrompt
+};
+//#endregion
+//#region src/providers/openai/index.ts
+var openai_exports = /* @__PURE__ */ __exportAll({
+	OPENAI_COMPUTER_INSTRUCTIONS: () => OPENAI_COMPUTER_INSTRUCTIONS,
+	OPENAI_CUA_ACTION_TYPES: () => CUA_ACTION_TYPES,
+	OPENAI_EXTRA_TOOL_DESCRIPTION: () => CUA_NAVIGATION_TOOL_DESCRIPTION,
+	OPENAI_EXTRA_TOOL_NAME: () => CUA_NAVIGATION_TOOL_NAME,
+	OpenAIExtraSchema: () => CuaNavigationSchema,
+	buildOpenAISystemPrompt: () => buildOpenAISystemPrompt,
+	computerToolExecutors: () => computerToolExecutors,
+	computerTools: () => computerTools,
+	coordinateSystem: () => coordinateSystem$2,
+	createActionSchema: () => createCuaActionSchema,
+	openaiResponsesStoreOnPayload: () => openaiResponsesStoreOnPayload,
+	providerModule: () => providerModule$2
+});
+function coordinateSystem$2() {
+	return { type: "pixel" };
+}
+const OPENAI_COMPUTER_INSTRUCTIONS = `You control a Kernel cloud browser through individual browser tools. Use the available tools for browser interaction and request explicit url, cursor_position, or screenshot reads when you need updated state.`;
+function buildOpenAISystemPrompt(opts = {}) {
+	return [OPENAI_COMPUTER_INSTRUCTIONS, opts.suffix].filter(Boolean).join("\n\n");
+}
+function openaiResponsesStoreOnPayload(payload) {
+	if (!payload || typeof payload !== "object") return void 0;
+	const current = payload;
+	if (current.store === true) return void 0;
+	return {
+		...current,
+		store: true
+	};
+}
+const providerModule$2 = {
+	toolDefinitions: computerTools,
+	toolExecutors: computerToolExecutors,
+	coordinateSystem: coordinateSystem$2,
+	buildSystemPrompt: buildOpenAISystemPrompt,
+	onPayload: openaiResponsesStoreOnPayload
+};
+//#endregion
+//#region src/providers/tzafon/index.ts
+var tzafon_exports = /* @__PURE__ */ __exportAll({
+	TZAFON_COMPUTER_INSTRUCTIONS: () => TZAFON_COMPUTER_INSTRUCTIONS,
+	TZAFON_CUA_ACTION_TYPES: () => CUA_ACTION_TYPES,
+	TZAFON_RESPONSES_API: () => TZAFON_RESPONSES_API,
+	buildTzafonSystemPrompt: () => buildTzafonSystemPrompt,
+	computerToolExecutors: () => computerToolExecutors,
+	computerTools: () => computerTools,
+	coordinateSystem: () => coordinateSystem$1,
+	createActionSchema: () => createCuaActionSchema,
+	providerModule: () => providerModule$1,
+	streamSimpleTzafonResponses: () => streamSimpleTzafonResponses,
+	streamTzafonResponses: () => streamTzafonResponses,
+	toCanonicalActions: () => toCanonicalActions$1,
+	tzafonComputerUseOnPayload: () => tzafonComputerUseOnPayload,
+	tzafonToolCallId: () => tzafonToolCallId
+});
+function coordinateSystem$1() {
+	return {
+		type: "normalized",
+		range: [0, 999]
+	};
+}
+const TZAFON_COMPUTER_INSTRUCTIONS = `You control a Kernel cloud browser through individual browser tools. Include screenshot or URL reads when you need updated state.`;
+/** Build the default system prompt used with Tzafon CUA models. */
+function buildTzafonSystemPrompt(opts = {}) {
+	return [TZAFON_COMPUTER_INSTRUCTIONS, opts.suffix].filter(Boolean).join("\n\n");
+}
+const providerModule$1 = {
+	toolDefinitions: computerTools,
+	toolExecutors: computerToolExecutors,
+	coordinateSystem: coordinateSystem$1,
+	buildSystemPrompt: buildTzafonSystemPrompt,
+	onPayload: tzafonComputerUseOnPayload
+};
+//#endregion
+//#region src/providers/yutori/index.ts
+var yutori_exports = /* @__PURE__ */ __exportAll({
+	YUTORI_CHAT_COMPLETIONS_API: () => YUTORI_CHAT_COMPLETIONS_API,
+	YUTORI_COMPUTER_INSTRUCTIONS: () => "",
+	YUTORI_CUA_ACTION_TYPES: () => YUTORI_CUA_ACTION_TYPES,
+	YUTORI_N15_ACTION_TYPES: () => YUTORI_N15_ACTION_TYPES,
+	YUTORI_N15_CORE_ACTION_TYPES: () => YUTORI_N15_CORE_ACTION_TYPES,
+	YUTORI_N15_CORE_TOOL_SET: () => YUTORI_N15_CORE_TOOL_SET,
+	YUTORI_N15_EXPANDED_ACTION_TYPES: () => YUTORI_N15_EXPANDED_ACTION_TYPES,
+	YUTORI_N15_EXPANDED_TOOL_SET: () => YUTORI_N15_EXPANDED_TOOL_SET,
+	YUTORI_N1_ACTION_TYPES: () => YUTORI_N1_ACTION_TYPES,
+	buildYutoriSystemPrompt: () => buildYutoriSystemPrompt,
+	computerToolExecutors: () => computerToolExecutors$2,
+	computerTools: () => computerTools$2,
+	coordinateSystem: () => coordinateSystem,
+	createActionSchema: () => createActionSchema$1,
+	providerModule: () => providerModule,
+	streamSimpleYutori: () => streamSimpleYutori,
+	streamYutori: () => streamYutori,
+	toCanonicalActions: () => toCanonicalActions,
+	yutoriCuaOnPayload: () => yutoriCuaOnPayload,
+	yutoriNativeActionsForModel: () => yutoriNativeActionsForModel,
+	yutoriNativeToolSetOnPayload: () => yutoriNativeToolSetOnPayload,
+	yutoriToolSetForModel: () => yutoriToolSetForModel
+});
+function coordinateSystem() {
+	return {
+		type: "normalized",
+		range: [0, 1e3]
+	};
+}
+function buildYutoriSystemPrompt(opts = {}) {
+	return ["", opts.suffix].filter(Boolean).join("\n\n");
+}
+const providerModule = {
+	toolDefinitions: () => [],
+	toolExecutors: computerToolExecutors$2,
+	coordinateSystem,
+	buildSystemPrompt: buildYutoriSystemPrompt,
+	onPayload: yutoriCuaOnPayload,
+	screenshot: {
+		appendToLatestMessage: true,
+		transform: {
+			width: 1280,
+			height: 800,
+			format: "webp",
+			quality: 90
+		}
+	}
+};
+//#endregion
+//#region src/runtime-spec.ts
+const PROVIDERS = {
+	openai: providerModule$2,
+	anthropic: providerModule$4,
+	google: providerModule$3,
+	tzafon: providerModule$1,
+	yutori: providerModule
+};
+/**
+* Resolve provider defaults from either a CUA model ref or a concrete model.
+*
+* Use the returned spec to build computer-use requests without hard-coding
+* model-provider rules in your application. Pass `options` (e.g.
+* `{ actions: ["click"] }`) to narrow the resolved tool definitions and
+* executors to a supported subset.
+*/
+function resolveCuaRuntimeSpec(input, options) {
+	const model = typeof input === "string" ? getCuaModel(input) : input;
+	const provider = providerForModel(model);
+	const mod = PROVIDERS[provider];
+	return {
+		model,
+		provider,
+		toolDefinitions: mod.toolDefinitions(options),
+		toolExecutors: mod.toolExecutors(options),
+		defaultSystemPrompt: mod.buildSystemPrompt(),
+		coordinateSystem: mod.coordinateSystem(),
+		screenshot: mod.screenshot,
+		onPayload: mod.onPayload
+	};
+}
+//#endregion
+//#region src/index.ts
 registerCuaProviders();
-//# sourceMappingURL=index.js.map
+//#endregion
+export { CUA_ACTION_TYPES, CUA_BATCH_TOOL_DESCRIPTION, CUA_BATCH_TOOL_NAME, CUA_MODEL_ANNOTATIONS, CUA_NAVIGATION_TOOL_DESCRIPTION, CUA_NAVIGATION_TOOL_NAME, CUA_PROVIDERS, CuaActionSchema, CuaBatchSchema, CuaNavigationSchema, anthropic_exports as anthropic, canonicalToolCallArguments, canonicalToolCallName, computerToolExecutors, computerTools, createCuaActionSchema, createCuaActionToolDefinitions, createCuaActionToolExecutors, createCuaBatchSchema, createCuaBatchToolDefinition, createCuaBatchToolExecutor, createCuaNavigationToolDefinition, cuaApiKeyEnvVarsForProvider, findCuaAnnotation, formatCuaModelRef, gemini_exports as gemini, getCuaEnvApiKey, getCuaEnvApiKeyForModel, getCuaModel, isCuaProvider, listCuaModels, normalizeGotoUrl, openai_exports as openai, parseCuaModelRef, providerForModel, registerCuaProviders, requireCuaEnvApiKey, requireCuaEnvApiKeyForModel, resolveCuaRuntimeSpec, tzafon_exports as tzafon, yutori_exports as yutori };