hyperbrane 0.2.0 → 0.2.1

package/dist/sandbox/lib/sshKey.js

@@ -0,0 +1,75 @@
+import { createPrivateKey, randomBytes } from "node:crypto";
+import ssh2 from "ssh2";
+const FORMATS = "an unencrypted private key in OpenSSH, PKCS#8 (Ed25519, RSA, ECDSA), PKCS#1 (RSA) or SEC1 (ECDSA) format";
+const PEM_WIDTH = 70;
+function parsed(privateKey) {
+    const result = ssh2.utils.parseKey(privateKey);
+    const key = Array.isArray(result) ? result[0] : result;
+    if (!key)
+        return new Error("no key found");
+    if (!(key instanceof Error) && !key.isPrivateKey())
+        return new Error("it's a public key");
+    return key;
+}
+function sshString(value) {
+    const bytes = typeof value === "string" ? Buffer.from(value) : value;
+    const length = Buffer.alloc(4);
+    length.writeUInt32BE(bytes.length);
+    return Buffer.concat([length, bytes]);
+}
+function uint32(value) {
+    const bytes = Buffer.alloc(4);
+    bytes.writeUInt32BE(value);
+    return bytes;
+}
+function openSshEd25519(key) {
+    const { d, x } = key.export({ format: "jwk" });
+    const seed = Buffer.from(d, "base64url");
+    const publicKey = Buffer.from(x, "base64url");
+    const check = randomBytes(4);
+    const unpadded = Buffer.concat([check, check, sshString("ssh-ed25519"), sshString(publicKey), sshString(Buffer.concat([seed, publicKey])), sshString("")]);
+    const padding = Buffer.from(Array.from({ length: (8 - (unpadded.length % 8)) % 8 }, (_, i) => i + 1));
+    const blob = Buffer.concat([
+        Buffer.from("openssh-key-v1\0"),
+        sshString("none"),
+        sshString("none"),
+        sshString(""),
+        uint32(1),
+        sshString(Buffer.concat([sshString("ssh-ed25519"), sshString(publicKey)])),
+        sshString(Buffer.concat([unpadded, padding])),
+    ]);
+    const lines = blob.toString("base64").match(new RegExp(`.{1,${PEM_WIDTH}}`, "g"));
+    return `-----BEGIN OPENSSH PRIVATE KEY-----\n${lines.join("\n")}\n-----END OPENSSH PRIVATE KEY-----\n`;
+}
+function converted(privateKey) {
+    let key;
+    try {
+        key = createPrivateKey(privateKey);
+    }
+    catch {
+        return null;
+    }
+    switch (key.asymmetricKeyType) {
+        case "rsa":
+            return key.export({ type: "pkcs1", format: "pem" });
+        case "ec":
+            return key.export({ type: "sec1", format: "pem" });
+        case "ed25519":
+            return openSshEd25519(key);
+        default:
+            return null;
+    }
+}
+export function parseSshKey(privateKey, whose) {
+    const key = parsed(privateKey);
+    if (!(key instanceof Error))
+        return { privateKey, key };
+    const readable = converted(privateKey);
+    const convertedKey = readable === null ? null : parsed(readable);
+    if (readable !== null && convertedKey !== null && !(convertedKey instanceof Error))
+        return { privateKey: readable, key: convertedKey };
+    throw new Error(`${whose} SSH key can't be read (${key.message}): it takes ${FORMATS}`);
+}
+export function sshPrivateKey(privateKey, whose) {
+    return parseSshKey(privateKey, whose).privateKey;
+}

package/dist/sandbox/providers/boat/boatService.d.ts

@@ -1,2 +1,3 @@
-import { type SandboxAuthContext, type SandboxService } from "../../api.ts";
+import { type SandboxAuthContext, type SandboxListing, type SandboxService } from "../../api.ts";
+export declare function listBoatSandboxes(ctx: SandboxAuthContext): Promise<SandboxListing[]>;
 export declare function createBoatService(ctx: SandboxAuthContext): SandboxService;

package/dist/sandbox/providers/boat/boatService.js

@@ -1,20 +1,27 @@
 import { randomUUID } from "node:crypto";
 import { posix } from "node:path";
 import { BoatApi, Configuration, ResponseError, waitUntilReady } from "@boatdev/sdk";
-import ssh2 from "ssh2";
-import { SandboxNotFoundError, SandboxStoppedError, } from "../../api.js";
+import { SandboxNotFoundError, SandboxPathError, SandboxStoppedError, } from "../../api.js";
 import { commandLine, quote } from "../../lib/shellCommand.js";
 import { commandFileOperations } from "../../lib/remoteFileOperations.js";
+import { parseSshKey } from "../../lib/sshKey.js";
 import { createDescriptor, getDescriptor, openDescriptor } from "../../storage/descriptors.js";
 import { createEndpoints } from "../../data-endpoints/dataEndpoints.js";
 import { createSandboxStorage } from "../../storage/sandboxStorage.js";
 import { sshConnect, sshFetch } from "../ssh/sshTransport.js";
 const BOAT_API_URL = "https://boat.dev/api/v1";
+const WORK_DIRECTORY = "/home/user";
+const FILE_API_DIRECTORIES = [WORK_DIRECTORY, "/tmp"];
+const REFUSED_PATH = /^Path must resolve under/;
 const COMMAND_TIMEOUT_S = 600;
 const READY_TIMEOUT_MS = 180_000;
 const RUNNING_STATES = ["ready", "idle", "running"];
+const STOPPED_CODES = ["machine_not_running", "sandbox_not_ready"];
 const UNDELIVERED = ["localhost_relay_failed", "sandbox_direct_failed"];
+const RESTORING = "sandbox_restoring";
 const UNDELIVERED_RETRY_MS = [1000, 2000, 4000];
+const LISTED_PER_PAGE = 200;
+const UNLISTED_STATES = ["cancelled", "error"];
 const DEFAULT_PORTS = {
     from: 8900,
     to: 8999,
@@ -22,11 +29,15 @@ const DEFAULT_PORTS = {
 class BoatError extends Error {
     status;
     code;
+    detail;
+    retryable;
     name = "BoatError";
-    constructor(status, code, message) {
+    constructor(status, code, detail, retryable, message) {
         super(message);
         this.status = status;
         this.code = code;
+        this.detail = detail;
+        this.retryable = retryable;
     }
 }
 function apiKeyOf(ctx) {
@@ -62,18 +73,26 @@ async function boatOnce(what, call) {
             body = { message: text };
         }
         const code = body.code ?? "";
-        if (code === "machine_not_running")
+        if (STOPPED_CODES.includes(code))
             throw new SandboxStoppedError(`${what}: the Boat sandbox is stopped`);
-        throw new BoatError(error.response.status, code, `${what} failed (${error.response.status}${code ? ` ${code}` : ""}): ${body.message ?? text}`);
+        const details = body.error?.details ?? {};
+        throw new BoatError(error.response.status, code, details.message ?? body.message ?? "", details.retryable, `${what} failed (${error.response.status}${code ? ` ${code}` : ""}): ${body.message ?? text}`);
     }
 }
-async function boat(what, call) {
+function undelivered(error, reaches) {
+    if (reaches === "command")
+        return error.code === "sandbox_direct_failed" && error.detail === RESTORING;
+    if (reaches === "file")
+        return error.code === "localhost_relay_failed" || (error.code === "sandbox_direct_failed" && error.retryable === true);
+    return UNDELIVERED.includes(error.code);
+}
+async function boat(what, call, reaches = "api") {
     for (const wait of [...UNDELIVERED_RETRY_MS, null]) {
         try {
             return await boatOnce(what, call);
         }
         catch (error) {
-            if (wait === null || !(error instanceof BoatError) || !UNDELIVERED.includes(error.code))
+            if (wait === null || !(error instanceof BoatError) || !undelivered(error, reaches))
                 throw error;
             await new Promise((resolve) => setTimeout(resolve, wait));
         }
@@ -113,7 +132,7 @@ async function resuming(ctx, call) {
 async function command(ctx, line, cwd) {
     const api = apiOf(ctx);
     const sandboxId = sandboxIdOf(ctx);
-    const result = await boat(`a command in ${where(ctx)}`, () => api.command({ sandboxId, command: line, cwd, timeoutSeconds: COMMAND_TIMEOUT_S }));
+    const result = await boat(`a command in ${where(ctx)}`, () => api.command({ sandboxId, command: `exec sh -c ${quote(line)}`, cwd, timeoutSeconds: COMMAND_TIMEOUT_S }), "command");
     if (!("exitCode" in result))
         throw new Error(`a command in ${where(ctx)} was started in the background`);
     if (result.timedOut)
@@ -122,18 +141,33 @@ async function command(ctx, line, cwd) {
         throw new Error(`Boat cut the output of a command in ${where(ctx)} short`);
     return { exitCode: result.exitCode ?? -1, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
 }
+function reachable(ctx, path) {
+    if (FILE_API_DIRECTORIES.some((directory) => path === directory || path.startsWith(`${directory}/`)))
+        return path;
+    throw new SandboxPathError(`${path} is outside ${FILE_API_DIRECTORIES.join(" and ")}, the directories Boat's file API reaches in ${where(ctx)}`);
+}
+function refused(ctx, path, error) {
+    if (!(error instanceof BoatError) || !(error.code === "invalid_path" || REFUSED_PATH.test(error.detail)))
+        return error;
+    return new SandboxPathError(`Boat's file API refuses ${path} in ${where(ctx)}: ${error.detail}`);
+}
 async function upload(ctx, path, data) {
     const api = apiOf(ctx);
     const sandboxId = sandboxIdOf(ctx);
     const content = Buffer.from(data).toString("base64");
-    await boat(`writing ${path} in ${where(ctx)}`, () => api.writeFile({ sandboxId, path, content, encoding: "base64" }));
+    try {
+        await boat(`writing ${path} in ${where(ctx)}`, () => api.writeFile({ sandboxId, path: reachable(ctx, path), content, encoding: "base64" }), "file");
+    }
+    catch (error) {
+        throw refused(ctx, path, error);
+    }
 }
 async function runCommand(ctx, cmd, { cwd, env, stdin } = {}) {
     const directory = cwd === undefined ? undefined : posix.resolve("/", cwd);
     if (stdin === undefined)
         return resuming(ctx, () => command(ctx, commandLine(cmd, { env }), directory));
     return resuming(ctx, async () => {
-        const staged = `/tmp/.hyperbrane-stdin-${randomUUID()}`;
+        const staged = `${WORK_DIRECTORY}/.hyperbrane-stdin-${randomUUID()}`;
         await upload(ctx, staged, typeof stdin === "string" ? new TextEncoder().encode(stdin) : stdin);
         return command(ctx, `(${commandLine(cmd, { env })}) < ${quote(staged)}; code=$?; rm -f ${quote(staged)}; exit "$code"`, directory);
     });
@@ -142,20 +176,27 @@ function boatMachine(ctx) {
     async function readBytes(path, start, end) {
         const api = apiOf(ctx);
         const sandboxId = sandboxIdOf(ctx);
+        reachable(ctx, path);
         try {
-            const { content } = await boat(`reading ${path} in ${where(ctx)}`, () => api.readFile({ sandboxId, path, encoding: "base64" }));
+            const { content } = await boat(`reading ${path} in ${where(ctx)}`, () => api.readFile({ sandboxId, path, encoding: "base64" }), "file");
             const data = new Uint8Array(Buffer.from(content, "base64"));
             return start === undefined ? data : data.subarray(start, end);
         }
         catch (error) {
-            if (error instanceof BoatError && error.status === 404)
+            const failure = refused(ctx, path, error);
+            if (failure === error && error instanceof BoatError && (await absent(path)))
                 throw new SandboxNotFoundError(`Not found: "${path}"`);
-            throw error;
+            throw failure;
         }
     }
+    async function absent(path) {
+        const checked = await command(ctx, `test -e ${quote(path)}`).catch(() => null);
+        return checked?.exitCode === 1;
+    }
     async function putFile(path, data, exclusive) {
+        reachable(ctx, path);
         return resuming(ctx, async () => {
-            const staged = `${posix.dirname(path)}/.${posix.basename(path)}.${randomUUID()}.tmp`;
+            const staged = `${posix.dirname(path)}/.hyperbrane-${randomUUID()}.tmp`;
             const made = await command(ctx, `mkdir -p ${quote(posix.dirname(path))}`);
             if (made.exitCode !== 0)
                 throw new Error(`writing ${path} in ${where(ctx)} failed: ${made.stderr.trim()}`);
@@ -177,13 +218,9 @@ function boatMachine(ctx) {
     };
 }
 async function sshTarget(ctx) {
-    const privateKey = ctx.sshKey;
-    if (!privateKey)
+    if (!ctx.sshKey)
         throw new Error(`${where(ctx)} has no shell: its context has no SSH key (sshKey)`);
-    const parsed = ssh2.utils.parseKey(privateKey);
-    const key = Array.isArray(parsed) ? parsed[0] : parsed;
-    if (!key || key instanceof Error)
-        throw new Error(`${where(ctx)}'s SSH key can't be read${key instanceof Error ? `: ${key.message}` : ""}`);
+    const { privateKey, key } = parseSshKey(ctx.sshKey, `${where(ctx)}'s`);
     await ensureRunning(ctx);
     const api = apiOf(ctx);
     const sandboxId = sandboxIdOf(ctx);
@@ -286,6 +323,21 @@ function hasShell(ctx) {
 async function sshEndpoint(ctx) {
     return sshTarget(ctx);
 }
+export async function listBoatSandboxes(ctx) {
+    const api = apiOf(ctx);
+    const listings = [];
+    let cursor;
+    do {
+        const page = await boat("listing Boat sandboxes", () => api.sandboxes({ limit: LISTED_PER_PAGE, cursor }));
+        for (const sandbox of page.sandboxes) {
+            if (UNLISTED_STATES.includes(sandbox.state))
+                continue;
+            listings.push({ id: sandbox.id, name: sandbox.name, state: RUNNING_STATES.includes(sandbox.state) ? "running" : "stopped" });
+        }
+        cursor = page.pageInfo?.hasMore ? (page.pageInfo.nextCursor ?? undefined) : undefined;
+    } while (cursor);
+    return listings;
+}
 export function createBoatService(ctx) {
     apiKeyOf(ctx);
     const { fileOps, cmdOps, netOps } = groupsOf(ctx);

package/dist/sandbox/providers/exedev/exeDevService.js

@@ -1,5 +1,6 @@
 import { userInfo } from "node:os";
 import { commandFileOperations } from "../../lib/remoteFileOperations.js";
+import { sshPrivateKey } from "../../lib/sshKey.js";
 import { createDescriptor, getDescriptor, openDescriptor } from "../../storage/descriptors.js";
 import { createEndpoints } from "../../data-endpoints/dataEndpoints.js";
 import { createSandboxStorage } from "../../storage/sandboxStorage.js";
@@ -24,9 +25,10 @@ function vmOf(ctx) {
 function target(ctx) {
     if (!ctx.sshKey)
         throw new Error(`exe.dev VM ${ctx.id ?? "(no name)"} needs the account's SSH key (sshKey)`);
+    const privateKey = sshPrivateKey(ctx.sshKey, "the exe.dev account's");
     if (ctx.sshHost)
-        return { host: ctx.sshHost, port: ctx.sshPort ?? 22, user: ctx.sshUser ?? userInfo().username, privateKey: ctx.sshKey };
-    return { host: "vm.exe.xyz", port: 22, user: `vm+${vmOf(ctx)}`, privateKey: ctx.sshKey };
+        return { host: ctx.sshHost, port: ctx.sshPort ?? 22, user: ctx.sshUser ?? userInfo().username, privateKey };
+    return { host: "vm.exe.xyz", port: 22, user: `vm+${vmOf(ctx)}`, privateKey };
 }
 function where(ctx) {
     return `exe.dev VM ${ctx.id ?? "(no name)"}`;

package/dist/sandbox/providers/exedev/exeDevToken.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import ssh2 from "ssh2";
+import { parseSshKey } from "../../lib/sshKey.js";
 function sshString(value) {
     const bytes = typeof value === "string" ? Buffer.from(value) : value;
     const length = Buffer.alloc(4);
@@ -7,11 +7,7 @@ function sshString(value) {
     return Buffer.concat([length, bytes]);
 }
 function privateKeyOf(privateKey) {
-    const parsed = ssh2.utils.parseKey(privateKey);
-    const key = Array.isArray(parsed) ? parsed[0] : parsed;
-    if (!key || key instanceof Error || !key.isPrivateKey())
-        throw new Error(`the exe.dev key isn't a usable private key${key instanceof Error ? `: ${key.message}` : ""}`);
-    return key;
+    return parseSshKey(privateKey, "the exe.dev account's").key;
 }
 function ecdsaBlob(der) {
     let offset = 2 + (der[1] & 0x80 ? der[1] & 0x7f : 0);

package/dist/sandbox/providers/local/localService.js

@@ -1,14 +1,15 @@
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import * as fs from "node:fs/promises";
-import { connect as netConnect, Socket } from "node:net";
+import { connect as netConnect } from "node:net";
 import { homedir, userInfo } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
-import { SandboxConnectionRefusedError, SandboxNotFoundError, } from "../../api.js";
+import { SandboxNotFoundError, } from "../../api.js";
 import { createDescriptor, getDescriptor, openDescriptor } from "../../storage/descriptors.js";
 import { createEndpoints } from "../../data-endpoints/dataEndpoints.js";
 import { firewalledPorts } from "../../data-endpoints/firewalledPorts.js";
 import { httpOver } from "../../lib/httpOverStream.js";
+import { connectUnixSocket } from "../../../lib/unixSocket.js";
 import { createSandboxStorage } from "../../storage/sandboxStorage.js";
 function hostPath(path) {
     return resolve("/", path);
@@ -142,30 +143,7 @@ async function fetch(url, { unix, ...init } = {}) {
     return httpOver(url, () => netConnect(hostPath(unix)), init);
 }
 function connect(path) {
-    return new Promise((resolve, reject) => {
-        const socket = new Socket();
-        let markClosed;
-        const closed = new Promise((done) => (markClosed = done));
-        const listeners = [];
-        socket.on("data", (chunk) => {
-            for (const listener of listeners)
-                listener(new Uint8Array(chunk));
-        });
-        socket.once("close", () => markClosed());
-        socket.once("end", () => markClosed());
-        socket.on("error", (error) => {
-            markClosed();
-            const message = `connecting to ${path} failed: ${error.message}`;
-            reject(error.code === "ENOENT" || error.code === "ECONNREFUSED" ? new SandboxConnectionRefusedError(message) : new Error(message));
-        });
-        socket.once("connect", () => resolve({
-            write: (data) => void socket.write(data),
-            onData: (listener) => void listeners.push(listener),
-            closed,
-            close: () => socket.end(),
-        }));
-        socket.connect({ path: hostPath(path) });
-    });
+    return connectUnixSocket(hostPath(path), path);
 }
 export function createLocalService(ctx) {
     const fileOps = {

package/dist/sandbox/providers/ssh/sshService.js

@@ -4,13 +4,14 @@ import { createDescriptor, getDescriptor, openDescriptor } from "../../storage/d
 import { createEndpoints } from "../../data-endpoints/dataEndpoints.js";
 import { firewalledPorts } from "../../data-endpoints/firewalledPorts.js";
 import { createSandboxStorage } from "../../storage/sandboxStorage.js";
+import { sshPrivateKey } from "../../lib/sshKey.js";
 import { sshCommand, sshConnect, sshFetch, sshMachine } from "./sshTransport.js";
 function target(ctx) {
     if (!ctx.sshHost)
         throw new Error("an SSH machine needs its host (sshHost)");
     if (!ctx.sshKey)
         throw new Error(`SSH to ${ctx.sshHost} needs a key (sshKey)`);
-    return { host: ctx.sshHost, port: ctx.sshPort ?? 22, user: ctx.sshUser ?? userInfo().username, privateKey: ctx.sshKey };
+    return { host: ctx.sshHost, port: ctx.sshPort ?? 22, user: ctx.sshUser ?? userInfo().username, privateKey: sshPrivateKey(ctx.sshKey, `${where(ctx)}'s`) };
 }
 function where(ctx) {
     return `SSH machine ${ctx.sshHost ?? "(no host)"}`;

package/dist/sandbox/service.d.ts

@@ -1,2 +1,3 @@
-import type { SandboxAuthContext, SandboxService } from "./api.ts";
+import type { SandboxAuthContext, SandboxListing, SandboxService } from "./api.ts";
 export declare function createSandboxService(ctx: SandboxAuthContext): SandboxService;
+export declare function listSandboxes(ctx: SandboxAuthContext): Promise<SandboxListing[]>;

package/dist/sandbox/service.js

@@ -1,7 +1,8 @@
-import { createBoatService } from "./providers/boat/boatService.js";
+import { createBoatService, listBoatSandboxes } from "./providers/boat/boatService.js";
 import { createExeDevService } from "./providers/exedev/exeDevService.js";
 import { createSshService } from "./providers/ssh/sshService.js";
 import { createLocalService } from "./providers/local/localService.js";
+import { createSandboxStorage } from "./storage/sandboxStorage.js";
 export function createSandboxService(ctx) {
     // Create service is a factory that initializes the specific sandbox operations client
     // It does nothing, just creates the client
@@ -16,3 +17,10 @@ export function createSandboxService(ctx) {
             return createLocalService(ctx);
     }
 }
+export async function listSandboxes(ctx) {
+    if (ctx.kind === "boat")
+        return listBoatSandboxes(ctx);
+    const service = createSandboxService(ctx);
+    const descriptor = await createSandboxStorage(service).readDescriptor();
+    return descriptor ? [{ id: descriptor.id, name: descriptor.name, state: await service.state() }] : [];
+}

package/dist/vendor-types/claude/agent-sdk/bridge.d.ts

@@ -61,17 +61,21 @@ export type BridgeSessionHandle = {
     sendControlCancelRequest(requestId: string): void;
     /**
      * Swap the underlying transport in place with a fresh JWT (and epoch).
-     * Carries the SSE sequence number so the server resumes the stream.
+     * Carries the SSE sequence number so the server resumes the stream, and
+     * hands the old transport's undelivered writes to the new one, including
+     * writes made after the transport died, so this call is also how a host
+     * recovers them after onClose fires.
      * Call this when the poll loop re-dispatches work for the same session
      * with a fresh secret (JWT is 4h; backend mints a new one every dispatch).
      *
      * Throws if `createV2ReplTransport` fails (registerWorker error, etc).
-     * Caller should treat that as a close and drop this handle.
+     * Caller should treat that as a close and drop this handle; the
+     * undelivered writes are dropped with it.
      */
     reconnectTransport(opts: {
         ingressToken: string;
         apiBaseUrl: string;
-        /** Omit to reuse the current transport's epoch (token-refresh reconnect); provide to override. */
+        /** Omit to reuse the current transport's epoch (token-refresh reconnect); provide to override. Pass a fresh one after a 4090. */
         epoch?: number;
     }): Promise<void>;
     /**
@@ -131,6 +135,13 @@ export type AttachBridgeSessionOptions = {
      * not be able to drive it.
      */
     outboundOnly?: boolean;
+    /**
+     * Version of the Claude Code CLI this host runs the session's turns with.
+     * Reported to attaching clients as `claude_code_version` on the initialize
+     * reply so they can gate features before the first turn's `system`/`init`
+     * arrives; omit when unknown and clients wait for that message instead.
+     */
+    claudeCodeVersion?: string;
     /**
      * User message typed on claude.ai. Echoes of outbound writes and
      * re-deliveries of prompts already forwarded are filtered before this
@@ -221,7 +232,11 @@ export type AttachBridgeSessionOptions = {
      * (heartbeat/write auth exhaustion — re-attach with a fresh secret,
      * like 401), 403/404 = permanent SSE HTTP rejection. Transient
      * disconnects (503, network blips) retry indefinitely inside
-     * SSETransport and do NOT fire this.
+     * SSETransport and do NOT fire this. After it fires, the handle keeps
+     * writes it could not deliver: reconnectTransport() hands them to the
+     * rebuilt transport, and close() drops them. After a 4090 the epoch
+     * may be stale: pass one from a fresh /bridge call, since reusing a
+     * stale one closes again.
      */
     onClose?: (code?: number) => void;
 };
@@ -351,6 +366,7 @@ export type CreateSessionFailure = {
     terminal: true;
     reason: 'grouping_rejected' | 'request_rejected' | 'malformed_response';
     status: number;
+    /** The service's own message, unchanged and still untrusted, or undefined. It is passed on only if it is one line of at most 1,024 UTF-16 units, with no control or invisible characters and no whitespace other than single ASCII spaces. */
     detail: string | undefined;
 };
 /**

package/dist/vendor-types/claude/agent-sdk/browser-sdk.d.ts

@@ -89,6 +89,13 @@ type BrowserQueryOptionsBase = {
      * each turn's result. At most one per turn.
      */
     promptSuggestions?: boolean;
+    /**
+     * Dialog kinds (`request_user_dialog` `dialog_kind` values) this consumer's
+     * `onUserDialog` can render, declared on `initialize`. The remote CLI sends
+     * only kinds an attached client declared, so `onUserDialog` alone does not
+     * opt in. A non-empty list without `onUserDialog` throws.
+     */
+    supportedDialogKinds?: string[];
 };
 /**
  * Exactly one of `websocket` | `sse` must be provided. `sse` is the v1alpha2
@@ -182,3 +189,20 @@ export declare function getCcrEvent(query: Query, message: SDKMessage): {
     created_at?: string;
     source?: string;
 } | undefined;
+/**
+ * Closes the event stream of an `sse` query without ending the query. The
+ * stream reopens on `resumeSseStream()` or on the query's next send, its own
+ * answers to earlier requests included. It then replays the durable events
+ * sent meanwhile (or `onCatchUpTruncated` fires). Until then, requests from
+ * the remote session, such as permission prompts, wait unanswered. So do the
+ * query's own requests in flight and sends still waiting for the first
+ * connection. Ephemeral frames and delivery updates sent meanwhile are lost.
+ * Returns false for a WebSocket, closed or suspended query.
+ */
+export declare function suspendSseStream(query: Query): boolean;
+/**
+ * Reopens the event stream that `suspendSseStream()` closed, resuming after
+ * the last event received. Returns false unless `query` is suspended and
+ * still open.
+ */
+export declare function resumeSseStream(query: Query): boolean;

package/dist/vendor-types/claude/agent-sdk/core.d.ts

@@ -1,10 +1,12 @@
 export {
   AbortError,
+  BUILTIN_TOOL_NAMES,
   createSdkMcpServer,
   deleteSession,
   EXIT_REASONS,
   filterEscalatingDefaultMode,
   HOOK_EVENTS,
+  LEGACY_TOOL_NAME_ALIASES,
   ORG_POLICY_LIMIT_PREFIXES,
   query,
   renameSession,