@onkernel/cua-ai 0.0.1 → 0.2.0

package/dist/index.d.ts

@@ -1,11 +1,577 @@
+import { Api, Model, SimpleStreamOptions, Static, StreamFunction, StreamOptions, TSchema, Tool, Type } from "@earendil-works/pi-ai";
 export * from "@earendil-works/pi-ai";
-export * from "./models.js";
-export * from "./api-keys.js";
-export * from "./runtime-spec.js";
-export * from "./providers/common.js";
-export * as anthropic from "./providers/anthropic/index.js";
-export * as gemini from "./providers/gemini/index.js";
-export * as openai from "./providers/openai/index.js";
-export * as tzafon from "./providers/tzafon/index.js";
-export * as yutori from "./providers/yutori/index.js";
-//# sourceMappingURL=index.d.ts.map
+
+//#region src/models.d.ts
+/** Providers with curated computer-use model support. */
+type CuaProvider = "openai" | "anthropic" | "google" | "tzafon" | "yutori";
+/** Provider-qualified model reference, e.g. `"openai:gpt-5.5"` or `"google:gemini-3-flash-preview"`. */
+type CuaModelRef = `${CuaProvider}:${string}`;
+/** One entry returned by {@link listCuaModels}. */
+interface CuaModelInfo {
+  /** Provider-qualified ref accepted by {@link getCuaModel}. */
+  ref: CuaModelRef;
+  provider: CuaProvider;
+  /** Provider-native model id (the part after the colon). */
+  model: string;
+  /** Human-readable model name. */
+  name: string;
+}
+/** All providers this package curates computer-use models for. */
+declare const CUA_PROVIDERS: readonly CuaProvider[];
+/**
+ * How a {@link CuaModelAnnotation} matches model ids.
+ *
+ * - `exact`: `id === match.id`
+ * - `family`: `id === match.family`, or `match.family` plus hyphen-separated
+ *   numeric segments (revisions and dated snapshots, e.g. "claude-opus-4-7",
+ *   "gpt-5.5-2026-04-23"). Named variants like "gpt-5.4-mini" are distinct
+ *   models and need their own entry.
+ */
+type CuaModelMatch = {
+  readonly kind: "exact";
+  readonly id: string;
+} | {
+  readonly kind: "family";
+  readonly family: string;
+};
+/** One CUA-support annotation: a model-id match plus the official source documenting support. */
+interface CuaModelAnnotation {
+  readonly match: CuaModelMatch;
+  /** URL of the provider documentation establishing computer-use support. */
+  readonly source: string;
+}
+/**
+ * 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.
+ */
+declare const CUA_MODEL_ANNOTATIONS: Record<CuaProvider, readonly CuaModelAnnotation[]>;
+/**
+ * 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.
+ */
+declare function parseCuaModelRef(ref: string): {
+  provider: CuaProvider;
+  model: string;
+};
+/** Join a provider and model id into a {@link CuaModelRef}. */
+declare function formatCuaModelRef(provider: CuaProvider, model: string): CuaModelRef;
+/**
+ * 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}.
+ */
+declare function listCuaModels(provider?: CuaProvider): CuaModelInfo[];
+/**
+ * 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}).
+ */
+declare function getCuaModel(ref: CuaModelRef): Model<Api>;
+/** Return the {@link CuaProvider} for a concrete model, or throw when it is not a CUA provider. */
+declare function providerForModel(model: Model<Api>): CuaProvider;
+/** Narrow an arbitrary string to {@link CuaProvider}. */
+declare function isCuaProvider(value: string): value is CuaProvider;
+/** Find the CUA-support annotation covering a model id, if any. */
+declare function findCuaAnnotation(provider: CuaProvider, modelId: string): CuaModelAnnotation | undefined;
+//#endregion
+//#region src/providers/common.d.ts
+declare const CUA_ACTION_TYPES: readonly ["click", "double_click", "mouse_down", "mouse_up", "type", "keypress", "scroll", "move", "drag", "wait", "screenshot", "goto", "back", "forward", "url", "cursor_position"];
+type CuaActionType = (typeof CUA_ACTION_TYPES)[number];
+/**
+ * Mouse buttons accepted by click, mouse_down, and mouse_up actions. The
+ * executor coerces anything outside this set to "left".
+ */
+type CuaMouseButton = "left" | "right" | "middle" | "back" | "forward";
+/**
+ * Mouse buttons accepted by drag actions. The executor coerces anything
+ * outside this set to "left".
+ */
+type CuaDragMouseButton = "left" | "right" | "middle";
+interface CuaActionClick {
+  type: "click";
+  x: number;
+  y: number;
+  button?: CuaMouseButton;
+  hold_keys?: string[];
+}
+interface CuaActionDoubleClick {
+  type: "double_click";
+  x: number;
+  y: number;
+  hold_keys?: string[];
+}
+interface CuaActionMouseDown {
+  type: "mouse_down";
+  x: number;
+  y: number;
+  button?: CuaMouseButton;
+  hold_keys?: string[];
+}
+interface CuaActionMouseUp {
+  type: "mouse_up";
+  x: number;
+  y: number;
+  button?: CuaMouseButton;
+  hold_keys?: string[];
+}
+interface CuaActionTypeText {
+  type: "type";
+  text: string;
+}
+interface CuaActionKeypress {
+  type: "keypress";
+  keys: string[];
+  duration?: number;
+}
+interface CuaActionScroll {
+  type: "scroll";
+  x?: number;
+  y?: number;
+  scroll_x?: number;
+  scroll_y?: number;
+  hold_keys?: string[];
+}
+interface CuaActionMove {
+  type: "move";
+  x: number;
+  y: number;
+}
+interface CuaActionDrag {
+  type: "drag";
+  path: Array<{
+    x: number;
+    y: number;
+  }>;
+  button?: CuaDragMouseButton;
+  hold_keys?: string[];
+}
+interface CuaActionWait {
+  type: "wait";
+  ms?: number;
+}
+interface CuaActionScreenshot {
+  type: "screenshot";
+}
+interface CuaActionGoto {
+  type: "goto";
+  url: string;
+}
+interface CuaActionBack {
+  type: "back";
+}
+interface CuaActionForward {
+  type: "forward";
+}
+interface CuaActionUrl {
+  type: "url";
+}
+interface CuaActionCursorPosition {
+  type: "cursor_position";
+}
+type CuaAction = CuaActionClick | CuaActionDoubleClick | CuaActionMouseDown | CuaActionMouseUp | CuaActionTypeText | CuaActionKeypress | CuaActionScroll | CuaActionMove | CuaActionDrag | CuaActionWait | CuaActionScreenshot | CuaActionGoto | CuaActionBack | CuaActionForward | CuaActionUrl | CuaActionCursorPosition;
+declare function createCuaActionSchema(actions?: readonly CuaActionType[]): TSchema;
+declare function createCuaActionToolDefinitions(actions?: readonly CuaActionType[]): Tool[];
+declare const CuaActionSchema: Type.TSchema;
+declare function createCuaBatchSchema(actions?: readonly CuaActionType[]): TSchema;
+declare const CuaBatchSchema: Type.TSchema;
+declare const CuaNavigationSchema: Type.TObject<{
+  action: Type.TUnion<[Type.TLiteral<"goto">, Type.TLiteral<"back">, Type.TLiteral<"forward">, Type.TLiteral<"url">]>;
+  url: Type.TOptional<Type.TString>;
+}>;
+interface CuaBatchInput {
+  actions: CuaAction[];
+}
+type CuaNavigationInput = Static<typeof CuaNavigationSchema>;
+/** Tool schema plus execution adapter for a browser computer-use tool. */
+interface CuaToolExecutorSpec {
+  /** Tool schema installed by CuaAgent/CuaAgentHarness. The name must match the provider tool call name. */
+  definition: Tool;
+  /** Convert that tool's arguments into canonical CUA actions for browser execution. */
+  toActions(args: unknown): CuaAction[];
+}
+/**
+ * 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).
+ */
+declare const CUA_BATCH_TOOL_NAME = "computer_batch";
+declare const CUA_NAVIGATION_TOOL_NAME = "computer_use_extra";
+declare const CUA_BATCH_TOOL_DESCRIPTION: string;
+declare const CUA_NAVIGATION_TOOL_DESCRIPTION = "High-level browser navigation helpers for goto, back, forward, and url.";
+interface ComputerToolsOptions {
+  actions?: readonly CuaActionType[];
+}
+type ComputerToolCoordinateSystem = {
+  type: "pixel";
+} | {
+  type: "normalized";
+  range: readonly [number, number];
+};
+/**
+ * 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"]`.
+ */
+declare function computerTools(options?: ComputerToolsOptions): Tool[];
+/** Build execution adapters for individual canonical CUA action tools. */
+declare function createCuaActionToolExecutors(actions?: readonly CuaActionType[]): CuaToolExecutorSpec[];
+/** Return the canonical tool name that should execute a normalized CUA action. */
+declare function canonicalToolCallName(action: CuaAction): CuaActionType;
+/** Convert a normalized CUA action into tool-call arguments by removing its `type` tag. */
+declare function canonicalToolCallArguments(action: CuaAction): Record<string, unknown>;
+/** Prefix bare hostnames/paths with `https://` before browser navigation. */
+declare function normalizeGotoUrl(value: unknown): string | undefined;
+declare function createCuaBatchToolDefinition(actions?: readonly CuaActionType[], options?: {
+  name?: string;
+  description?: string;
+}): Tool;
+/** Build an execution adapter for a batch tool whose input is `{ actions }`. */
+declare function createCuaBatchToolExecutor(actions?: readonly CuaActionType[], options?: {
+  name?: string;
+  description?: string;
+}): CuaToolExecutorSpec;
+/** Build the provider's default CUA tool execution adapters. */
+declare function computerToolExecutors(options?: ComputerToolsOptions): CuaToolExecutorSpec[];
+declare function createCuaNavigationToolDefinition(): Tool;
+interface CuaScreenshotTransformSpec {
+  width: number;
+  height: number;
+  format: "png" | "jpeg" | "webp";
+  quality?: number;
+}
+interface CuaScreenshotSpec {
+  /** Append a provider-prepared screenshot to the latest user/tool message before each request. */
+  appendToLatestMessage?: boolean;
+  /** Optional image transform applied to Kernel screenshots before they are sent to the provider. */
+  transform?: CuaScreenshotTransformSpec;
+}
+interface CuaPayloadContext {
+  /** Tool names that should remain in the outbound provider payload even if the provider strips local CUA executors. */
+  keepToolNames?: readonly string[];
+  /** Capture a fresh browser screenshot, already transformed per the provider's screenshot spec. */
+  getScreenshot?: () => Promise<{
+    data: Buffer;
+    mimeType: string;
+  }>;
+}
+type CuaPayloadHook = (payload: unknown, model: Model<Api>, context?: CuaPayloadContext) => unknown | Promise<unknown>;
+/**
+ * Runtime configuration for a supported CUA model.
+ *
+ * Use this to pair a model with the agent tool definitions, baseline prompt,
+ * coordinate convention, screenshot policy, and request payload middleware
+ * expected by its provider.
+ */
+interface CuaRuntimeSpec {
+  model: Model<Api>;
+  provider: CuaProvider;
+  /** Provider-facing CUA tool definitions used for model requests. */
+  toolDefinitions: Tool[];
+  /** Local execution adapters that turn provider tool calls into canonical CUA actions. */
+  toolExecutors: CuaToolExecutorSpec[];
+  /** Provider-tuned baseline prompt for browser control behavior. */
+  defaultSystemPrompt: string;
+  /** Coordinate convention emitted by provider tool calls. */
+  coordinateSystem: ComputerToolCoordinateSystem;
+  /** Optional provider screenshot input policy used by CuaAgent/CuaAgentHarness. */
+  screenshot?: CuaScreenshotSpec;
+  /** Optional provider middleware for request payload adaptation. */
+  onPayload?: CuaPayloadHook;
+}
+type CuaRuntimeSpecInput = CuaModelRef | Model<Api>;
+/** Uniform provider contract resolved by the CUA runtime registry. */
+interface CuaProviderModule {
+  /** Model-facing CUA tool definitions sent in provider requests. */
+  toolDefinitions(options?: ComputerToolsOptions): Tool[];
+  /** Local execution adapters (provider tool-call name -> canonical CUA actions). */
+  toolExecutors(options?: ComputerToolsOptions): CuaToolExecutorSpec[];
+  /** Coordinate convention emitted by this provider's tool calls. */
+  coordinateSystem(): ComputerToolCoordinateSystem;
+  /** Provider-tuned baseline browser-control system prompt. */
+  buildSystemPrompt(opts?: {
+    suffix?: string;
+  }): string;
+  /** Optional request-payload middleware for provider protocol quirks. */
+  onPayload?: CuaPayloadHook;
+  /** Optional provider screenshot input policy. */
+  screenshot?: CuaScreenshotSpec;
+}
+//#endregion
+//#region src/providers/tzafon/provider.d.ts
+declare const TZAFON_RESPONSES_API = "tzafon-responses";
+/** Stream options accepted by {@link streamTzafonResponses}. */
+interface TzafonResponsesOptions extends StreamOptions {
+  /** Tool names to keep in the outbound payload even though they collide with local CUA action tool names. */
+  keepToolNames?: readonly string[];
+}
+declare const streamSimpleTzafonResponses: StreamFunction<typeof TZAFON_RESPONSES_API, SimpleStreamOptions>;
+declare const streamTzafonResponses: StreamFunction<typeof TZAFON_RESPONSES_API, TzafonResponsesOptions>;
+declare function tzafonComputerUseOnPayload(payload: unknown, _model?: Model<Api>, context?: CuaPayloadContext): unknown | undefined;
+/** Derive a unique canonical tool-call id for a Tzafon computer action. */
+declare function tzafonToolCallId(callId: string, actionIndex: number): string;
+/** A canonical CUA action, or the terminal `answer` text Tzafon emits when it is done. */
+type TzafonCanonicalAction = CuaAction | {
+  type: "answer";
+  text: string;
+};
+/** Normalize one Tzafon `computer_call.action` payload into canonical CUA actions. */
+declare function toCanonicalActions$1(action: unknown): TzafonCanonicalAction[];
+//#endregion
+//#region src/providers/yutori/provider.d.ts
+declare const YUTORI_CHAT_COMPLETIONS_API = "yutori-chat-completions";
+/** Stream options accepted by {@link streamYutori}. */
+interface YutoriOptions extends StreamOptions {
+  /** Tool names to keep in the outbound payload even though they collide with local CUA action tool names. */
+  keepToolNames?: readonly string[];
+}
+declare const streamYutori: StreamFunction<typeof YUTORI_CHAT_COMPLETIONS_API, YutoriOptions>;
+declare const streamSimpleYutori: StreamFunction<typeof YUTORI_CHAT_COMPLETIONS_API, SimpleStreamOptions>;
+declare function yutoriNativeToolSetOnPayload(payload: unknown, model?: Model<Api>, context?: CuaPayloadContext): unknown | undefined;
+/**
+ * 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.
+ */
+declare function yutoriCuaOnPayload(payload: unknown, model?: Model<Api>, context?: CuaPayloadContext): Promise<unknown | undefined>;
+//#endregion
+//#region src/providers.d.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.
+ */
+declare function registerCuaProviders(): void;
+//#endregion
+//#region src/api-keys.d.ts
+/**
+ * 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.
+ */
+declare function cuaApiKeyEnvVarsForProvider(provider: string): readonly string[];
+/** Read a provider's API key from the environment, or return undefined when unset. */
+declare function getCuaEnvApiKey(provider: string): string | undefined;
+/** Read a provider's API key from the environment, or throw naming the variables to set. */
+declare function requireCuaEnvApiKey(provider: string): string;
+/** {@link getCuaEnvApiKey} keyed by a model ref or concrete model instead of a provider name. */
+declare function getCuaEnvApiKeyForModel(input: CuaModelRef | Model<Api>): string | undefined;
+/** {@link requireCuaEnvApiKey} keyed by a model ref or concrete model instead of a provider name. */
+declare function requireCuaEnvApiKeyForModel(input: CuaModelRef | Model<Api>): string;
+//#endregion
+//#region src/runtime-spec.d.ts
+/**
+ * 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.
+ */
+declare function resolveCuaRuntimeSpec(input: CuaRuntimeSpecInput, options?: ComputerToolsOptions): CuaRuntimeSpec;
+//#endregion
+//#region src/providers/anthropic/actions.d.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
+ */
+declare const ANTHROPIC_CUA_ACTION_TYPES: readonly ["click", "double_click", "mouse_down", "mouse_up", "type", "keypress", "scroll", "move", "drag", "wait", "screenshot", "goto", "cursor_position"];
+type AnthropicCanonicalActionType = (typeof ANTHROPIC_CUA_ACTION_TYPES)[number];
+/** Name of the batch tool included by default in Anthropic computer-use tools. */
+declare const ANTHROPIC_BATCH_TOOL_NAME = "computer_batch";
+/** Options for building Anthropic browser computer-use tools. */
+interface AnthropicComputerToolsOptions extends ComputerToolsOptions {
+  /** Exclude the batch computer action tool from the returned tools. */
+  excludeBatch?: boolean;
+}
+/** Canonical CUA action shape supported by Anthropic browser computer-use tools. */
+type AnthropicAction = Extract<CuaAction, {
+  type: AnthropicCanonicalActionType;
+}>;
+/** Build the TypeBox schema for Anthropic-supported canonical browser actions. */
+declare function createActionSchema$1(actions?: readonly CuaActionType[]): TSchema;
+/**
+ * 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.
+ */
+declare function computerTools$2(options?: AnthropicComputerToolsOptions): Tool[];
+/** Build the local execution adapters used by CuaAgent and CuaAgentHarness. */
+declare function computerToolExecutors$2(options?: AnthropicComputerToolsOptions): CuaToolExecutorSpec[];
+declare namespace index_d_exports {
+  export { ANTHROPIC_BATCH_TOOL_NAME, ANTHROPIC_COMPUTER_INSTRUCTIONS, ANTHROPIC_CUA_ACTION_TYPES, AnthropicAction, AnthropicComputerToolsOptions, AnthropicComputerToolsOptions as ComputerToolsOptions, buildAnthropicSystemPrompt, computerToolExecutors$2 as computerToolExecutors, computerTools$2 as computerTools, coordinateSystem$4 as coordinateSystem, createActionSchema$1 as createActionSchema, providerModule$4 as providerModule };
+}
+declare function coordinateSystem$4(): ComputerToolCoordinateSystem;
+declare 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.";
+declare function buildAnthropicSystemPrompt(opts?: {
+  suffix?: string;
+}): string;
+declare const providerModule$4: {
+  toolDefinitions: typeof computerTools$2;
+  toolExecutors: typeof computerToolExecutors$2;
+  coordinateSystem: typeof coordinateSystem$4;
+  buildSystemPrompt: typeof buildAnthropicSystemPrompt;
+};
+declare namespace index_d_exports$1 {
+  export { ComputerToolsOptions, GEMINI_COMPUTER_INSTRUCTIONS, CUA_ACTION_TYPES as GEMINI_CUA_ACTION_TYPES, CuaAction as GeminiAction, buildGeminiSystemPrompt, computerToolExecutors, computerTools, coordinateSystem$3 as coordinateSystem, createCuaActionSchema as createActionSchema, providerModule$3 as providerModule };
+}
+declare function coordinateSystem$3(): ComputerToolCoordinateSystem;
+declare 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.";
+declare function buildGeminiSystemPrompt(opts?: {
+  suffix?: string;
+}): string;
+declare const providerModule$3: {
+  toolDefinitions: typeof computerTools;
+  toolExecutors: typeof computerToolExecutors;
+  coordinateSystem: typeof coordinateSystem$3;
+  buildSystemPrompt: typeof buildGeminiSystemPrompt;
+};
+declare namespace index_d_exports$2 {
+  export { ComputerToolsOptions, OPENAI_COMPUTER_INSTRUCTIONS, CUA_ACTION_TYPES as OPENAI_CUA_ACTION_TYPES, CUA_NAVIGATION_TOOL_DESCRIPTION as OPENAI_EXTRA_TOOL_DESCRIPTION, CUA_NAVIGATION_TOOL_NAME as OPENAI_EXTRA_TOOL_NAME, CuaAction as OpenAIAction, CuaNavigationInput as OpenAIExtraInput, CuaNavigationSchema as OpenAIExtraSchema, buildOpenAISystemPrompt, computerToolExecutors, computerTools, coordinateSystem$2 as coordinateSystem, createCuaActionSchema as createActionSchema, openaiResponsesStoreOnPayload, providerModule$2 as providerModule };
+}
+declare function coordinateSystem$2(): ComputerToolCoordinateSystem;
+declare 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.";
+declare function buildOpenAISystemPrompt(opts?: {
+  suffix?: string;
+}): string;
+declare function openaiResponsesStoreOnPayload(payload: unknown): unknown | undefined;
+declare const providerModule$2: {
+  toolDefinitions: typeof computerTools;
+  toolExecutors: typeof computerToolExecutors;
+  coordinateSystem: typeof coordinateSystem$2;
+  buildSystemPrompt: typeof buildOpenAISystemPrompt;
+  onPayload: typeof openaiResponsesStoreOnPayload;
+};
+declare namespace index_d_exports$3 {
+  export { ComputerToolsOptions, TZAFON_COMPUTER_INSTRUCTIONS, CUA_ACTION_TYPES as TZAFON_CUA_ACTION_TYPES, TZAFON_RESPONSES_API, CuaAction as TzafonAction, TzafonCanonicalAction, TzafonResponsesOptions, buildTzafonSystemPrompt, computerToolExecutors, computerTools, coordinateSystem$1 as coordinateSystem, createCuaActionSchema as createActionSchema, providerModule$1 as providerModule, streamSimpleTzafonResponses, streamTzafonResponses, toCanonicalActions$1 as toCanonicalActions, tzafonComputerUseOnPayload, tzafonToolCallId };
+}
+declare function coordinateSystem$1(): ComputerToolCoordinateSystem;
+declare 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. */
+declare function buildTzafonSystemPrompt(opts?: {
+  suffix?: string;
+}): string;
+declare const providerModule$1: {
+  toolDefinitions: typeof computerTools;
+  toolExecutors: typeof computerToolExecutors;
+  coordinateSystem: typeof coordinateSystem$1;
+  buildSystemPrompt: typeof buildTzafonSystemPrompt;
+  onPayload: typeof tzafonComputerUseOnPayload;
+};
+//#endregion
+//#region src/providers/yutori/actions.d.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
+ */
+declare const YUTORI_N15_CORE_TOOL_SET = "browser_tools_core-20260403";
+declare 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.
+ */
+declare const YUTORI_N15_EXPANDED_ACTION_TYPES: readonly ["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
+ */
+declare const YUTORI_N1_ACTION_TYPES: readonly ["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
+ */
+declare const YUTORI_N15_CORE_ACTION_TYPES: readonly ["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"];
+declare const YUTORI_N15_ACTION_TYPES: readonly ["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", "extract_elements", "find", "set_element_value", "execute_js"];
+/**
+ * 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.
+ */
+declare const YUTORI_CUA_ACTION_TYPES: readonly ["click", "double_click", "mouse_down", "mouse_up", "type", "keypress", "scroll", "move", "drag", "wait", "goto", "back", "forward"];
+type YutoriCanonicalActionType = (typeof YUTORI_CUA_ACTION_TYPES)[number];
+/** Canonical CUA action shape emitted for Yutori models. */
+type YutoriAction = Extract<CuaAction, {
+  type: YutoriCanonicalActionType;
+}>;
+type YutoriN1ActionType = (typeof YUTORI_N1_ACTION_TYPES)[number];
+type YutoriN15CoreActionType = (typeof YUTORI_N15_CORE_ACTION_TYPES)[number];
+type YutoriN15ExpandedActionType = (typeof YUTORI_N15_EXPANDED_ACTION_TYPES)[number];
+type YutoriNativeActionType = YutoriN1ActionType | YutoriN15CoreActionType | YutoriN15ExpandedActionType;
+/** Build the TypeBox schema for Yutori-supported canonical browser actions. */
+declare function createActionSchema(actions?: readonly CuaActionType[]): TSchema;
+/**
+ * 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"]`.
+ */
+declare function computerTools$1(options?: ComputerToolsOptions): Tool[];
+/** Build the local execution adapters used by CuaAgent and CuaAgentHarness. */
+declare function computerToolExecutors$1(options?: ComputerToolsOptions): CuaToolExecutorSpec[];
+declare function yutoriToolSetForModel(modelId: string): typeof YUTORI_N15_CORE_TOOL_SET | undefined;
+declare function yutoriNativeActionsForModel(modelId: string): readonly YutoriNativeActionType[];
+declare function toCanonicalActions(name: string, args: Record<string, unknown>): CuaAction[] | undefined;
+declare namespace index_d_exports$4 {
+  export { ComputerToolsOptions, YUTORI_CHAT_COMPLETIONS_API, YUTORI_COMPUTER_INSTRUCTIONS, YUTORI_CUA_ACTION_TYPES, YUTORI_N15_ACTION_TYPES, YUTORI_N15_CORE_ACTION_TYPES, YUTORI_N15_CORE_TOOL_SET, YUTORI_N15_EXPANDED_ACTION_TYPES, YUTORI_N15_EXPANDED_TOOL_SET, YUTORI_N1_ACTION_TYPES, YutoriAction, YutoriN15CoreActionType, YutoriN15ExpandedActionType, YutoriN1ActionType, YutoriNativeActionType, YutoriOptions, buildYutoriSystemPrompt, computerToolExecutors$1 as computerToolExecutors, computerTools$1 as computerTools, coordinateSystem, createActionSchema, providerModule, streamSimpleYutori, streamYutori, toCanonicalActions, yutoriCuaOnPayload, yutoriNativeActionsForModel, yutoriNativeToolSetOnPayload, yutoriToolSetForModel };
+}
+declare function coordinateSystem(): ComputerToolCoordinateSystem;
+declare const YUTORI_COMPUTER_INSTRUCTIONS = "";
+declare function buildYutoriSystemPrompt(opts?: {
+  suffix?: string;
+}): string;
+declare const providerModule: {
+  toolDefinitions: () => never[];
+  toolExecutors: typeof computerToolExecutors$1;
+  coordinateSystem: typeof coordinateSystem;
+  buildSystemPrompt: typeof buildYutoriSystemPrompt;
+  onPayload: typeof yutoriCuaOnPayload;
+  screenshot: {
+    appendToLatestMessage: true;
+    transform: {
+      width: number;
+      height: number;
+      format: "webp";
+      quality: number;
+    };
+  };
+};
+//#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, ComputerToolCoordinateSystem, ComputerToolsOptions, CuaAction, CuaActionBack, CuaActionClick, CuaActionCursorPosition, CuaActionDoubleClick, CuaActionDrag, CuaActionForward, CuaActionGoto, CuaActionKeypress, CuaActionMouseDown, CuaActionMouseUp, CuaActionMove, CuaActionSchema, CuaActionScreenshot, CuaActionScroll, CuaActionType, CuaActionTypeText, CuaActionUrl, CuaActionWait, CuaBatchInput, CuaBatchSchema, CuaDragMouseButton, CuaModelAnnotation, CuaModelInfo, CuaModelMatch, CuaModelRef, CuaMouseButton, CuaNavigationInput, CuaNavigationSchema, CuaPayloadContext, CuaPayloadHook, CuaProvider, CuaProviderModule, CuaRuntimeSpec, CuaRuntimeSpecInput, CuaScreenshotSpec, CuaScreenshotTransformSpec, CuaToolExecutorSpec, index_d_exports as anthropic, canonicalToolCallArguments, canonicalToolCallName, computerToolExecutors, computerTools, createCuaActionSchema, createCuaActionToolDefinitions, createCuaActionToolExecutors, createCuaBatchSchema, createCuaBatchToolDefinition, createCuaBatchToolExecutor, createCuaNavigationToolDefinition, cuaApiKeyEnvVarsForProvider, findCuaAnnotation, formatCuaModelRef, index_d_exports$1 as gemini, getCuaEnvApiKey, getCuaEnvApiKeyForModel, getCuaModel, isCuaProvider, listCuaModels, normalizeGotoUrl, index_d_exports$2 as openai, parseCuaModelRef, providerForModel, registerCuaProviders, requireCuaEnvApiKey, requireCuaEnvApiKeyForModel, resolveCuaRuntimeSpec, index_d_exports$3 as tzafon, index_d_exports$4 as yutori };