@skrr-ai/cli 0.1.114 → 0.1.116

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

@@ -0,0 +1,75 @@
+"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 toolOperationOutcome_exports = {};
+__export(toolOperationOutcome_exports, {
+  mergeToolOperationOutcome: () => mergeToolOperationOutcome,
+  readToolOperationOutcome: () => readToolOperationOutcome,
+  toolOperationState: () => toolOperationState,
+  unknownToolOperationOutcome: () => unknownToolOperationOutcome
+});
+module.exports = __toCommonJS(toolOperationOutcome_exports);
+const statuses = /* @__PURE__ */ new Set(["succeeded", "failed", "not_run", "unknown"]);
+const sources = /* @__PURE__ */ new Set(["executor", "permission_resolver", "runtime_observer"]);
+const reasons = /* @__PURE__ */ new Set([
+  "command_failed",
+  "permission_denied",
+  "unavailable_before_dispatch",
+  "transport_unconfirmed",
+  "background_pending",
+  "unobserved",
+  "conflicting_receipts"
+]);
+function readToolOperationOutcome(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return void 0;
+  const v = value;
+  if (v.version !== 1 || typeof v.status !== "string" || typeof v.source !== "string" || !statuses.has(v.status) || !sources.has(v.source) || v.reason !== void 0 && (typeof v.reason !== "string" || !reasons.has(v.reason)) || v.source === "runtime_observer" && v.status !== "unknown" || v.source === "permission_resolver" && v.status !== "not_run")
+    return void 0;
+  return {
+    version: 1,
+    status: v.status,
+    source: v.source,
+    ...v.reason === void 0 ? {} : { reason: v.reason }
+  };
+}
+function unknownToolOperationOutcome(reason = "unobserved") {
+  return { version: 1, status: "unknown", source: "runtime_observer", reason };
+}
+function mergeToolOperationOutcome(previous, next) {
+  const before = readToolOperationOutcome(previous);
+  const after = readToolOperationOutcome(next);
+  if (!after)
+    return before;
+  if (!before || before.source === "runtime_observer" && before.reason === "unobserved")
+    return after;
+  if (after.source === "runtime_observer" && after.reason === "unobserved")
+    return before;
+  return JSON.stringify(before) === JSON.stringify(after) ? before : unknownToolOperationOutcome("conflicting_receipts");
+}
+function toolOperationState(value) {
+  const outcome = readToolOperationOutcome(value);
+  return !outcome ? void 0 : outcome.status === "succeeded" ? "completed" : outcome.status === "unknown" ? "unreported" : "error";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mergeToolOperationOutcome,
+  readToolOperationOutcome,
+  toolOperationState,
+  unknownToolOperationOutcome
+});

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

@@ -1,87 +1,75 @@
 "use strict";
-/**
- * ttlParser.ts — shared TTL-duration grammar for CI-token lifetimes.
- *
- * Single source of truth for the `--ttl` flag accepted by both
- * `oversky create-token` (daemon CLI) and `sky create-token` (CLI).
- * Before this module the CLI accepted bare integers only while the
- * daemon accepted `30d`/`1y`/`1w` — users would learn the daemon
- * grammar, hit a cryptic oclif integer-parser error when they tried
- * the same string on `sky`, and file a confused bug (ADD-CLI1).
- *
- * Grammar:
- *   <number><unit?>
- *     unit := 'd' | 'w' | 'y'    (default 'd' if absent)
- *
- * Constraints:
- *   days ∈ [MIN_TTL_DAYS, MAX_TTL_DAYS]  (1 .. 365)
- *
- * Errors are returned as a discriminated-union value rather than
- * thrown, so each CLI can surface them with its own idioms
- * (`this.error(...)` on oclif vs `showError(); process.exit(2)` on
- * the daemon) without the parser owning process-exit semantics.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_TTL_DAYS = exports.MIN_TTL_DAYS = void 0;
-exports.parseTtlDays = parseTtlDays;
-exports.MIN_TTL_DAYS = 1;
-exports.MAX_TTL_DAYS = 365;
+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 ttlParser_exports = {};
+__export(ttlParser_exports, {
+  MAX_TTL_DAYS: () => MAX_TTL_DAYS,
+  MIN_TTL_DAYS: () => MIN_TTL_DAYS,
+  parseTtlDays: () => parseTtlDays
+});
+module.exports = __toCommonJS(ttlParser_exports);
+const MIN_TTL_DAYS = 1;
+const MAX_TTL_DAYS = 365;
 const TTL_RE = /^(\d+)\s*([dwy]?)$/i;
-/**
- * Parse a `--ttl` string into a concrete day count. Pure; never
- * throws. Accepts `undefined`/empty as "use default."
- *
- * Examples:
- *   parseTtlDays('30d')      → { ok: true, days: 30 }
- *   parseTtlDays('1y')       → { ok: true, days: 365 }
- *   parseTtlDays('2w')       → { ok: true, days: 14 }
- *   parseTtlDays('90')       → { ok: true, days: 90 }
- *   parseTtlDays('0')        → { ok: false, code: 'OUT_OF_RANGE' }
- *   parseTtlDays('abc')      → { ok: false, code: 'INVALID_FORMAT' }
- *   parseTtlDays('2y')       → { ok: false, code: 'OUT_OF_RANGE' } // 730d > 365
- *
- * The default-days argument is a day count, not a string, because the
- * caller already knows it's in range — no need to re-parse.
- */
 function parseTtlDays(input, defaultDays) {
-    if (input == null || input === '') {
-        return { ok: true, days: defaultDays, input: '' };
-    }
-    const trimmed = String(input).trim();
-    const m = trimmed.match(TTL_RE);
-    if (!m) {
-        return {
-            ok: false,
-            code: 'INVALID_FORMAT',
-            input: trimmed,
-            message: `Invalid --ttl value "${trimmed}". ` +
-                `Examples: 30d (30 days), 2w (14 days), 1y (365 days), 90 (treated as days).`,
-        };
-    }
-    const n = parseInt(m[1], 10);
-    const unit = (m[2] || 'd').toLowerCase();
-    let days;
-    switch (unit) {
-        case 'd':
-            days = n;
-            break;
-        case 'w':
-            days = n * 7;
-            break;
-        case 'y':
-            days = n * 365;
-            break;
-        default:
-            days = n;
-            break;
-    }
-    if (!Number.isFinite(days) || days < exports.MIN_TTL_DAYS || days > exports.MAX_TTL_DAYS) {
-        return {
-            ok: false,
-            code: 'OUT_OF_RANGE',
-            input: trimmed,
-            message: `--ttl must be ${exports.MIN_TTL_DAYS}–${exports.MAX_TTL_DAYS} days (got ${days} days from "${trimmed}").`,
-        };
-    }
-    return { ok: true, days, input: trimmed };
+  if (input == null || input === "") {
+    return { ok: true, days: defaultDays, input: "" };
+  }
+  const trimmed = String(input).trim();
+  const m = trimmed.match(TTL_RE);
+  if (!m) {
+    return {
+      ok: false,
+      code: "INVALID_FORMAT",
+      input: trimmed,
+      message: `Invalid --ttl value "${trimmed}". Examples: 30d (30 days), 2w (14 days), 1y (365 days), 90 (treated as days).`
+    };
+  }
+  const n = parseInt(m[1], 10);
+  const unit = (m[2] || "d").toLowerCase();
+  let days;
+  switch (unit) {
+    case "d":
+      days = n;
+      break;
+    case "w":
+      days = n * 7;
+      break;
+    case "y":
+      days = n * 365;
+      break;
+    default:
+      days = n;
+      break;
+  }
+  if (!Number.isFinite(days) || days < MIN_TTL_DAYS || days > MAX_TTL_DAYS) {
+    return {
+      ok: false,
+      code: "OUT_OF_RANGE",
+      input: trimmed,
+      message: `--ttl must be ${MIN_TTL_DAYS}\u2013${MAX_TTL_DAYS} days (got ${days} days from "${trimmed}").`
+    };
+  }
+  return { ok: true, days, input: trimmed };
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_TTL_DAYS,
+  MIN_TTL_DAYS,
+  parseTtlDays
+});

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

@@ -1,37 +1,56 @@
 "use strict";
-/**
- * Shared types & error classes used across refresh, refreshScheduler, and
- * fdToken modules. Lives in its own file so consumers can `import type` from
- * the package without dragging in side-effecting modules.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransientAuthFailure = exports.PermanentAuthFailure = void 0;
+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 types_exports = {};
+__export(types_exports, {
+  PermanentAuthFailure: () => PermanentAuthFailure,
+  TransientAuthFailure: () => TransientAuthFailure
+});
+module.exports = __toCommonJS(types_exports);
 class PermanentAuthFailure extends Error {
-    code;
-    /**
-     * OSK-16941 — for `SESSION_REVOKED`, the server's `reason` (a
-     * `SESSION_REVOCATION_REASONS` value, `./sessionRevocation.ts`) exactly as
-     * received, or undefined when the server sent none. Deliberately not
-     * normalized here: a surface rendering it with `describeSessionRevocation`
-     * turns a missing or unknown value into the "we could not tell why" copy,
-     * and keeps an unrecognised code visible rather than losing it.
-     */
-    revocationReason;
-    constructor(code, message, revocationReason) {
-        super(message);
-        this.name = 'PermanentAuthFailure';
-        this.code = code;
-        if (revocationReason !== undefined)
-            this.revocationReason = revocationReason;
-    }
+  code;
+  /**
+   * OSK-16941 — for `SESSION_REVOKED`, the server's `reason` (a
+   * `SESSION_REVOCATION_REASONS` value, `./sessionRevocation.ts`) exactly as
+   * received, or undefined when the server sent none. Deliberately not
+   * normalized here: a surface rendering it with `describeSessionRevocation`
+   * turns a missing or unknown value into the "we could not tell why" copy,
+   * and keeps an unrecognised code visible rather than losing it.
+   */
+  revocationReason;
+  constructor(code, message, revocationReason) {
+    super(message);
+    this.name = "PermanentAuthFailure";
+    this.code = code;
+    if (revocationReason !== void 0)
+      this.revocationReason = revocationReason;
+  }
 }
-exports.PermanentAuthFailure = PermanentAuthFailure;
 class TransientAuthFailure extends Error {
-    cause;
-    constructor(message, cause) {
-        super(message);
-        this.name = 'TransientAuthFailure';
-        this.cause = cause;
-    }
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "TransientAuthFailure";
+    this.cause = cause;
+  }
 }
-exports.TransientAuthFailure = TransientAuthFailure;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PermanentAuthFailure,
+  TransientAuthFailure
+});

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

@@ -1,50 +1,50 @@
 "use strict";
-/**
- * The workspace-isolation probe wire contract (OSK-15099).
- *
- * A Commitment Run is always isolated: the daemon cuts it a private git
- * worktree from the directory the Run is rooted in, and refuses the Run with
- * `EXECUTION_ISOLATION_UNAVAILABLE` before any tool when it cannot. Preflight
- * had no way to read that machine's filesystem, so it reported `ready`,
- * activation succeeded, and the first Run failed. The daemon now answers the
- * same question BEFORE a Run, through the same predicate its executor refuses
- * on, and this module is the one place both ends spell it.
- *
- * - The daemon announces {@link WORKSPACE_ISOLATION_PROBE_CAPABILITY}. A daemon
- *   that does not is never asked, and the server reports the prerequisite as
- *   UNVERIFIED — never as satisfied (unknown is never ok).
- * - The server sends {@link WORKSPACE_ISOLATION_PROBE_METHOD} as a control RPC
- *   with `{ workingDirectory? }`: exactly the directory it would put on the
- *   Run's request (`agent.workingDirectory || daemon cwd`).
- * - The daemon answers {@link WorkspaceIsolationProbeAnswer}.
- *
- * Pure: no I/O, safe for the browser, the CLI and the API.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.REFUSING_WORKTREE_BASE_VERDICTS = exports.WORKTREE_BASE_VERDICTS = exports.WORKSPACE_ISOLATION_PROBE_METHOD = exports.WORKSPACE_ISOLATION_PROBE_CAPABILITY = void 0;
-exports.isWorktreeBaseVerdict = isWorktreeBaseVerdict;
-exports.WORKSPACE_ISOLATION_PROBE_CAPABILITY = 'workspace_isolation_probe_v1';
-exports.WORKSPACE_ISOLATION_PROBE_METHOD = 'daemon:workspace:isolation-probe';
-/**
- * What an explicit isolation request can be given from a base directory.
- *
- *   - `worktree`          — a git repository with a commit: a worktree is cut;
- *   - `sandbox`           — the daemon's own bare scratch workspace: an empty
- *                           private sandbox is used instead;
- *   - `not_a_repository`  — refused: not inside a git repository;
- *   - `no_initial_commit` — refused: a repository with an unborn HEAD.
- */
-exports.WORKTREE_BASE_VERDICTS = Object.freeze([
-    'worktree',
-    'sandbox',
-    'not_a_repository',
-    'no_initial_commit',
+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 workspaceIsolationProbeWire_exports = {};
+__export(workspaceIsolationProbeWire_exports, {
+  REFUSING_WORKTREE_BASE_VERDICTS: () => REFUSING_WORKTREE_BASE_VERDICTS,
+  WORKSPACE_ISOLATION_PROBE_CAPABILITY: () => WORKSPACE_ISOLATION_PROBE_CAPABILITY,
+  WORKSPACE_ISOLATION_PROBE_METHOD: () => WORKSPACE_ISOLATION_PROBE_METHOD,
+  WORKTREE_BASE_VERDICTS: () => WORKTREE_BASE_VERDICTS,
+  isWorktreeBaseVerdict: () => isWorktreeBaseVerdict
+});
+module.exports = __toCommonJS(workspaceIsolationProbeWire_exports);
+const WORKSPACE_ISOLATION_PROBE_CAPABILITY = "workspace_isolation_probe_v1";
+const WORKSPACE_ISOLATION_PROBE_METHOD = "daemon:workspace:isolation-probe";
+const WORKTREE_BASE_VERDICTS = Object.freeze([
+  "worktree",
+  "sandbox",
+  "not_a_repository",
+  "no_initial_commit"
 ]);
-/** The verdicts on which the daemon refuses an isolated Run before any tool. */
-exports.REFUSING_WORKTREE_BASE_VERDICTS = new Set([
-    'not_a_repository',
-    'no_initial_commit',
+const REFUSING_WORKTREE_BASE_VERDICTS = /* @__PURE__ */ new Set([
+  "not_a_repository",
+  "no_initial_commit"
 ]);
 function isWorktreeBaseVerdict(value) {
-    return typeof value === 'string' && exports.WORKTREE_BASE_VERDICTS.includes(value);
+  return typeof value === "string" && WORKTREE_BASE_VERDICTS.includes(value);
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  REFUSING_WORKTREE_BASE_VERDICTS,
+  WORKSPACE_ISOLATION_PROBE_CAPABILITY,
+  WORKSPACE_ISOLATION_PROBE_METHOD,
+  WORKTREE_BASE_VERDICTS,
+  isWorktreeBaseVerdict
+});

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/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;