@skrr-ai/cli 0.1.114 → 0.1.116

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/computerUse.d.ts

@@ -0,0 +1,228 @@
+/**
+ * Computer Use v1 is a host-to-host protocol, never a model tool schema.
+ * Models see exactly the runtime's js/js_reset surface. In particular, script
+ * contents cannot prove that a call is read-only or supply execution identity.
+ * Kept dependency-free so daemon, API, browser and native clients agree.
+ */
+export declare const COMPUTER_USE_TOOL: "ComputerUse";
+export declare const COMPUTER_USE_PROVIDER: "lcu";
+export declare const COMPUTER_USE_PROTOCOL: "computer_use_mcp_v1";
+export declare const COMPUTER_USE_ROTATE_CREDENTIAL_EVENT: "daemon:computer-use:rotate-credential";
+/** Owner-approved hosted credential upgrade; no bearer secret travels in this request. */
+export interface ComputerUseRotateCredentialRequest {
+    requestId: string;
+    ownerUserId: string;
+    machineUuid: string;
+    leaseId: string;
+    generation: number;
+}
+export declare const COMPUTER_USE_EXECUTION_CAPABILITY: "computer_use";
+export declare const COMPUTER_USE_CLOUD_CONSENT: "computer_use_cloud_agents_v1";
+export declare const COMPUTER_USE_PUBLIC_TOOLS: readonly ["js", "js_reset"];
+export type ComputerUsePublicTool = (typeof COMPUTER_USE_PUBLIC_TOOLS)[number];
+export declare const COMPUTER_USE_OPERATIONS: readonly ["describe", "call", "end_turn", "close", "status", "control_stop"];
+export type ComputerUseOperation = (typeof COMPUTER_USE_OPERATIONS)[number];
+export type ComputerUseSurfaceMode = 'computer' | 'browser' | 'all';
+export type ComputerUseEndReason = 'Stop' | 'Interrupt';
+/** Identity is derived from authenticated execution, never tool arguments. */
+export interface ComputerUseHostContext {
+    principalId: string;
+    machineId: string;
+    sessionId: string;
+    turnId: string;
+    generation: number;
+    toolCallId?: string;
+    agentId?: string;
+    engine?: string;
+    conversationId?: string;
+    contextKey?: string;
+}
+export interface ComputerUseBudgets {
+    activeExecutionMs: number;
+    humanResponseMs: number;
+    totalLifetimeMs: number;
+    cleanupGraceMs: number;
+}
+export declare const COMPUTER_USE_DEFAULT_BUDGETS: Readonly<ComputerUseBudgets>;
+/** Negotiated ceilings; exceeding a limit is an error, never silent clipping. */
+export declare const COMPUTER_USE_LIMITS: Readonly<{
+    maxEnvelopeBytes: number;
+    maxInstructionsBytes: number;
+    maxSchemaBytes: number;
+    maxContentBlocks: 512;
+    maxIdentityChars: 512;
+    maxActiveExecutionMs: 900000;
+    maxHumanResponseMs: 900000;
+    maxTotalLifetimeMs: 1800000;
+    maxCleanupGraceMs: 60000;
+}>;
+/** Preserve upstream fields and schemas, including annotations and extensions. */
+export interface ComputerUseToolDescriptor {
+    name: ComputerUsePublicTool;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface ComputerUseMcpContent {
+    type: string;
+    [key: string]: unknown;
+}
+export interface ComputerUseMcpResult {
+    content: ComputerUseMcpContent[];
+    isError?: boolean;
+    structuredContent?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface ComputerUseVersions {
+    lcu: string;
+    adapter?: string;
+    app?: string;
+    runtime?: string;
+    [key: string]: string | undefined;
+}
+export interface ComputerUseRuntimePolicy {
+    replPersistence: 'turn';
+    audioCleanup: 'retire-runtime';
+}
+export interface ComputerUseSurface {
+    protocol: typeof COMPUTER_USE_PROTOCOL;
+    provider: typeof COMPUTER_USE_PROVIDER;
+    instructions: string;
+    tools: ComputerUseToolDescriptor[];
+    versions: ComputerUseVersions;
+    /** Digest of the actual instructions and full descriptors, not a version label. */
+    digest: string;
+    surfaceMode: ComputerUseSurfaceMode;
+    /** Host-observed lifecycle constraints, separate from original runtime instructions. */
+    runtimePolicy?: ComputerUseRuntimePolicy;
+}
+/** Preserve original documentation while explaining the host's narrower lifecycle. */
+export declare function computerUseModelInstructions(surface: ComputerUseSurface): string;
+export declare const COMPUTER_USE_RUNTIME_STATES: readonly ["disabled", "starting", "ready", "executing", "awaiting_approval", "ending_turn", "unavailable", "closed"];
+export type ComputerUseRuntimeState = (typeof COMPUTER_USE_RUNTIME_STATES)[number];
+export interface ComputerUseReadiness {
+    provider: typeof COMPUTER_USE_PROVIDER;
+    protocol: typeof COMPUTER_USE_PROTOCOL;
+    state: ComputerUseRuntimeState;
+    available: boolean;
+    enabled: boolean;
+    cloudAgentsAllowed: boolean;
+    reason?: string;
+    versions?: ComputerUseVersions;
+    surfaceDigest?: string;
+    /** Capability readiness is independent of whether a person granted consent. */
+    browserReady?: boolean;
+    audioReady?: boolean;
+}
+export interface ComputerUseStatus extends ComputerUseReadiness {
+    controller?: Pick<ComputerUseHostContext, 'sessionId' | 'turnId' | 'generation' | 'agentId' | 'conversationId'>;
+    pendingApprovalId?: string;
+    cleanupConfirmed?: boolean;
+}
+export type ComputerUseInput = {
+    operation: 'describe';
+    surfaceMode?: ComputerUseSurfaceMode;
+} | {
+    operation: 'call';
+    tool: ComputerUsePublicTool;
+    arguments: Record<string, unknown>;
+    surfaceDigest?: string;
+    budgets?: Partial<ComputerUseBudgets>;
+} | {
+    operation: 'end_turn';
+    reason: ComputerUseEndReason;
+} | {
+    operation: 'close';
+    reason?: string;
+} | {
+    operation: 'status';
+} | {
+    operation: 'control_stop';
+    reason?: string;
+};
+export type ComputerUseRequest = ComputerUseInput & {
+    protocol: typeof COMPUTER_USE_PROTOCOL;
+    provider: typeof COMPUTER_USE_PROVIDER;
+    context: ComputerUseHostContext;
+};
+export interface ComputerUseCleanupResult {
+    /** True only after the runtime confirms execution can no longer produce input. */
+    cleanupConfirmed: boolean;
+    closed: boolean;
+    generation: number;
+}
+export type ComputerUseResponse = {
+    operation: 'describe';
+    surface: ComputerUseSurface;
+} | {
+    operation: 'call';
+    mcpResult: ComputerUseMcpResult;
+} | {
+    operation: 'status';
+    status: ComputerUseStatus;
+} | {
+    operation: 'end_turn' | 'close' | 'control_stop';
+    cleanup: ComputerUseCleanupResult;
+};
+export declare const COMPUTER_USE_ELICITATION_CHOICES: readonly ["once", "session", "always", "decline"];
+export type ComputerUseElicitationChoice = (typeof COMPUTER_USE_ELICITATION_CHOICES)[number];
+export interface ComputerUseElicitationOption {
+    value: ComputerUseElicitationChoice;
+    label: string;
+    description?: string;
+}
+/** This is a dedicated permission request, not AskUserQuestion or sticky tool approval. */
+export interface ComputerUseElicitationRequest {
+    kind: 'computer_use_runtime';
+    requestId: string;
+    context: ComputerUseHostContext & {
+        toolCallId: string;
+    };
+    message: string;
+    resource?: Record<string, unknown>;
+    options: ComputerUseElicitationOption[];
+    expiresAt: number;
+}
+export interface ComputerUseElicitationResponse {
+    requestId: string;
+    context: ComputerUseHostContext & {
+        toolCallId: string;
+    };
+    choice: ComputerUseElicitationChoice;
+}
+export declare class ComputerUseContractError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+/** Validate the hosted rotation envelope before changing runtime admission. */
+export declare function assertComputerUseRotateCredentialRequest(value: unknown): asserts value is ComputerUseRotateCredentialRequest;
+export declare function assertComputerUseHostContext(value: unknown): asserts value is ComputerUseHostContext;
+export declare function computerUseBudgets(value?: unknown): ComputerUseBudgets;
+export declare function assertComputerUseInput(value: unknown): asserts value is ComputerUseInput;
+export declare function assertComputerUseRequest(value: unknown): asserts value is ComputerUseRequest;
+export declare function assertComputerUseSurface(value: unknown): asserts value is ComputerUseSurface;
+/** Validate the envelope without rewriting blocks or discarding upstream extensions. */
+export declare function assertComputerUseMcpResult(value: unknown): asserts value is ComputerUseMcpResult;
+/** Compare full execution identity; a matching conversation alone never grants access. */
+export declare function sameComputerUseContext(left: ComputerUseHostContext, right: ComputerUseHostContext): boolean;
+export declare function assertComputerUseElicitationRequest(value: unknown): asserts value is ComputerUseElicitationRequest;
+export declare function assertComputerUseElicitationResponse(value: unknown): asserts value is ComputerUseElicitationResponse;
+/** A human answer can only satisfy this exact pending request and offered scope.
+ * This matcher is not authentication: the caller must verify the human responder.
+ */
+export declare function acceptsComputerUseElicitationResponse(request: ComputerUseElicitationRequest, response: ComputerUseElicitationResponse, now?: number): boolean;
+export type ComputerUseModelProjectionOptions = {
+    audio: 'inline';
+} | {
+    audio: 'artifact-reference';
+    principalId: string;
+    sessionId: string;
+    consumer?: string;
+};
+/**
+ * Consumer capability projection, never a rewrite of the canonical daemon
+ * result. Some model hosts accept MCP AudioContent but silently omit its bytes.
+ * Those hosts receive explicit references to already-persisted owned audio.
+ * This function never uploads, transcribes, invents a path or grants access.
+ */
+export declare function projectComputerUseResultForModel(result: ComputerUseMcpResult, options: ComputerUseModelProjectionOptions): ComputerUseMcpResult;

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/computerUse.js

@@ -0,0 +1,407 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var computerUse_exports = {};
+__export(computerUse_exports, {
+  COMPUTER_USE_CLOUD_CONSENT: () => COMPUTER_USE_CLOUD_CONSENT,
+  COMPUTER_USE_DEFAULT_BUDGETS: () => COMPUTER_USE_DEFAULT_BUDGETS,
+  COMPUTER_USE_ELICITATION_CHOICES: () => COMPUTER_USE_ELICITATION_CHOICES,
+  COMPUTER_USE_EXECUTION_CAPABILITY: () => COMPUTER_USE_EXECUTION_CAPABILITY,
+  COMPUTER_USE_LIMITS: () => COMPUTER_USE_LIMITS,
+  COMPUTER_USE_OPERATIONS: () => COMPUTER_USE_OPERATIONS,
+  COMPUTER_USE_PROTOCOL: () => COMPUTER_USE_PROTOCOL,
+  COMPUTER_USE_PROVIDER: () => COMPUTER_USE_PROVIDER,
+  COMPUTER_USE_PUBLIC_TOOLS: () => COMPUTER_USE_PUBLIC_TOOLS,
+  COMPUTER_USE_ROTATE_CREDENTIAL_EVENT: () => COMPUTER_USE_ROTATE_CREDENTIAL_EVENT,
+  COMPUTER_USE_RUNTIME_STATES: () => COMPUTER_USE_RUNTIME_STATES,
+  COMPUTER_USE_TOOL: () => COMPUTER_USE_TOOL,
+  ComputerUseContractError: () => ComputerUseContractError,
+  acceptsComputerUseElicitationResponse: () => acceptsComputerUseElicitationResponse,
+  assertComputerUseElicitationRequest: () => assertComputerUseElicitationRequest,
+  assertComputerUseElicitationResponse: () => assertComputerUseElicitationResponse,
+  assertComputerUseHostContext: () => assertComputerUseHostContext,
+  assertComputerUseInput: () => assertComputerUseInput,
+  assertComputerUseMcpResult: () => assertComputerUseMcpResult,
+  assertComputerUseRequest: () => assertComputerUseRequest,
+  assertComputerUseRotateCredentialRequest: () => assertComputerUseRotateCredentialRequest,
+  assertComputerUseSurface: () => assertComputerUseSurface,
+  computerUseBudgets: () => computerUseBudgets,
+  computerUseModelInstructions: () => computerUseModelInstructions,
+  projectComputerUseResultForModel: () => projectComputerUseResultForModel,
+  sameComputerUseContext: () => sameComputerUseContext
+});
+module.exports = __toCommonJS(computerUse_exports);
+const COMPUTER_USE_TOOL = "ComputerUse";
+const COMPUTER_USE_PROVIDER = "lcu";
+const COMPUTER_USE_PROTOCOL = "computer_use_mcp_v1";
+const COMPUTER_USE_ROTATE_CREDENTIAL_EVENT = "daemon:computer-use:rotate-credential";
+const COMPUTER_USE_EXECUTION_CAPABILITY = "computer_use";
+const COMPUTER_USE_CLOUD_CONSENT = "computer_use_cloud_agents_v1";
+const COMPUTER_USE_PUBLIC_TOOLS = ["js", "js_reset"];
+const COMPUTER_USE_OPERATIONS = ["describe", "call", "end_turn", "close", "status", "control_stop"];
+const COMPUTER_USE_DEFAULT_BUDGETS = Object.freeze({
+  activeExecutionMs: 12e4,
+  humanResponseMs: 3e5,
+  totalLifetimeMs: 9e5,
+  cleanupGraceMs: 1e4
+});
+const COMPUTER_USE_LIMITS = Object.freeze({
+  maxEnvelopeBytes: 32 * 1024 * 1024,
+  maxInstructionsBytes: 1024 * 1024,
+  maxSchemaBytes: 1024 * 1024,
+  maxContentBlocks: 512,
+  maxIdentityChars: 512,
+  maxActiveExecutionMs: 9e5,
+  maxHumanResponseMs: 9e5,
+  maxTotalLifetimeMs: 18e5,
+  maxCleanupGraceMs: 6e4
+});
+function computerUseModelInstructions(surface) {
+  assertComputerUseSurface(surface);
+  if (!surface.runtimePolicy)
+    return surface.instructions;
+  return surface.instructions + "\n\nOverSky host policy\nAudio cleanup retires the complete runtime after js_reset and at the end of each host turn. JavaScript variables and application handles persist only within the current turn. Initialize fresh handles in the next turn; do not reuse handles from an earlier runtime.";
+}
+const COMPUTER_USE_RUNTIME_STATES = [
+  "disabled",
+  "starting",
+  "ready",
+  "executing",
+  "awaiting_approval",
+  "ending_turn",
+  "unavailable",
+  "closed"
+];
+const COMPUTER_USE_ELICITATION_CHOICES = ["once", "session", "always", "decline"];
+class ComputerUseContractError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ComputerUseContractError";
+  }
+}
+function fail(message) {
+  throw new ComputerUseContractError("invalid_computer_use_contract", message);
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function exactKeys(value, keys, name) {
+  if (Object.keys(value).some((key) => !keys.includes(key)))
+    fail(`Unsupported ${name} field`);
+}
+function identifier(value, name) {
+  if (typeof value !== "string" || value.trim().length === 0 || value.length > COMPUTER_USE_LIMITS.maxIdentityChars)
+    fail(`Invalid ${name}`);
+}
+function jsonSize(value) {
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (item) => {
+    if (item === null || typeof item === "string" || typeof item === "boolean")
+      return;
+    if (typeof item === "number" && Number.isFinite(item))
+      return;
+    if (typeof item !== "object" || !item || seen.has(item))
+      fail("Expected acyclic JSON data");
+    if (!Array.isArray(item) && Object.getPrototypeOf(item) !== Object.prototype && Object.getPrototypeOf(item) !== null)
+      fail("Expected plain JSON object");
+    seen.add(item);
+    for (const child of Array.isArray(item) ? item : Object.values(item))
+      visit(child);
+    seen.delete(item);
+  };
+  visit(value);
+  return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+}
+function boundedJson(value, max, name) {
+  if (jsonSize(value) > max)
+    fail(`${name} exceeds negotiated byte limit`);
+}
+function assertComputerUseRotateCredentialRequest(value) {
+  if (!record(value))
+    fail("Expected credential rotation request");
+  const ids = ["requestId", "ownerUserId", "machineUuid", "leaseId"];
+  exactKeys(value, [...ids, "generation"], "credential rotation");
+  for (const key of ids) {
+    identifier(value[key], key);
+    if (value[key].length > 160)
+      fail(`Invalid ${key}`);
+  }
+  if (!Number.isSafeInteger(value.generation) || value.generation < 1)
+    fail("Invalid hosted desktop generation");
+}
+function assertComputerUseHostContext(value) {
+  if (!record(value))
+    fail("Expected host context");
+  const required = ["principalId", "machineId", "sessionId", "turnId"];
+  const optional = ["toolCallId", "agentId", "engine", "conversationId", "contextKey"];
+  exactKeys(value, [...required, ...optional, "generation"], "host context");
+  for (const key of required)
+    identifier(value[key], key);
+  for (const key of optional)
+    if (value[key] !== void 0)
+      identifier(value[key], key);
+  if (!Number.isSafeInteger(value.generation) || value.generation < 0)
+    fail("Invalid generation");
+}
+function computerUseBudgets(value = {}) {
+  if (!record(value))
+    fail("Expected execution budgets");
+  const ceilings = {
+    activeExecutionMs: COMPUTER_USE_LIMITS.maxActiveExecutionMs,
+    humanResponseMs: COMPUTER_USE_LIMITS.maxHumanResponseMs,
+    totalLifetimeMs: COMPUTER_USE_LIMITS.maxTotalLifetimeMs,
+    cleanupGraceMs: COMPUTER_USE_LIMITS.maxCleanupGraceMs
+  };
+  exactKeys(value, Object.keys(ceilings), "budget");
+  const result = { ...COMPUTER_USE_DEFAULT_BUDGETS };
+  for (const key of Object.keys(ceilings)) {
+    if (value[key] === void 0)
+      continue;
+    if (!Number.isSafeInteger(value[key]) || value[key] <= 0 || value[key] > ceilings[key])
+      fail(`Invalid ${key}`);
+    result[key] = value[key];
+  }
+  if (result.totalLifetimeMs < result.activeExecutionMs || result.totalLifetimeMs < result.cleanupGraceMs)
+    fail("Total lifetime is shorter than execution or cleanup budget");
+  return result;
+}
+function assertComputerUseInput(value) {
+  if (!record(value))
+    fail("Expected Computer Use operation");
+  switch (value.operation) {
+    case "describe":
+      exactKeys(value, ["operation", "surfaceMode"], "describe");
+      if (value.surfaceMode !== void 0 && !["computer", "browser", "all"].includes(value.surfaceMode))
+        fail("Unsupported surface mode");
+      break;
+    case "call":
+      exactKeys(value, ["operation", "tool", "arguments", "surfaceDigest", "budgets"], "call");
+      if (!COMPUTER_USE_PUBLIC_TOOLS.includes(value.tool))
+        fail("Unsupported public tool");
+      if (!record(value.arguments))
+        fail("Expected original tool arguments");
+      if (value.surfaceDigest !== void 0)
+        identifier(value.surfaceDigest, "surfaceDigest");
+      if (value.budgets !== void 0)
+        computerUseBudgets(value.budgets);
+      break;
+    case "end_turn":
+      exactKeys(value, ["operation", "reason"], "end_turn");
+      if (value.reason !== "Stop" && value.reason !== "Interrupt")
+        fail("Unsupported end reason");
+      break;
+    case "close":
+    case "control_stop":
+      exactKeys(value, ["operation", "reason"], value.operation);
+      if (value.reason !== void 0)
+        identifier(value.reason, "reason");
+      break;
+    case "status":
+      exactKeys(value, ["operation"], "status");
+      break;
+    default:
+      fail("Unsupported Computer Use operation");
+  }
+  boundedJson(value, COMPUTER_USE_LIMITS.maxEnvelopeBytes, "Request");
+}
+function assertComputerUseRequest(value) {
+  if (!record(value) || value.protocol !== COMPUTER_USE_PROTOCOL || value.provider !== COMPUTER_USE_PROVIDER)
+    fail("Unsupported Computer Use protocol/provider");
+  assertComputerUseHostContext(value.context);
+  const { protocol: _protocol, provider: _provider, context, ...input } = value;
+  assertComputerUseInput(input);
+  if (input.operation === "call" && !context.toolCallId)
+    fail("Calls require exact host toolCallId");
+  boundedJson(value, COMPUTER_USE_LIMITS.maxEnvelopeBytes, "Request");
+}
+function assertComputerUseSurface(value) {
+  if (!record(value) || value.protocol !== COMPUTER_USE_PROTOCOL || value.provider !== COMPUTER_USE_PROVIDER)
+    fail("Unsupported Computer Use surface");
+  if (typeof value.instructions !== "string")
+    fail("Expected original runtime instructions");
+  if (new TextEncoder().encode(value.instructions).byteLength > COMPUTER_USE_LIMITS.maxInstructionsBytes)
+    fail("Instructions exceed negotiated byte limit");
+  identifier(value.digest, "surface digest");
+  if (!["computer", "browser", "all"].includes(value.surfaceMode))
+    fail("Unsupported surface mode");
+  if (value.runtimePolicy !== void 0) {
+    if (!record(value.runtimePolicy))
+      fail("Invalid host runtime policy");
+    exactKeys(value.runtimePolicy, ["replPersistence", "audioCleanup"], "host runtime policy");
+    if (value.runtimePolicy.replPersistence !== "turn" || value.runtimePolicy.audioCleanup !== "retire-runtime")
+      fail("Unsupported host runtime policy");
+  }
+  if (!record(value.versions) || typeof value.versions.lcu !== "string" || !value.versions.lcu)
+    fail("Missing LCU version");
+  if (Object.values(value.versions).some((v) => typeof v !== "string"))
+    fail("Invalid runtime version");
+  if (!Array.isArray(value.tools) || value.tools.length !== 2)
+    fail("Expected js and js_reset descriptors");
+  const names = /* @__PURE__ */ new Set();
+  for (const tool of value.tools) {
+    if (!record(tool) || !COMPUTER_USE_PUBLIC_TOOLS.includes(tool.name) || !record(tool.inputSchema))
+      fail("Invalid original tool descriptor");
+    if (tool.description !== void 0 && typeof tool.description !== "string")
+      fail("Invalid tool description");
+    if (names.has(tool.name))
+      fail("Duplicate public tool");
+    names.add(tool.name);
+    boundedJson(tool, COMPUTER_USE_LIMITS.maxSchemaBytes, "Tool descriptor");
+  }
+  boundedJson(value, COMPUTER_USE_LIMITS.maxEnvelopeBytes, "Surface");
+}
+function assertComputerUseMcpResult(value) {
+  if (!record(value) || !Array.isArray(value.content) || value.content.length > COMPUTER_USE_LIMITS.maxContentBlocks)
+    fail("Invalid MCP result content");
+  if (value.isError !== void 0 && typeof value.isError !== "boolean")
+    fail("Invalid MCP isError");
+  if (value.structuredContent !== void 0 && !record(value.structuredContent))
+    fail("Invalid MCP structuredContent");
+  for (const block of value.content) {
+    if (!record(block) || typeof block.type !== "string" || !block.type)
+      fail("Invalid MCP content block");
+    if (block.type === "text" && typeof block.text !== "string")
+      fail("Invalid MCP text block");
+    if (block.type === "image" && (typeof block.data !== "string" || typeof block.mimeType !== "string"))
+      fail("Invalid MCP image block");
+  }
+  boundedJson(value, COMPUTER_USE_LIMITS.maxEnvelopeBytes, "MCP result");
+}
+function sameComputerUseContext(left, right) {
+  return ["principalId", "machineId", "sessionId", "turnId", "generation", "agentId", "engine", "conversationId", "contextKey"].every((key) => left[key] === right[key]);
+}
+function assertComputerUseElicitationRequest(value) {
+  if (!record(value) || value.kind !== "computer_use_runtime")
+    fail("Expected runtime elicitation");
+  exactKeys(value, ["kind", "requestId", "context", "message", "resource", "options", "expiresAt"], "elicitation request");
+  identifier(value.requestId, "requestId");
+  assertComputerUseHostContext(value.context);
+  identifier(value.context.toolCallId, "toolCallId");
+  if (typeof value.message !== "string" || !value.message)
+    fail("Missing runtime elicitation message");
+  if (value.resource !== void 0 && !record(value.resource))
+    fail("Invalid runtime resource");
+  if (!Number.isSafeInteger(value.expiresAt) || value.expiresAt <= 0)
+    fail("Invalid runtime elicitation expiry");
+  if (!Array.isArray(value.options) || value.options.length === 0 || value.options.length > COMPUTER_USE_ELICITATION_CHOICES.length)
+    fail("Invalid runtime choices");
+  const choices = /* @__PURE__ */ new Set();
+  for (const option of value.options) {
+    if (!record(option))
+      fail("Invalid runtime option");
+    exactKeys(option, ["value", "label", "description"], "elicitation option");
+    if (!COMPUTER_USE_ELICITATION_CHOICES.includes(option.value) || choices.has(option.value))
+      fail("Unsupported or duplicate runtime choice");
+    if (typeof option.label !== "string" || !option.label || option.description !== void 0 && typeof option.description !== "string")
+      fail("Invalid runtime choice label");
+    choices.add(option.value);
+  }
+  boundedJson(value, COMPUTER_USE_LIMITS.maxEnvelopeBytes, "Runtime elicitation");
+}
+function assertComputerUseElicitationResponse(value) {
+  if (!record(value))
+    fail("Expected runtime elicitation response");
+  exactKeys(value, ["requestId", "context", "choice"], "elicitation response");
+  identifier(value.requestId, "requestId");
+  assertComputerUseHostContext(value.context);
+  identifier(value.context.toolCallId, "toolCallId");
+  if (!COMPUTER_USE_ELICITATION_CHOICES.includes(value.choice))
+    fail("Unsupported runtime choice");
+  boundedJson(value, COMPUTER_USE_LIMITS.maxEnvelopeBytes, "Runtime elicitation response");
+}
+function acceptsComputerUseElicitationResponse(request, response, now = Date.now()) {
+  try {
+    assertComputerUseElicitationRequest(request);
+    assertComputerUseElicitationResponse(response);
+  } catch {
+    return false;
+  }
+  return request.kind === "computer_use_runtime" && request.requestId === response.requestId && Number.isFinite(request.expiresAt) && now < request.expiresAt && sameComputerUseContext(request.context, response.context) && typeof request.context.toolCallId === "string" && request.context.toolCallId === response.context.toolCallId && COMPUTER_USE_ELICITATION_CHOICES.includes(response.choice) && request.options.some((option) => option.value === response.choice);
+}
+function projectComputerUseResultForModel(result, options) {
+  assertComputerUseMcpResult(result);
+  if (!options || !["inline", "artifact-reference"].includes(options.audio))
+    fail("Unsupported Computer Use model audio capability");
+  const audioCount = result.content.filter((block) => block.type === "audio").length;
+  if (options.audio === "inline" || audioCount === 0)
+    return result;
+  identifier(options.principalId, "audio artifact owner");
+  identifier(options.sessionId, "audio artifact session");
+  if (options.consumer !== void 0)
+    identifier(options.consumer, "audio consumer");
+  const metadata = record(result._meta) ? result._meta : {};
+  const candidates = metadata["skrr.ai/computer-use-artifacts"];
+  const references = Array.isArray(candidates) ? candidates.filter((item) => record(item) && typeof item.mimeType === "string" && item.mimeType.startsWith("audio/")) : [];
+  if (references.length < audioCount || references.some((item) => !record(item) || typeof item.fileId !== "string" || !/^[A-Za-z0-9_-]{1,512}$/.test(item.fileId) || item.reference !== `file:${item.fileId}` || item.ownerUserId !== options.principalId || item.sessionId !== options.sessionId || !Number.isSafeInteger(item.bytes) || item.bytes <= 0 || typeof item.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(item.sha256) || typeof item.mimeType !== "string" || item.mimeType.length > 256 || !/^audio\/[A-Za-z0-9.+-]+(?:;[ -~]*)?$/.test(item.mimeType))) {
+    throw new ComputerUseContractError("computer_use_audio_artifact_required", "This model cannot receive inline audio. Every audio block requires an existing owned file artifact for this exact session.");
+  }
+  const notice = [
+    "Audio is available as owned file artifacts. This model receives references instead of inline audio and has not listened to the recording.",
+    ...references.map((item) => `${item.reference} (${item.mimeType}; ${item.bytes} bytes; sha256 ${item.sha256})`)
+  ].join("\n");
+  let inserted = false;
+  const content = result.content.flatMap((block) => {
+    if (block.type !== "audio")
+      return [block];
+    if (inserted)
+      return [];
+    inserted = true;
+    return [{ type: "text", text: notice }];
+  });
+  const projected = { ...result, content, _meta: {
+    ...metadata,
+    "skrr.ai/computer-use-model-projection": {
+      audio: "artifact-reference",
+      audioBlocks: audioCount,
+      ...options.consumer ? { consumer: options.consumer } : {}
+    }
+  } };
+  assertComputerUseMcpResult(projected);
+  return projected;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  COMPUTER_USE_CLOUD_CONSENT,
+  COMPUTER_USE_DEFAULT_BUDGETS,
+  COMPUTER_USE_ELICITATION_CHOICES,
+  COMPUTER_USE_EXECUTION_CAPABILITY,
+  COMPUTER_USE_LIMITS,
+  COMPUTER_USE_OPERATIONS,
+  COMPUTER_USE_PROTOCOL,
+  COMPUTER_USE_PROVIDER,
+  COMPUTER_USE_PUBLIC_TOOLS,
+  COMPUTER_USE_ROTATE_CREDENTIAL_EVENT,
+  COMPUTER_USE_RUNTIME_STATES,
+  COMPUTER_USE_TOOL,
+  ComputerUseContractError,
+  acceptsComputerUseElicitationResponse,
+  assertComputerUseElicitationRequest,
+  assertComputerUseElicitationResponse,
+  assertComputerUseHostContext,
+  assertComputerUseInput,
+  assertComputerUseMcpResult,
+  assertComputerUseRequest,
+  assertComputerUseRotateCredentialRequest,
+  assertComputerUseSurface,
+  computerUseBudgets,
+  computerUseModelInstructions,
+  projectComputerUseResultForModel,
+  sameComputerUseContext
+});