withruntime 0.5.1 → 0.6.1

package/dist/products/desktop.d.ts

@@ -21,6 +21,27 @@ export type DesktopStart = {
     streamUrl: string;
     preview: Preview;
 };
+export type DesktopRecording = {
+    id: string;
+    state: "starting" | "installing" | "recording" | "finished" | "failed";
+    /** The MP4 file in the sandbox. */
+    path: string;
+    bytes: number;
+    seconds?: number;
+    /** Why it ended: stopped, max-seconds, max-bytes, disk-low, desktop-gone, error. */
+    reason: string | null;
+    startedAt?: number | null;
+};
+export type RecordOptions = {
+    /** Frames a second, 1 to 30. Default 10. */
+    fps?: number;
+    /** Stop after this much video, up to 7200. Default 1800. */
+    maxSeconds?: number;
+    /** The file never grows past this, 16 to 4096. Default 512. */
+    maxMiB?: number;
+    /** Quality, 18 (sharp, large) to 45 (small). Default 30. */
+    crf?: number;
+};
 /** `sbx.desktop`: a Linux desktop in the sandbox, driven like a person would.
  *
  *   const { streamUrl } = await sbx.desktop.start();
@@ -31,10 +52,12 @@ export type DesktopStart = {
  *
  * Coordinates are pixels from the top left of the screen. */
 export declare function sandboxDesktop(t: Transport, sandbox: Sandbox): {
-    start: (size?: {
+    /** Starts the desktop. The first start in a sandbox installs it, which
+     * takes a minute or two; this waits for that (up to 10 minutes). */
+    start(size?: {
         width?: number;
         height?: number;
-    }, options?: RequestOptions) => Promise<DesktopStart>;
+    }, options?: RequestOptions): Promise<DesktopStart>;
     stop: (options?: RequestOptions) => Promise<{
         ok: boolean;
     }>;
@@ -92,12 +115,26 @@ export declare function sandboxDesktop(t: Transport, sandbox: Sandbox): {
     focus: (windowId: string, options?: RequestOptions) => Promise<{
         ok: true;
     }>;
-    /** Opens `url` in Firefox on the desktop. */
-    open: (url: string, options?: RequestOptions) => Promise<{
+    /** Opens `url` in Firefox on the desktop. Right after a sandbox's first
+     * start, Firefox may still be installing; this waits for it. */
+    open(url: string, options?: RequestOptions): Promise<{
         ok: true;
     }>;
     /** Starts a program on the desktop, detached. */
     launch: (argv: string[], options?: RequestOptions) => Promise<{
         ok: true;
     }>;
+    /** Screen recordings to MP4: `const rec = await sbx.desktop.recordings.start();`
+     * ... `await sbx.desktop.recordings.stop(rec.id)`, then `download(rec.id)`. */
+    recordings: {
+        start: (input?: RecordOptions, options?: RequestOptions) => Promise<DesktopRecording>;
+        stop: (id: string, options?: RequestOptions) => Promise<DesktopRecording>;
+        get: (id: string, options?: RequestOptions) => Promise<DesktopRecording>;
+        list: (options?: RequestOptions) => Promise<DesktopRecording[]>;
+        /** The MP4 bytes. */
+        download: (id: string, options?: RequestOptions) => Promise<Uint8Array<ArrayBufferLike>>;
+        delete: (id: string, options?: RequestOptions) => Promise<{
+            deleted: boolean;
+        }>;
+    };
 };

package/dist/products/desktop.js

@@ -11,7 +11,27 @@ export function sandboxDesktop(t, sandbox) {
     const base = () => `/v1/sandboxes/${encodeURIComponent(sandbox.id)}/desktop`;
     const act = (body, options) => t.json({ method: "POST", path: `${base()}:act`, body, ...options });
     return {
-        start: (size = {}, options) => t.json({ method: "POST", path: `${base()}:start`, body: size, ...options }),
+        /** Starts the desktop. The first start in a sandbox installs it, which
+         * takes a minute or two; this waits for that (up to 10 minutes). */
+        async start(size = {}, options) {
+            const deadline = Date.now() + 600_000;
+            for (;;) {
+                try {
+                    return await t.json({
+                        method: "POST",
+                        path: `${base()}:start`,
+                        body: size,
+                        ...options,
+                    });
+                }
+                catch (error) {
+                    const code = error.code;
+                    if (code !== "desktop_installing" || Date.now() > deadline)
+                        throw error;
+                    await new Promise((resolve) => setTimeout(resolve, error.retryAfterMs ?? 10_000));
+                }
+            }
+        },
         stop: (options) => t.json({ method: "POST", path: `${base()}:stop`, ...options }),
         /** PNG bytes, or JPEG with `format: "jpeg"`. */
         screenshot: (input = {}, options) => t.bytes({ method: "GET", path: `${base()}/screenshot`, query: input, ...options }),
@@ -30,9 +50,59 @@ export function sandboxDesktop(t, sandbox) {
         cursor: (options) => act({ action: "cursor" }, options),
         windows: async (options) => (await act({ action: "windows" }, options)).windows,
         focus: (windowId, options) => act({ action: "focus", windowId }, options),
-        /** Opens `url` in Firefox on the desktop. */
-        open: (url, options) => act({ action: "open", url }, options),
+        /** Opens `url` in Firefox on the desktop. Right after a sandbox's first
+         * start, Firefox may still be installing; this waits for it. */
+        async open(url, options) {
+            const deadline = Date.now() + 600_000;
+            for (;;) {
+                try {
+                    return await act({ action: "open", url }, options);
+                }
+                catch (error) {
+                    const code = error.code;
+                    if (code !== "desktop_installing" || Date.now() > deadline)
+                        throw error;
+                    await new Promise((resolve) => setTimeout(resolve, error.retryAfterMs ?? 10_000));
+                }
+            }
+        },
         /** Starts a program on the desktop, detached. */
         launch: (argv, options) => act({ action: "launch", argv }, options),
+        /** Screen recordings to MP4: `const rec = await sbx.desktop.recordings.start();`
+         * ... `await sbx.desktop.recordings.stop(rec.id)`, then `download(rec.id)`. */
+        recordings: {
+            start: (input = {}, options) => t.json({
+                method: "POST",
+                path: `${base()}/recordings`,
+                body: input,
+                ...options,
+            }),
+            stop: (id, options) => t.json({
+                method: "POST",
+                path: `${base()}/recordings/${encodeURIComponent(id)}:stop`,
+                ...options,
+            }),
+            get: (id, options) => t.json({
+                method: "GET",
+                path: `${base()}/recordings/${encodeURIComponent(id)}`,
+                ...options,
+            }),
+            list: async (options) => (await t.json({
+                method: "GET",
+                path: `${base()}/recordings`,
+                ...options,
+            })).data,
+            /** The MP4 bytes. */
+            download: (id, options) => t.bytes({
+                method: "GET",
+                path: `${base()}/recordings/${encodeURIComponent(id)}/video`,
+                ...options,
+            }),
+            delete: (id, options) => t.json({
+                method: "DELETE",
+                path: `${base()}/recordings/${encodeURIComponent(id)}`,
+                ...options,
+            }),
+        },
     };
 }

package/dist/products/index.d.ts

@@ -4,13 +4,17 @@ import { images } from "./images.js";
 import { sandboxDesktop } from "./desktop.js";
 import { sandboxInterpreter } from "./interpreter.js";
 import { sandboxNetwork } from "./network.js";
+import { addresses, domains, ports, tunnel } from "./network-products.js";
 import { sandboxPreviews } from "./previews.js";
 import { referrals } from "./referrals.js";
 import { audit } from "./audit.js";
+import { sso } from "./sso.js";
 import { switching } from "./switching.js";
 import { limits } from "./limits.js";
 import { volumes } from "./volumes.js";
+import { sandboxMounts } from "./mounts.js";
 import { secrets } from "./secrets.js";
+import { mcp, sandboxMcp } from "./mcp.js";
 import { events, otel, sandboxMetrics, webhooks } from "./observability.js";
 export declare const clientExtensions: {
     images: typeof images;
@@ -23,13 +27,21 @@ export declare const clientExtensions: {
     otel: typeof otel;
     events: typeof events;
     audit: typeof audit;
+    mcp: typeof mcp;
+    sso: typeof sso;
+    domains: typeof domains;
+    ports: typeof ports;
+    addresses: typeof addresses;
+    tunnel: typeof tunnel;
 };
 export declare const sandboxExtensions: {
     interpreter: typeof sandboxInterpreter;
     previews: typeof sandboxPreviews;
     network: typeof sandboxNetwork;
     desktop: typeof sandboxDesktop;
+    mounts: typeof sandboxMounts;
     metrics: typeof sandboxMetrics;
+    mcp: typeof sandboxMcp;
 };
 export type ClientExtensions = {
     readonly [K in keyof typeof clientExtensions]: ReturnType<(typeof clientExtensions)[K]>;

package/dist/products/index.js

@@ -2,13 +2,17 @@ import { images } from "./images.js";
 import { sandboxDesktop } from "./desktop.js";
 import { sandboxInterpreter } from "./interpreter.js";
 import { sandboxNetwork } from "./network.js";
+import { addresses, domains, ports, tunnel } from "./network-products.js";
 import { sandboxPreviews } from "./previews.js";
 import { referrals } from "./referrals.js";
 import { audit } from "./audit.js";
+import { sso } from "./sso.js";
 import { switching } from "./switching.js";
 import { limits } from "./limits.js";
 import { volumes } from "./volumes.js";
+import { sandboxMounts } from "./mounts.js";
 import { secrets } from "./secrets.js";
+import { mcp, sandboxMcp } from "./mcp.js";
 import { events, otel, sandboxMetrics, webhooks } from "./observability.js";
 /* HOW A LANE ADDS A PRODUCT TO THE SDK
  *
@@ -36,13 +40,21 @@ export const clientExtensions = {
     otel,
     events,
     audit,
+    mcp,
+    sso,
+    domains,
+    ports,
+    addresses,
+    tunnel,
 };
 export const sandboxExtensions = {
     interpreter: sandboxInterpreter,
     previews: sandboxPreviews,
     network: sandboxNetwork,
     desktop: sandboxDesktop,
+    mounts: sandboxMounts,
     metrics: sandboxMetrics,
+    mcp: sandboxMcp,
 };
 /** The factories as plain pairs, for the constructors that install them. */
 export function clientFactories() {

package/dist/products/interpreter.d.ts

@@ -1,6 +1,6 @@
 import type { Sandbox } from "../sandbox.js";
 import type { RequestOptions, Transport } from "../transport.js";
-export type InterpreterLanguage = "python" | "javascript";
+export type InterpreterLanguage = "python" | "javascript" | "typescript" | "r" | "java" | "bash" | "go";
 export type ResultRef = {
     path: string;
     bytes: number;
@@ -47,7 +47,8 @@ export type InterpreterContext = {
 };
 export type RunOptions = RequestOptions & {
     language?: InterpreterLanguage;
-    /** A context id; "python" and "javascript" are the defaults, started on first use. */
+    /** A context id; each language's own name ("python", "typescript", "r"...) is
+     * its default context, started on first use. */
     context?: string;
     timeoutMs?: number;
     onStdout?: (text: string) => void;
@@ -59,7 +60,8 @@ export type RunOptions = RequestOptions & {
         traceback: string;
     }) => void;
 };
-/** A stateful Python and JavaScript interpreter in the sandbox:
+/** A stateful interpreter in the sandbox, in Python, JavaScript, TypeScript,
+ * R, Java, Bash or Go:
  * `await sbx.interpreter.run("import pandas as pd; pd.DataFrame({'a': [1]})")`.
  * Variables persist between runs of the same context, like a notebook. */
 export declare function sandboxInterpreter(t: Transport, sandbox: Sandbox): {

package/dist/products/interpreter.js

@@ -1,4 +1,5 @@
-/** A stateful Python and JavaScript interpreter in the sandbox:
+/** A stateful interpreter in the sandbox, in Python, JavaScript, TypeScript,
+ * R, Java, Bash or Go:
  * `await sbx.interpreter.run("import pandas as pd; pd.DataFrame({'a': [1]})")`.
  * Variables persist between runs of the same context, like a notebook. */
 export function sandboxInterpreter(t, sandbox) {

package/dist/products/mcp.d.ts

@@ -0,0 +1,79 @@
+import type { Sandbox } from "../sandbox.js";
+import type { RequestOptions, Transport } from "../transport.js";
+export type McpCatalogEntry = {
+    id: string;
+    title: string;
+    description: string;
+    license: string;
+    source: string;
+    version: string;
+    env: {
+        name: string;
+        description: string;
+        required: boolean;
+        secret: boolean;
+        hosts?: string[];
+    }[];
+    options: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+    egress: string[];
+    checked: string;
+};
+export type McpServerRequest = {
+    /** A catalog id, e.g. "github". */
+    id: string;
+    name?: string;
+    /** A secret setting to the Runtime secret that fills it. */
+    secrets?: Record<string, string>;
+    env?: Record<string, string>;
+    options?: Record<string, string>;
+} | {
+    name: string;
+    command: string[];
+    env?: Record<string, string>;
+};
+export type McpGateway = {
+    running: boolean;
+    port: number | null;
+    /** Send it as `Authorization: Bearer <token>`. */
+    token?: string | null;
+    headers?: Record<string, string>;
+    urlExpiresAt?: string | null;
+    servers: {
+        name: string;
+        status: "installing" | "ready" | "failed";
+        message?: string | null;
+        /** Its Streamable HTTP endpoint. */
+        url: string | null;
+    }[];
+    warnings: string[];
+};
+/** `runtime.mcp`: the catalog of MCP servers a sandbox can run. */
+export declare function mcp(t: Transport): {
+    catalog: (options?: RequestOptions) => Promise<McpCatalogEntry[]>;
+};
+/** `sbx.mcp`: catalog MCP servers running inside the sandbox, at URLs an
+ * agent connects to.
+ *
+ *   const gw = await sbx.mcp.start([{ id: "github", secrets: { GITHUB_PERSONAL_ACCESS_TOKEN: "GITHUB_TOKEN" } }]);
+ *   // gw.servers[0].url with gw.headers, in any MCP client
+ */
+export declare function sandboxMcp(t: Transport, sandbox: Sandbox): {
+    start: (servers: McpServerRequest[], input?: {
+        port?: number;
+        replace?: boolean;
+    }, options?: RequestOptions) => Promise<McpGateway>;
+    /** Their state, and fresh URLs. */
+    get: (options?: RequestOptions) => Promise<McpGateway>;
+    /** Wait until every server is ready (or one failed). */
+    ready(input?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }): Promise<McpGateway>;
+    stop: (options?: RequestOptions) => Promise<{
+        stopped: boolean;
+    }>;
+};

package/dist/products/mcp.js

@@ -0,0 +1,37 @@
+/** `runtime.mcp`: the catalog of MCP servers a sandbox can run. */
+export function mcp(t) {
+    return {
+        catalog: async (options) => (await t.json({
+            method: "GET",
+            path: "/v1/mcp/catalog",
+            ...options,
+        })).data,
+    };
+}
+/** `sbx.mcp`: catalog MCP servers running inside the sandbox, at URLs an
+ * agent connects to.
+ *
+ *   const gw = await sbx.mcp.start([{ id: "github", secrets: { GITHUB_PERSONAL_ACCESS_TOKEN: "GITHUB_TOKEN" } }]);
+ *   // gw.servers[0].url with gw.headers, in any MCP client
+ */
+export function sandboxMcp(t, sandbox) {
+    const path = () => `/v1/sandboxes/${encodeURIComponent(sandbox.id)}/mcp`;
+    return {
+        start: (servers, input = {}, options) => t.json({ method: "POST", path: path(), body: { servers, ...input }, ...options }),
+        /** Their state, and fresh URLs. */
+        get: (options) => t.json({ method: "GET", path: path(), ...options }),
+        /** Wait until every server is ready (or one failed). */
+        async ready(input = {}) {
+            const deadline = Date.now() + (input.timeoutMs ?? 600_000);
+            for (;;) {
+                const state = await t.json({ method: "GET", path: path() });
+                if (!state.running || state.servers.every((server) => server.status !== "installing"))
+                    return state;
+                if (Date.now() > deadline)
+                    return state;
+                await new Promise((resolve) => setTimeout(resolve, input.intervalMs ?? 2_000));
+            }
+        },
+        stop: (options) => t.json({ method: "DELETE", path: path(), ...options }),
+    };
+}

package/dist/products/mounts.d.ts

@@ -0,0 +1,49 @@
+import type { Sandbox } from "../sandbox.js";
+import type { RequestOptions, Transport } from "../transport.js";
+/** A bucket mounted in a sandbox. */
+export type Mount = {
+    path: string;
+    provider: "s3" | "r2" | "gcs";
+    bucket: string;
+    prefix: string | null;
+    /** The endpoint host the sandbox reaches the bucket at. */
+    endpoint: string;
+    /** The secret whose key the egress proxy signs with; null for a public bucket. */
+    secret: string | null;
+    readOnly: boolean;
+    /** Whether it is mounted right now. */
+    mounted: boolean;
+    mountedAt?: string;
+};
+export type MountBucket = {
+    /** s3 for Amazon S3, or any S3-compatible store with `endpoint`; r2 for
+     * Cloudflare R2 (with `accountId`); gcs for Google Cloud Storage (HMAC keys). */
+    provider: "s3" | "r2" | "gcs";
+    bucket: string;
+    /** Where it appears in the sandbox, such as /data. */
+    path: string;
+    prefix?: string;
+    region?: string;
+    endpoint?: string;
+    accountId?: string;
+    /** A secret stored with header `Authorization`, format
+     * `AWS4-HMAC-SHA256 {value}` and value `ACCESS_KEY_ID:SECRET_KEY`, naming
+     * the endpoint host. The sandbox never sees the key. Omit for a public bucket. */
+    secret?: string;
+    readOnly?: boolean;
+};
+/** `sbx.mounts`: your own S3, R2 or Google Cloud Storage bucket as a
+ * directory in this sandbox.
+ *
+ *   await sbx.mounts.add({ provider: "s3", bucket: "data", region: "eu-west-1",
+ *                          path: "/data", secret: "DATA_BUCKET" });
+ *
+ * A mount lasts through a pause and a wake, and ends when the sandbox stops. */
+export declare function sandboxMounts(t: Transport, sandbox: Sandbox): {
+    add: (input: MountBucket, options?: RequestOptions) => Promise<Mount>;
+    list: (options?: RequestOptions) => Promise<Mount[]>;
+    remove: (path: string, options?: RequestOptions) => Promise<{
+        path: string;
+        mounted: false;
+    }>;
+};

package/dist/products/mounts.js

@@ -0,0 +1,21 @@
+const enc = encodeURIComponent;
+/** `sbx.mounts`: your own S3, R2 or Google Cloud Storage bucket as a
+ * directory in this sandbox.
+ *
+ *   await sbx.mounts.add({ provider: "s3", bucket: "data", region: "eu-west-1",
+ *                          path: "/data", secret: "DATA_BUCKET" });
+ *
+ * A mount lasts through a pause and a wake, and ends when the sandbox stops. */
+export function sandboxMounts(t, sandbox) {
+    const base = () => `/v1/sandboxes/${enc(sandbox.id)}/mounts`;
+    return {
+        add: (input, options) => t.json({ method: "POST", path: base(), body: input, ...options }),
+        list: async (options) => (await t.json({ method: "GET", path: base(), ...options })).data,
+        remove: (path, options) => t.json({
+            method: "POST",
+            path: `${base()}:unmount`,
+            body: { path },
+            ...options,
+        }),
+    };
+}

package/dist/products/network-products.d.ts

@@ -0,0 +1,167 @@
+import type { RequestOptions, Transport } from "../transport.js";
+export type DnsRecord = {
+    type: string;
+    name: string;
+    value: string;
+    purpose: string;
+};
+export type Domain = {
+    id: string;
+    hostname: string;
+    sandboxId: string;
+    port: number;
+    /** pending until the TXT record proves the name is yours, then active. */
+    state: "pending" | "active" | "released";
+    url: string;
+    /** Turned off by Runtime after a report. */
+    disabled: boolean;
+    /** The TXT record that proves the name, and the CNAME (or A) that sends visitors here. */
+    records: DnsRecord[];
+    verifiedAt: string | null;
+    checkedAt: string | null;
+    checkError: string | null;
+    createdAt: string;
+};
+export type CheckedDomain = Domain & {
+    /** The name resolves to Runtime's edge now. */
+    pointed: boolean | null;
+    hint: string;
+};
+export type TcpPort = {
+    id: string;
+    sandboxId: string;
+    /** The port inside the sandbox. */
+    port: number;
+    address: string;
+    publicPort: number;
+    /** address:publicPort, for a client's host and port. */
+    connect: string;
+    protocol: "tcp";
+    disabled: boolean;
+    createdAt: string;
+};
+export type NetworkFunding = {
+    /** False disables traffic; the reservation remains until explicitly released. */
+    funded: boolean;
+    /** Last funded-through ISO timestamp, possibly past. Null means no meter exists. */
+    fundedUntil: string | null;
+    /** Immutable monthly quote in millionths of a US dollar. */
+    rateMicros: number;
+    rateUnit: "unit_month";
+};
+export type EgressAddress = NetworkFunding & {
+    id: string;
+    address: string;
+    family: 4 | 6;
+    createdAt: string;
+};
+export type TunnelPeer = {
+    id: string;
+    name: string;
+    publicKey: string;
+    /** The peer's address inside the tunnel's subnet. */
+    address: string;
+    /** Your own ranges behind the peer that sandboxes may reach through it. */
+    routes: string[];
+    createdAt: string;
+    rotatedAt: string | null;
+};
+export type Tunnel = NetworkFunding & {
+    id: string;
+    subnet: string;
+    gatewayAddress: string;
+    /** Where peers send WireGuard: address:udpPort. */
+    endpoint: string;
+    /** Null for a few seconds after creation. */
+    gatewayPublicKey: string | null;
+    disabled: boolean;
+    peers: TunnelPeer[];
+    /** Each sandbox's address in the tunnel. */
+    sandboxes: {
+        sandboxId: string;
+        name: string | null;
+        address: string;
+        state: string;
+    }[];
+    createdAt: string;
+};
+export type TunnelPeerCreated = {
+    tunnel: Tunnel;
+    peer: TunnelPeer;
+    /** A wg-quick file. It holds the private key only when Runtime generated it. */
+    config: string | null;
+    /** False means config is a draft preserving the private key; fill its gateway PublicKey before use. */
+    configReady: boolean;
+    hint: string;
+};
+/** `runtime.domains`: serve a sandbox's port at your own hostname, with HTTPS. */
+export declare function domains(t: Transport): {
+    /** Claims the hostname and answers the DNS records to set. Calling it again
+     * with another sandbox or port points the name there. */
+    add: (input: {
+        hostname: string;
+        sandboxId: string;
+        port: number;
+    }, options?: RequestOptions) => Promise<CheckedDomain>;
+    /** Checks the TXT record now; the name goes live when it matches. */
+    verify: (hostname: string, options?: RequestOptions) => Promise<CheckedDomain>;
+    get: (hostname: string, options?: RequestOptions) => Promise<Domain>;
+    list: (options?: RequestOptions) => Promise<Domain[]>;
+    remove: (hostname: string, options?: RequestOptions) => Promise<{
+        hostname: string;
+        deleted: true;
+    }>;
+};
+/** `runtime.ports`: a public TCP port to a port of a sandbox. */
+export declare function ports(t: Transport): {
+    /** Returns the same public port when called again for the same sandbox and port. */
+    open: (input: {
+        sandboxId: string;
+        port: number;
+    }, options?: RequestOptions) => Promise<TcpPort & {
+        hint: string;
+    }>;
+    list: (filter?: {
+        sandboxId?: string;
+    }, options?: RequestOptions) => Promise<TcpPort[]>;
+    close: (portId: string, options?: RequestOptions) => Promise<{
+        id: string;
+        deleted: true;
+    }>;
+};
+/** `runtime.addresses`: a dedicated outbound address every sandbox of the
+ * account sends from, for allow-lists. */
+export declare function addresses(t: Transport): {
+    reserve: (input?: {
+        family?: 4 | 6;
+    }, options?: RequestOptions) => Promise<EgressAddress>;
+    list: (options?: RequestOptions) => Promise<EgressAddress[]>;
+    release: (addressId: string, options?: RequestOptions) => Promise<{
+        id: string;
+        address: string;
+        deleted: true;
+    }>;
+};
+/** `runtime.tunnel`: a WireGuard tunnel from your own network into your sandboxes. */
+export declare function tunnel(t: Transport): {
+    get: (options?: RequestOptions) => Promise<Tunnel>;
+    /** Idempotent: returns the tunnel you have. */
+    create: (input?: {
+        subnet?: string;
+    }, options?: RequestOptions) => Promise<Tunnel>;
+    delete: (options?: RequestOptions) => Promise<{
+        id: string;
+        deleted: true;
+    }>;
+    /** Leave publicKey out and Runtime generates the pair; the private key is
+     * then in `config`, shown once. */
+    addPeer: (input: {
+        name: string;
+        publicKey?: string;
+        routes?: string[];
+    }, options?: RequestOptions) => Promise<TunnelPeerCreated>;
+    rotatePeer: (peerId: string, input?: {
+        publicKey?: string;
+    }, options?: RequestOptions) => Promise<TunnelPeerCreated>;
+    removePeer: (peerId: string, options?: RequestOptions) => Promise<Tunnel>;
+};