@miosa/sdk 3.5.0 → 3.7.0

package/README.md

@@ -53,6 +53,7 @@ await sbx.pause();
 | Resource | Description |
 |---|---|
 | `miosa.sandboxes` | Lightweight code-execution VMs — exec, files, snapshots, previews |
+| `miosa.runtimes` | Selectable sandbox runtimes (firecracker / soma / auto) with gate state |
 | `miosa.computers` | Full Linux desktop VMs with desktop control for agents |
 | `miosa.deployments` | Versioned production releases with rollback |
 | `miosa.appDocuments` | Durable generated apps with exact-version review approvals and immutable publication bindings |
@@ -276,6 +277,37 @@ await sbx.pause();
 await sbx.resume();
 ```
 
+### Selecting a runtime
+
+A runtime is the microVM engine behind a sandbox. Pass `runtime` on create to
+choose one; the SDK sends it as the wire field `runtime_profile`:
+
+```ts
+// Full microVM (the default). Sent on the wire as "standard".
+const fx = await miosa.sandboxes.create({ runtime: "firecracker" });
+
+// Fastest start for supported Linux images.
+const soma = await miosa.sandboxes.create({ runtime: "soma" });
+
+// Let the platform pick.
+const auto = await miosa.sandboxes.create({ runtime: "auto" });
+```
+
+Omitting `runtime` leaves `runtime_profile` off the request, so the server
+applies its own default (Firecracker). List what your org can use and each
+runtime's capabilities:
+
+```ts
+const runtimes = await miosa.runtimes.list();
+for (const rt of runtimes) {
+  console.log(rt.id, rt.label, rt.available ? "available" : rt.unavailable_reason);
+}
+```
+
+`available` is the live gate for your org; when it is false,
+`unavailable_reason` carries a machine code (`GLOBAL_GATE_CLOSED` or
+`ORG_RESTRICTED`).
+
 ### Cancelling sandbox commands
 
 Pass an `AbortSignal` to `sandbox.exec.run(command, { signal, timeoutSec })` or `sandbox.exec.stream(command, { signal, timeoutSec })`.
@@ -293,6 +325,61 @@ Cancellation requires the server's request-owned streaming implementation and th
 If deletion is still in progress, the handle reports `destroying` and exposes `sandbox.data.operation_id` when supplied by the server.
 Use `sandbox.refresh()` to verify completion; an acknowledgement alone does not prove resource cleanup.
 
+## Browser automation with CDP
+
+A sandbox browser speaks the Chrome DevTools Protocol. Mint a scoped, expiring,
+revocable grant with `miosa.sandboxes.browserCdpUrl(id)`. Pass
+`{ ttlSeconds }` (60-604800) to request a lifetime:
+
+```ts
+const grant = await miosa.sandboxes.browserCdpUrl(sbx.id, { ttlSeconds: 3600 });
+console.log(grant.cdp_host_http_url); // https://cdp-<id8>-<token>.sandbox.miosa.ai
+```
+
+The grant returns every endpoint a CDP client needs:
+
+| Field | What it is |
+|---|---|
+| `cdp_url` | `wss://` CDP endpoint for header/session auth |
+| `cdp_ws_url` | `wss://` CDP endpoint carrying the grant token in the path |
+| `cdp_http_url` | `https://` CDP endpoint carrying the grant token in the path |
+| `cdp_host` | Header-auth CDP host (`cdp-<id8>-<token>.sandbox.miosa.ai`) |
+| `cdp_host_http_url` | `https://` host form; answers `/json`, `/json/version`, `/json/list`, `/json/new` with `webSocketDebuggerUrl` rewritten to the same host's `/devtools/*` sockets |
+| `cdp_host_ws_url` | `wss://` host form; serves the `/devtools/<browser\|page>/<id>` sockets |
+| `cdp_token_id` / `cdp_expires_at` / `epoch` | Grant id, ISO-8601 expiry and generation |
+| `cdp_debugger_address` | Optional `host:port` for Selenium's `debuggerAddress`. This endpoint does not return it - it appears on the browser-start payload - so it may be absent |
+
+The SDK only mints the grant - it never starts or proxies a browser. Run a
+CDP-speaking browser inside the sandbox, then choose whichever endpoint your
+client understands. The path-token URLs (`cdp_ws_url`, `cdp_http_url`) are for
+clients that cannot set headers; `cdp_url` is the header-auth `wss://` form.
+
+Point Selenium at the debugger address. Use the `cdp_debugger_address` from the
+browser-start payload when present, or `127.0.0.1:9222` when you forward the
+port with the MIOSA CLI:
+
+```py
+# Selenium - 127.0.0.1:9222 after `miosa sandboxes forward <id> 9222`, or the
+# cdp_debugger_address supplied by the browser-start payload.
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+
+options = Options()
+options.add_experimental_option("debuggerAddress", "127.0.0.1:9222")
+driver = webdriver.Chrome(options=options)
+driver.get("https://example.com")
+```
+
+Point chromedp (Go) at the header-auth host as its base URL:
+
+```go
+// chromedp
+allocCtx, cancel := chromedp.NewRemoteAllocator(ctx, grant.cdp_host_http_url)
+defer cancel()
+browserCtx, cancel := chromedp.NewContext(allocCtx)
+defer cancel()
+```
+
 ## Publish from sandbox
 
 Preview is mutable; publish creates a durable deployment version. Static output
@@ -398,6 +485,99 @@ console.log(rotated.viewer_password);
 await computer.destroy();
 ```
 
+## Computer use
+
+Drive a computer by action name. The names are the members of Anthropic's `computer_toolset_20260801`, and every result is typed.
+
+```ts
+const shot = await computer.act("screenshot");              // imageBase64, width, height
+const at = await computer.act("cursor_position");           // x, y
+await computer.act("left_click", { coordinate: [512, 384] });
+await computer.act("key", { text: "ctrl+s" });
+
+const view = await computer.look();                          // screenshot and accessibility tree in one call
+await computer.waitForDesktop();                             // ready and answering
+await computer.waitUntilIdle();                              // screen stopped changing
+const viewer = await computer.viewerUrl({ ttlSeconds: 3600 }); // { url, expiresAt, ... }
+```
+
+The rest of the desktop is on `computer.desktop`: `hotkey`, `keyDown`, `keyUp`, `mouseDown`, `mouseUp`, `getClipboard`, `setClipboard`, `screenSize`, `accessibilityTree`, `environment`, `setWallpaper`, `screenshotRegion` and window calls (`windowSize`, `resizeWindow`, `moveWindow`, `maximizeWindow`, `minimizeWindow`, `closeWindow`).
+
+`computer` and `sandbox` implement `Symbol.asyncDispose`, so `await using computer = await miosa.computers.create(...)` destroys it when the scope ends (TypeScript 5.2 or newer; Node 18.18 or newer).
+
+### Let Claude drive it
+
+```ts
+import { miosaComputerToolset } from "@miosa/sdk/computer-use";
+
+const toolset = miosaComputerToolset(computer, {
+  confirm: async ({ member, input }) => member !== "type" || askHuman(input), // required
+});
+// tools: [toolset] in anthropic.beta.messages.toolRunner(...), or toolset.toJSON() and toolset.toolResult(block) in your own loop.
+```
+
+`@miosa/sdk/computer-use` subclasses Anthropic's `BetaAbstractComputerToolset20260801`, so the batch rules (stop at the first failure, `Not executed: an earlier computer action in this turn failed.` for the rest, `toolset_name` on every result) come from Anthropic's runner.
+It needs the optional peer `@anthropic-ai/sdk` 0.133 or newer.
+`confirm` is required because the toolset can type and press keys; the alternative is to switch `type`, `key` and `hold_key` off in `configs`.
+`zoom` is a region screenshot.
+`triple_click` is off by default because the desktop has no triple-click route; `emulateTripleClick: true` sends a click and then a double-click.
+Screens are sent at their native size, so pick a 1024x768 or 1280x720 computer.
+For older models use `miosaComputerToolLegacy(computer, { version, displayWidthPx, displayHeightPx, confirm })`.
+
+See `examples/computer-use-claude.ts`.
+
+## End-user tokens (platform builders)
+
+`miosa.tokens.createScoped()` is the path for a platform that serves many customers.
+Your server mints a short-lived token for one end user and one workspace, and the browser holds only that token.
+It carries the scopes you ask for and never more than the minting key holds.
+
+```ts
+const { token, expires_at } = await miosa.tokens.createScoped({
+  userId: "end-user-123",
+  workspaceId: "ws_abc",
+  scopes: ["sandboxes:create", "sandboxes:read"],
+  expiresInSeconds: 3600,
+});
+// give `token` to the browser: new Miosa({ apiKey: token })
+```
+
+See `sdks/docs/guides/build-a-multi-tenant-platform.md` for the whole flow.
+
+## Helpers
+
+`@miosa/sdk/helpers` puts the calls an agent loop reaches for in one import, keyed by computer id.
+
+| Helper | Does |
+|---|---|
+| `waitUntilReady(miosa, id)` | poll until the computer is `active` or `running` |
+| `waitForDesktop(miosa, id)` | ready, and the desktop answers |
+| `waitUntilIdle(miosa, id)` | the screen stopped changing |
+| `waitForPrompt(miosa, runId)` | wait for an agent run to finish |
+| `streamPrompt(miosa, runId)` | follow an agent run's activity |
+| `streamEvents(miosa, id, { subscribe })` | follow window, file, process, clipboard and idle events |
+| `streamCommand(miosa, id, command)` | run a command and follow its output |
+| `execCommand(miosa, id, command)` | run a command and get the result |
+| `readText` / `writeText` | UTF-8 files |
+| `stopAndRemove(miosa, id)` | stop, then destroy; safe to call twice |
+
+Timeouts raise a `MiosaError` with a stable code (`COMPUTER_READY_TIMEOUT`, `DESKTOP_READY_TIMEOUT`, `DESKTOP_IDLE_TIMEOUT`) and `retryable: true`.
+
+## Fail fast
+
+Pass `failFast: true` to `sandboxes.create`, `fork`, `resume`, `computers.create` or `computer.start` to shed load instead of waiting for capacity.
+When no ready machine is free the server answers `503 no_ready_machine` in about 1.5 seconds, and the SDK raises `NoReadyMachineError`.
+A fail-fast request is never retried by the client, because the refusal is the point.
+
+```ts
+try {
+  const sbx = await miosa.sandboxes.create({ failFast: true, size: "large" });
+} catch (error) {
+  if (error instanceof NoReadyMachineError) return fallback(); // retryAfterMs is the server's hint
+  throw error;
+}
+```
+
 ## White-label / multi-tenant
 
 ```ts

package/dist/chunk-BMWUKYWU.js

@@ -0,0 +1,463 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/errors.ts
+function defaultRetryable(status) {
+  return status === 408 || status === 429 || status >= 500;
+}
+var MiosaError = class _MiosaError extends Error {
+  status;
+  code;
+  details;
+  requestId;
+  retryable;
+  /**
+   * Server-supplied retry hint in milliseconds, taken from the canonical
+   * error shape's `retry_after_ms` (nested under `error` or top-level) or,
+   * failing that, the HTTP `Retry-After` header. `undefined` when the
+   * response carried neither, in which case a caller should fall back to
+   * its own backoff policy.
+   */
+  retryAfterMs;
+  constructor(message, status, code, details, requestId, retryable = defaultRetryable(status), retryAfterMs) {
+    super(message);
+    this.name = "MiosaError";
+    this.status = status;
+    this.code = code;
+    this.details = details;
+    this.requestId = requestId;
+    this.retryable = retryable;
+    this.retryAfterMs = retryAfterMs;
+  }
+  /**
+   * @param retryAfterHeaderMs The `Retry-After` header value, already
+   *   converted to milliseconds by the caller. Used only when the body does
+   *   not carry the more precise `retry_after_ms`.
+   */
+  static fromResponse(status, body, requestId, retryAfterHeaderMs) {
+    const nested = typeof body.error === "object" ? body.error : void 0;
+    const flatError = typeof body.error === "string" ? body.error : void 0;
+    const flatErrorIsCode = !!flatError && (/^[A-Z][A-Z0-9_]+$/.test(flatError) || /^[a-z][a-z0-9]*(_[a-z0-9]+)+$/.test(flatError));
+    const message = nested?.message ?? body.message ?? body.detail ?? body.reason ?? flatError ?? `HTTP ${status}`;
+    const code = nested?.code ?? body.code ?? (flatErrorIsCode ? flatError : "UNKNOWN_ERROR");
+    const details = nested?.details ?? body.details ?? (body.detail || body.reason ? { detail: body.detail, reason: body.reason } : void 0) ?? extraFields(body, nested);
+    requestId ??= nested?.request_id ?? body.request_id;
+    const retryable = nested?.retryable ?? body.retryable ?? RETRYABLE_BY_CODE[code] ?? defaultRetryable(status);
+    const retryAfterMs = nested?.retry_after_ms ?? body.retry_after_ms ?? retryAfterHeaderMs;
+    const connectError = connectErrorFromCode(code, message, status, details, requestId, retryable) ?? typedErrorFromCode(code, message, status, details, requestId, retryable, retryAfterMs);
+    const built = connectError ?? (status === 401 || status === 403 ? new AuthError(message, status, code, details, requestId, retryable) : status === 404 ? new NotFoundError(message, code, details, requestId, retryable) : status === 429 ? new RateLimitError(
+      message,
+      details,
+      requestId,
+      retryAfterMs === void 0 ? void 0 : retryAfterMs / 1e3,
+      retryable,
+      // Keep the server's own code (SERVICE_ACCOUNT_LIMIT, ...) when it sent one.
+      code === "UNKNOWN_ERROR" ? "RATE_LIMITED" : code
+    ) : status === 402 ? new InsufficientCreditsError(
+      message,
+      details,
+      requestId,
+      retryable,
+      code === "UNKNOWN_ERROR" ? "INSUFFICIENT_CREDITS" : code
+    ) : status >= 400 && status < 500 ? new ValidationError(message, status, code, details, requestId, retryable) : new _MiosaError(message, status, code, details, requestId, retryable));
+    built.retryAfterMs = retryAfterMs;
+    return built;
+  }
+};
+var ENVELOPE_KEYS = /* @__PURE__ */ new Set([
+  "error",
+  "message",
+  "code",
+  "detail",
+  "details",
+  "reason",
+  "request_id",
+  "retryable",
+  "retry_after_ms",
+  "ok",
+  "success",
+  "status"
+]);
+var NESTED_KEYS = /* @__PURE__ */ new Set(["code", "message", "details", "retryable", "request_id", "retry_after_ms"]);
+function extraFields(body, nested) {
+  const extras = {};
+  for (const [key, value] of Object.entries(body)) {
+    if (!ENVELOPE_KEYS.has(key)) extras[key] = value;
+  }
+  if (nested) {
+    for (const [key, value] of Object.entries(nested)) {
+      if (!NESTED_KEYS.has(key)) extras[key] = value;
+    }
+  }
+  return Object.keys(extras).length > 0 ? extras : void 0;
+}
+function connectErrorFromCode(code, message, status, details, requestId, retryable) {
+  switch (code) {
+    case "PROJECT_NOT_LINKED":
+      return new ProjectNotLinkedError(message, status, details, requestId, retryable);
+    case "SUBJECT_NOT_ALLOWED":
+      return new SubjectNotAllowedError(message, status, details, requestId, retryable);
+    case "SCOPE_NOT_ALLOWED":
+      return new ScopeNotAllowedError(message, status, details, requestId, retryable);
+    case "MANAGED_PROVIDER_BINDING_ONLY":
+      return new ManagedProviderBindingOnlyError(message, status, details, requestId, retryable);
+    case "INSTALLATION_REQUIRED":
+      return new InstallationRequiredError(message, status, details, requestId, retryable);
+    case "USER_AUTHORIZATION_REQUIRED":
+      return new UserAuthorizationRequiredError(message, status, details, requestId, retryable);
+    case "EGRESS_HOST_NOT_ALLOWED":
+      return new EgressHostNotAllowedError(message, status, details, requestId, retryable);
+    case "TOKEN_REFRESH_FAILED":
+      return new TokenRefreshFailedError(message, status, details, requestId, retryable);
+    default:
+      return void 0;
+  }
+}
+var AuthError = class extends MiosaError {
+  constructor(message, status = 401, code = "UNAUTHORIZED", details, requestId, retryable) {
+    super(message, status, code, details, requestId, retryable);
+    this.name = "AuthError";
+  }
+};
+var NotFoundError = class extends MiosaError {
+  constructor(message, code = "NOT_FOUND", details, requestId, retryable) {
+    super(message, 404, code, details, requestId, retryable);
+    this.name = "NotFoundError";
+  }
+};
+var RateLimitError = class extends MiosaError {
+  retryAfter;
+  constructor(message, details, requestId, retryAfter, retryable, code = "RATE_LIMITED") {
+    super(message, 429, code, details, requestId, retryable);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var InsufficientCreditsError = class extends MiosaError {
+  constructor(message, details, requestId, retryable, code = "INSUFFICIENT_CREDITS") {
+    super(message, 402, code, details, requestId, retryable);
+    this.name = "InsufficientCreditsError";
+  }
+};
+var ValidationError = class extends MiosaError {
+  constructor(message, status, code = "VALIDATION_ERROR", details, requestId, retryable) {
+    super(message, status, code, details, requestId, retryable);
+    this.name = "ValidationError";
+  }
+};
+var TimeoutError = class extends MiosaError {
+  constructor(message = "Request timed out") {
+    super(message, 408, "TIMEOUT", void 0, void 0, true);
+    this.name = "TimeoutError";
+  }
+};
+var NetworkError = class extends MiosaError {
+  cause;
+  constructor(message, cause) {
+    super(message, 0, "NETWORK_ERROR", void 0, void 0, true);
+    this.name = "NetworkError";
+    this.cause = cause;
+  }
+};
+var ProjectNotLinkedError = class extends MiosaError {
+  constructor(message, status = 403, details, requestId, retryable) {
+    super(message, status, "PROJECT_NOT_LINKED", details, requestId, retryable);
+    this.name = "ProjectNotLinkedError";
+  }
+};
+var SubjectNotAllowedError = class extends MiosaError {
+  constructor(message, status = 403, details, requestId, retryable) {
+    super(message, status, "SUBJECT_NOT_ALLOWED", details, requestId, retryable);
+    this.name = "SubjectNotAllowedError";
+  }
+};
+var ScopeNotAllowedError = class extends MiosaError {
+  constructor(message, status = 403, details, requestId, retryable) {
+    super(message, status, "SCOPE_NOT_ALLOWED", details, requestId, retryable);
+    this.name = "ScopeNotAllowedError";
+  }
+};
+var ManagedProviderBindingOnlyError = class extends MiosaError {
+  constructor(message, status = 403, details, requestId, retryable) {
+    super(message, status, "MANAGED_PROVIDER_BINDING_ONLY", details, requestId, retryable);
+    this.name = "ManagedProviderBindingOnlyError";
+  }
+};
+var InstallationRequiredError = class extends MiosaError {
+  constructor(message, status = 409, details, requestId, retryable) {
+    super(message, status, "INSTALLATION_REQUIRED", details, requestId, retryable);
+    this.name = "InstallationRequiredError";
+  }
+};
+var UserAuthorizationRequiredError = class extends MiosaError {
+  constructor(message, status = 403, details, requestId, retryable) {
+    super(message, status, "USER_AUTHORIZATION_REQUIRED", details, requestId, retryable);
+    this.name = "UserAuthorizationRequiredError";
+  }
+};
+var EgressHostNotAllowedError = class extends MiosaError {
+  constructor(message, status = 403, details, requestId, retryable) {
+    super(message, status, "EGRESS_HOST_NOT_ALLOWED", details, requestId, retryable);
+    this.name = "EgressHostNotAllowedError";
+  }
+};
+var TokenRefreshFailedError = class extends MiosaError {
+  constructor(message, status = 502, details, requestId, retryable) {
+    super(message, status, "TOKEN_REFRESH_FAILED", details, requestId, retryable);
+    this.name = "TokenRefreshFailedError";
+  }
+};
+var RETRYABLE_BY_CODE = {
+  SANDBOX_STARTING: true,
+  COMPUTER_STARTING: true,
+  ENVIRONMENT_SCRUB_FAILED: true,
+  CHAT_BUSY: true,
+  ENVIRONMENT_MEMORY_WITHHELD: false,
+  NO_AGENT_RUN: false,
+  MEMBER_LIMIT_REACHED: false,
+  NO_READY_MACHINE: true,
+  no_ready_machine: true
+};
+var NoReadyMachineError = class extends MiosaError {
+  constructor(message, status = 503, details, requestId, retryable = true, retryAfterMs) {
+    super(message, status, "no_ready_machine", details, requestId, retryable, retryAfterMs);
+    this.name = "NoReadyMachineError";
+  }
+};
+var InvalidIdError = class extends ValidationError {
+  constructor(message, status = 400, details, requestId, retryable) {
+    super(message, status, "INVALID_ID", details, requestId, retryable);
+    this.name = "InvalidIdError";
+  }
+};
+var OwnCredentialsRequiredError = class extends ValidationError {
+  constructor(message, status = 422, details, requestId, retryable) {
+    super(message, status, "OWN_CREDENTIALS_REQUIRED", details, requestId, retryable);
+    this.name = "OwnCredentialsRequiredError";
+  }
+};
+var EnvironmentNotFoundError = class extends NotFoundError {
+  constructor(message, details, requestId, retryable) {
+    super(message, "ENVIRONMENT_NOT_FOUND", details, requestId, retryable);
+    this.name = "EnvironmentNotFoundError";
+  }
+};
+var UnknownEnvironmentError = class extends ValidationError {
+  constructor(message, status = 422, details, requestId, retryable) {
+    super(message, status, "ENVIRONMENT_NOT_FOUND", details, requestId, retryable);
+    this.name = "UnknownEnvironmentError";
+  }
+};
+var EnvironmentNameTakenError = class extends ValidationError {
+  constructor(message, status = 409, details, requestId, retryable) {
+    super(message, status, "ENVIRONMENT_NAME_TAKEN", details, requestId, retryable);
+    this.name = "EnvironmentNameTakenError";
+  }
+};
+var EnvironmentIsDefaultError = class extends ValidationError {
+  constructor(message, status = 409, details, requestId, retryable) {
+    super(message, status, "ENVIRONMENT_IS_DEFAULT", details, requestId, retryable);
+    this.name = "EnvironmentIsDefaultError";
+  }
+};
+var EnvironmentScrubFailedError = class extends ValidationError {
+  constructor(message, status = 409, details, requestId, retryable = true) {
+    super(message, status, "ENVIRONMENT_SCRUB_FAILED", details, requestId, retryable);
+    this.name = "EnvironmentScrubFailedError";
+  }
+};
+var EnvironmentMemoryWithheldError = class extends ValidationError {
+  constructor(message, status = 409, details, requestId, retryable = false) {
+    super(message, status, "ENVIRONMENT_MEMORY_WITHHELD", details, requestId, retryable);
+    this.name = "EnvironmentMemoryWithheldError";
+  }
+  /** `details.reasons`: why the memory was withheld. Empty when absent. */
+  get reasons() {
+    const reasons = this.details?.reasons;
+    return Array.isArray(reasons) ? reasons.filter((r) => typeof r === "string") : [];
+  }
+};
+var MachineKeyScopeError = class extends AuthError {
+  constructor(message, status = 403, details, requestId, retryable) {
+    super(message, status, "MACHINE_KEY_SCOPE", details, requestId, retryable);
+    this.name = "MachineKeyScopeError";
+  }
+};
+var MachineStartingError = class extends ValidationError {
+  constructor(message, status = 409, code = "SANDBOX_STARTING", details, requestId, retryable = true) {
+    super(message, status, code, details, requestId, retryable);
+    this.name = "MachineStartingError";
+  }
+};
+var SandboxStartingError = class extends MachineStartingError {
+  constructor(message, status = 409, details, requestId, retryable = true) {
+    super(message, status, "SANDBOX_STARTING", details, requestId, retryable);
+    this.name = "SandboxStartingError";
+  }
+};
+var ComputerStartingError = class extends MachineStartingError {
+  constructor(message, status = 409, details, requestId, retryable = true) {
+    super(message, status, "COMPUTER_STARTING", details, requestId, retryable);
+    this.name = "ComputerStartingError";
+  }
+};
+var CreditRequiredError = class extends InsufficientCreditsError {
+  constructor(message, details, requestId, retryable) {
+    super(message, details, requestId, retryable, "CREDIT_REQUIRED");
+    this.name = "CreditRequiredError";
+  }
+};
+var TeamMemberCapReachedError = class extends InsufficientCreditsError {
+  constructor(message, details, requestId, retryable) {
+    super(message, details, requestId, retryable, "TEAM_MEMBER_CAP_REACHED");
+    this.name = "TeamMemberCapReachedError";
+  }
+};
+var MemberLimitReachedError = class extends RateLimitError {
+  constructor(message, details, requestId, retryAfter, retryable = false) {
+    super(message, details, requestId, retryAfter, retryable, "MEMBER_LIMIT_REACHED");
+    this.name = "MemberLimitReachedError";
+  }
+};
+var BillToLockedError = class extends AuthError {
+  constructor(message, status = 403, details, requestId, retryable) {
+    super(message, status, "BILL_TO_LOCKED", details, requestId, retryable);
+    this.name = "BillToLockedError";
+  }
+};
+var BillToForbiddenError = class extends AuthError {
+  constructor(message, status = 403, details, requestId, retryable) {
+    super(message, status, "BILL_TO_FORBIDDEN", details, requestId, retryable);
+    this.name = "BillToForbiddenError";
+  }
+};
+var BillToSuspendedError = class extends AuthError {
+  constructor(message, status = 403, details, requestId, retryable) {
+    super(message, status, "BILL_TO_SUSPENDED", details, requestId, retryable);
+    this.name = "BillToSuspendedError";
+  }
+};
+var OrgNotFoundError = class extends NotFoundError {
+  constructor(message, details, requestId, retryable) {
+    super(message, "ORG_NOT_FOUND", details, requestId, retryable);
+    this.name = "OrgNotFoundError";
+  }
+};
+var AmbiguousOrgError = class extends ValidationError {
+  constructor(message, status = 409, details, requestId, retryable) {
+    super(message, status, "AMBIGUOUS_ORG", details, requestId, retryable);
+    this.name = "AmbiguousOrgError";
+  }
+};
+var SnapshotInUseError = class extends ValidationError {
+  constructor(message, status = 409, details, requestId, retryable) {
+    super(message, status, "SNAPSHOT_IN_USE", details, requestId, retryable);
+    this.name = "SnapshotInUseError";
+  }
+  /** `details.dependents`: every thing that still needs the snapshot's bytes. */
+  get dependents() {
+    const dependents = this.details?.dependents;
+    return Array.isArray(dependents) ? dependents : [];
+  }
+};
+var RunSessionNotResumableError = class extends ValidationError {
+  constructor(message, status = 409, details, requestId, retryable) {
+    super(message, status, "RUN_SESSION_NOT_RESUMABLE", details, requestId, retryable);
+    this.name = "RunSessionNotResumableError";
+  }
+  get reason() {
+    const reason = this.details?.reason;
+    return typeof reason === "string" ? reason : void 0;
+  }
+};
+var ChatBusyError = class extends ValidationError {
+  constructor(message, status = 409, details, requestId, retryable = true) {
+    super(message, status, "CHAT_BUSY", details, requestId, retryable);
+    this.name = "ChatBusyError";
+  }
+};
+var NoAgentRunError = class extends ValidationError {
+  constructor(message, status = 409, details, requestId, retryable = false) {
+    super(message, status, "NO_AGENT_RUN", details, requestId, retryable);
+    this.name = "NoAgentRunError";
+  }
+};
+var InvalidSetupFileError = class extends ValidationError {
+  constructor(message, status = 422, details, requestId, retryable) {
+    super(message, status, "INVALID_SETUP_FILE", details, requestId, retryable);
+    this.name = "InvalidSetupFileError";
+  }
+  get reason() {
+    const reason = this.details?.reason;
+    return typeof reason === "string" ? reason : void 0;
+  }
+};
+function typedErrorFromCode(code, message, status, details, requestId, retryable, retryAfterMs) {
+  switch (code) {
+    case "no_ready_machine":
+    case "NO_READY_MACHINE":
+      return new NoReadyMachineError(message, status, details, requestId, retryable, retryAfterMs);
+    case "INVALID_ID":
+      return new InvalidIdError(message, status, details, requestId, retryable);
+    case "OWN_CREDENTIALS_REQUIRED":
+      return new OwnCredentialsRequiredError(message, status, details, requestId, retryable);
+    case "ENVIRONMENT_NOT_FOUND":
+      return status === 404 ? new EnvironmentNotFoundError(message, details, requestId, retryable) : new UnknownEnvironmentError(message, status, details, requestId, retryable);
+    case "ENVIRONMENT_NAME_TAKEN":
+      return new EnvironmentNameTakenError(message, status, details, requestId, retryable);
+    case "ENVIRONMENT_IS_DEFAULT":
+      return new EnvironmentIsDefaultError(message, status, details, requestId, retryable);
+    case "ENVIRONMENT_SCRUB_FAILED":
+      return new EnvironmentScrubFailedError(message, status, details, requestId, retryable);
+    case "ENVIRONMENT_MEMORY_WITHHELD":
+      return new EnvironmentMemoryWithheldError(message, status, details, requestId, retryable);
+    case "MACHINE_KEY_SCOPE":
+      return new MachineKeyScopeError(message, status, details, requestId, retryable);
+    case "SANDBOX_STARTING":
+      return new SandboxStartingError(message, status, details, requestId, retryable);
+    case "COMPUTER_STARTING":
+      return new ComputerStartingError(message, status, details, requestId, retryable);
+    case "CREDIT_REQUIRED":
+      return new CreditRequiredError(message, details, requestId, retryable);
+    case "TEAM_MEMBER_CAP_REACHED":
+      return new TeamMemberCapReachedError(message, details, requestId, retryable);
+    case "MEMBER_LIMIT_REACHED":
+      return new MemberLimitReachedError(
+        message,
+        details,
+        requestId,
+        retryAfterMs === void 0 ? void 0 : retryAfterMs / 1e3,
+        retryable
+      );
+    case "BILL_TO_LOCKED":
+      return new BillToLockedError(message, status, details, requestId, retryable);
+    case "BILL_TO_FORBIDDEN":
+      return new BillToForbiddenError(message, status, details, requestId, retryable);
+    case "BILL_TO_SUSPENDED":
+      return new BillToSuspendedError(message, status, details, requestId, retryable);
+    case "ORG_NOT_FOUND":
+      return new OrgNotFoundError(message, details, requestId, retryable);
+    case "AMBIGUOUS_ORG":
+      return new AmbiguousOrgError(message, status, details, requestId, retryable);
+    case "SNAPSHOT_IN_USE":
+      return new SnapshotInUseError(message, status, details, requestId, retryable);
+    case "RUN_SESSION_NOT_RESUMABLE":
+      return new RunSessionNotResumableError(message, status, details, requestId, retryable);
+    case "CHAT_BUSY":
+      return new ChatBusyError(message, status, details, requestId, retryable);
+    case "NO_AGENT_RUN":
+      return new NoAgentRunError(message, status, details, requestId, retryable);
+    case "INVALID_SETUP_FILE":
+      return new InvalidSetupFileError(message, status, details, requestId, retryable);
+    default:
+      return void 0;
+  }
+}
+
+export { AmbiguousOrgError, AuthError, BillToForbiddenError, BillToLockedError, BillToSuspendedError, ChatBusyError, ComputerStartingError, CreditRequiredError, EgressHostNotAllowedError, EnvironmentIsDefaultError, EnvironmentMemoryWithheldError, EnvironmentNameTakenError, EnvironmentNotFoundError, EnvironmentScrubFailedError, InstallationRequiredError, InsufficientCreditsError, InvalidIdError, InvalidSetupFileError, MachineKeyScopeError, MachineStartingError, ManagedProviderBindingOnlyError, MemberLimitReachedError, MiosaError, NetworkError, NoAgentRunError, NoReadyMachineError, NotFoundError, OrgNotFoundError, OwnCredentialsRequiredError, ProjectNotLinkedError, RateLimitError, RunSessionNotResumableError, SandboxStartingError, ScopeNotAllowedError, SnapshotInUseError, SubjectNotAllowedError, TeamMemberCapReachedError, TimeoutError, TokenRefreshFailedError, UnknownEnvironmentError, UserAuthorizationRequiredError, ValidationError, __require };
+//# sourceMappingURL=chunk-BMWUKYWU.js.map
+//# sourceMappingURL=chunk-BMWUKYWU.js.map