@workerdeck/client 0.22.0 → 1.0.0

package/build/index.d.mts

@@ -1,202 +1,54 @@
 import { AttachedFrame, CreateJobRequest, CreateProfileRequest, CreateSessionRequest, FindHostFilesResponse, GetProfileResponse, JobEvent, JobInfo, ListHostDirResponse, ListHostRootsResponse, ListProfilesResponse, McpServerActionRequest, McpServerStatusInfo, MessageAttachment, PermissionMode, ProfileInfo, QueueStats, ReadHostFileResponse, ResolvePermissionRequest, SdkSessionSummary, SessionEvent, SessionFileInfo, SessionInfo, SubmitExecutionResultRequest, SubmitExecutionResultResponse, ToolCallRequestFrame, ToolExecutionOutput, ToolResultBlock, UpdateProfileRequest, UpdateSessionRequest, WriteHostFileRequest, WriteHostFileResponse } from "@workerdeck/protocol";
 
-//#region src/host-url.d.ts
-/**
- * Pure URL logic for gateway hosts — what an operator types, turned into the
- * `baseUrl` a `WorkerDeckClient` takes.
- *
- * Here rather than in each client because there were already two copies (the iOS
- * `Host.apiURL` and the VS Code extension's port) and a third was coming. Every
- * host that lets someone type a gateway address has to normalize it the same
- * way, or the same gateway saved on two devices is two gateways.
- */
-type HostUrl = {
-  baseUrl: string;
-};
-/** Normalized REST base for `WorkerDeckClient`, or undefined if unparseable. */
-declare function apiUrl(host: HostUrl): string | undefined;
-/**
- * Whether this gateway is the machine the caller runs on. Decided from the URL,
- * never by probing paths for existence — two checkouts of the same repo would
- * lie. In a remote development window the caller runs on the remote box, so
- * "loopback" correctly means *that* machine and its paths are real files there.
- */
-declare function isLoopbackHost(host: HostUrl): boolean;
-//#endregion
-//#region src/host-auth.d.ts
-/**
- * The `ClientOptions` a **browser** needs to reach a gateway that is not its own
- * origin.
- *
- * Here, beside `apiUrl`, for the same reason that is here: every host that lets
- * someone type a gateway address and a key has to present them identically, or
- * the same gateway works in one client and not another. It is browser-shaped on
- * purpose — a Node host (the VS Code extension) sends the key as a header on
- * both transports and needs none of this.
- *
- * Two transports, because a browser has no choice:
- *
- * - **REST** takes `Authorization: Bearer <key>`, like any service client.
- * - **WebSocket** takes `?key=<key>`, because a tab cannot put a header on an
- *   upgrade handshake and the gateway's cookie belongs to another origin. The
- *   CLI's auth accepts the key this way on upgrades *only*.
- *
- * The query-string transport is the weaker one and is worth naming: unlike a
- * header it is a permanent credential that lands in reverse-proxy access logs.
- * It is confined to the upgrade so what a leaked URL buys is one attach. If a
- * gateway later mints short-lived tickets, only the body of `buildWsUrl`
- * changes — callers of this function do not.
- */
-declare function hostAuth(options: {
-  /** The gateway's API root, as `apiUrl()` returns it (ends in `/v1`). */baseUrl: string; /** The operator's gateway key. Empty means an unauthenticated gateway. */
-  key: string;
-}): Pick<ClientOptions, 'headers' | 'buildWsUrl' | 'buildQueueWsUrl'>;
+//#region src/lib/emitter.d.ts
+type Listener<T> = (payload: T) => void;
 //#endregion
-//#region src/index.d.ts
-/** Whatever the ambient `fetch` accepts as a body — `Blob`/`File` in a browser,
- * `Uint8Array` or a string in Node. Derived rather than named (`BodyInit` is a
- * DOM-lib type, and this package compiles against both). */
-type FetchBody = NonNullable<NonNullable<Parameters<typeof fetch>[1]>['body']>;
-type ClientOptions = {
-  /** REST base, e.g. "http://127.0.0.1:8787/v1". The ws:// URL is derived from it. */baseUrl: string;
-  /** Extra headers for REST calls (auth). Browsers can't set WS headers — use
-   * `buildWsUrl` (ticket query param) or cookies for WS auth. */
-  headers?: Record<string, string>; /** Override WS URL construction (auth tickets, proxies). */
-  buildWsUrl?: (sessionId: string, afterSeq: number, truncateResults?: boolean, imageRefs?: boolean) => string; /** Override the queue WS URL (`{baseUrl}/queue/ws` by default). */
-  buildQueueWsUrl?: () => string; /** Injectable for non-browser environments/tests. Defaults to globalThis.WebSocket. */
-  WebSocketImpl?: typeof WebSocket;
-  fetchImpl?: typeof fetch;
-};
-/**
- * A REST call the gateway refused, carrying the status alongside the message.
- *
- * An `Error` subclass on purpose: every existing `e instanceof Error` check and
- * every `e.message` read keeps working unchanged. The status is what lets a
- * caller tell "this server doesn't have that route" (404 — stop asking) from
- * "that file was too big" (413 — tell the user), which a message string can't.
- */
-declare class WorkerDeckError extends Error {
-  readonly status: number;
-  constructor(message: string, status: number);
-}
+//#region src/session-handle.d.ts
 type AttachOptions = {
-  /** Replay events with seq greater than this. Default 0 (full replay). */afterSeq?: number; /** Auto-reconnect with backoff on unexpected disconnects. Default true. */
+  afterSeq?: number;
   reconnect?: boolean;
-  /**
-   * Ask the gateway to replay an oversized tool result as its **head**, with
-   * `truncated`/`total_chars` on the block and the whole thing one
-   * {@link WorkerDeckClient.toolResult} call away. Measured after shipping, that
-   * is a **0.3%** cut on a real session, not the 68% it was designed against —
-   * the projection had counted base64 as text. The mechanism is right and the
-   * bytes were elsewhere; see {@link AttachOptions.imageRefs}.
-   *
-   * Default off, and the default must stay off: **only the unit that renders may
-   * ask for it**. `client` and `react` are separate packages an embedder can
-   * skew, and a caller that asked for heads without knowing how to fetch the
-   * rest would show one as though it were the whole result — the silent lie this
-   * rule family exists to prevent. `useClaudeSession` sets it; nothing else here
-   * does. Live events are never affected.
-   */
   truncateResults?: boolean;
-  /**
-   * Ask the gateway to deliver a tool result's base64 image parts as
-   * `image_ref` addresses, their bytes one {@link
-   * WorkerDeckClient.toolResultImage} call away.
-   *
-   * This is where the bytes actually were: measured across 214 local sessions,
-   * **91% of all tool-result payload is base64 no client renders** — 489 MB
-   * against 44 MB of text, two thirds of it from `Read` looking at a PNG. One
-   * session's attach fell from 4,550 KB to 771 KB with no image in it.
-   *
-   * Default off under the same rule as {@link AttachOptions.truncateResults} —
-   * only the unit that renders may ask — and its **own** flag rather than a
-   * widening of that one, because this family's "additive at protocol 7"
-   * argument rests on a client that never asked being unable to receive one, by
-   * construction rather than by release archaeology.
-   *
-   * Unlike truncation this **also applies to live events**. The render path is
-   * ref-then-fetch, so bytes arriving live would only be discarded or pinned in
-   * client state.
-   */
   imageRefs?: boolean;
 };
 type SessionHandleEvents = {
-  /** Fired on every (re)attach with the server's session snapshot. */attached: AttachedFrame; /** Every session event, replayed and live, in seq order. */
+  attached: AttachedFrame;
   event: SessionEvent;
-  protocolError: string; /** WS connectivity: true on open, false on close. */
+  protocolError: string;
   connectionChange: boolean;
-  /**
-   * A reconnect has been scheduled, carrying how many have failed in a row (1 on
-   * the first). The handle retries forever, so "offline" is a judgement a UI makes
-   * about how long it has been failing rather than a state reported here.
-   */
   reconnectAttempt: number;
-  /**
-   * The server is asking this client to execute a tool call in its own sandbox.
-   * Answer with {@link SessionHandle.sendToolCallResult} or
-   * {@link SessionHandle.sendToolCallError}, echoing the same `executionId`.
-   * Ignoring it is safe: the server fails the execution at `expiresAt`.
-   */
   toolCallRequest: ToolCallRequestFrame;
-  /** A bridged call no longer needs an answer (turn interrupted, timed out, or
-   * the session closed) — abandon any work in progress for this executionId. */
   toolCallCanceled: {
     executionId: string;
     reason: string;
   };
 };
-type Listener<T> = (payload: T) => void;
 declare class SessionHandle {
   #private;
   readonly sessionId: string;
   constructor(client: WorkerDeckClient, sessionId: string, options?: AttachOptions);
   get lastSeq(): number;
   on<K extends keyof SessionHandleEvents>(kind: K, listener: Listener<SessionHandleEvents[K]>): () => void;
-  /** Send a message, optionally naming attachments uploaded ahead of it with
-   * {@link WorkerDeckClient.uploadAttachment} (ids in the order they should reach
-   * the model). An unknown id fails the whole command — the server will not send a
-   * message that quietly lost its picture. */
   send(text: string, attachmentIds?: string[]): void;
   approve(requestId: string, updatedInput?: Record<string, unknown>): void;
   deny(requestId: string, message?: string, interrupt?: boolean): void;
   interrupt(): void;
-  /**
-   * Reset the conversation in place: same session, empty context. The server
-   * answers with a `conversation_reset` event.
-   *
-   * Gate the affordance on `EngineCapabilities.clearContext` (absent = false)
-   * rather than calling this blindly — an engine or a server that cannot do it
-   * answers with an error frame, which is the wrong way for a user to find out.
-   */
   clearContext(): void;
   setPermissionMode(mode: PermissionMode): void;
-  /** Switch the model for subsequent responses; omit `model` for the default. */
   setModel(model?: string): void;
-  /** Answer a bridged tool call (see the `toolCallRequest` event). */
   sendToolCallResult(executionId: string, output: ToolExecutionOutput, logs?: string[]): void;
-  /** Report that a bridged tool call could not be executed. The failure is fed
-   * to the model as tool output, so the agent can adapt rather than stall. */
   sendToolCallError(executionId: string, reason: string, error: string, logs?: string[]): void;
-  /** Ask the server to terminate the session (the handle disconnects too). */
   closeSession(): void;
-  /** Skip the reconnect backoff and try again now — what a tab returning to the
-   * foreground should do, rather than sitting out the remaining delay. No-op
-   * while connected or after {@link SessionHandle.detach}. */
   reconnectNow(): void;
-  /** Disconnect this handle without touching the session. */
   detach(): void;
 }
+//#endregion
+//#region src/queue-handle.d.ts
 type QueueHandleEvents = {
-  /** Fired on every (re)attach with the server's current stats. */attached: QueueStats; /** Every job lifecycle/progress event, live. */
-  event: JobEvent; /** Refreshed stats pushed after job lifecycle changes. */
-  stats: QueueStats; /** WS connectivity: true on open, false on close. */
+  attached: QueueStats;
+  event: JobEvent;
+  stats: QueueStats;
   connectionChange: boolean;
 };
-/**
- * Live view of the server's job queue over `{basePath}/queue/ws`. The stream is
- * read-only — submit/cancel stay on the REST methods. There is no replay: on
- * (re)connect, re-list jobs and treat the stream as updates from there.
- */
 declare class QueueHandle {
   #private;
   constructor(client: WorkerDeckClient, options?: {
@@ -205,203 +57,86 @@ declare class QueueHandle {
   on<K extends keyof QueueHandleEvents>(kind: K, listener: Listener<QueueHandleEvents[K]>): () => void;
   detach(): void;
 }
+//#endregion
+//#region src/host-url.d.ts
+type HostUrl = {
+  baseUrl: string;
+};
+declare function apiUrl(host: HostUrl): string | undefined;
+declare function isLoopbackHost(host: HostUrl): boolean;
+//#endregion
+//#region src/host-auth.d.ts
+declare function hostAuth(options: {
+  baseUrl: string;
+  key: string;
+}): Pick<ClientOptions, 'headers' | 'buildWsUrl' | 'buildQueueWsUrl'>;
+//#endregion
+//#region src/index.d.ts
+type FetchBody = NonNullable<NonNullable<Parameters<typeof fetch>[1]>['body']>;
+type ClientOptions = {
+  baseUrl: string;
+  headers?: Record<string, string>;
+  buildWsUrl?: (sessionId: string, afterSeq: number, truncateResults?: boolean, imageRefs?: boolean) => string;
+  buildQueueWsUrl?: () => string;
+  WebSocketImpl?: typeof WebSocket;
+  fetchImpl?: typeof fetch;
+};
+declare class WorkerDeckError extends Error {
+  readonly status: number;
+  constructor(message: string, status: number);
+}
 declare class WorkerDeckClient {
   #private;
   constructor(options: ClientOptions);
-  /**
-   * Stable identity of the (gateway, principal) pair this client speaks as:
-   * the base URL plus the auth headers it sends, order-insensitively.
-   *
-   * Exists for client-side caches that must survive the client *instance*
-   * being rebuilt (a `useMemo` recreating it when a view switches gateways)
-   * without ever sharing an entry across gateways — a session id is unique
-   * only within one — or across credentials. Auth that rides outside
-   * `headers` (a same-origin cookie, a fetch shim adding the key host-side)
-   * is chosen per origin in every such host, so the base URL still separates
-   * principals there; an embedder whose principal varies some other way on
-   * one base URL should not key anything on this.
-   */
   get identityKey(): string;
   createSession(request: CreateSessionRequest): Promise<SessionInfo>;
   listSessions(): Promise<SessionInfo[]>;
   getSession(id: string): Promise<SessionInfo>;
-  /** Rename a session (or clear the name with `null`, restoring the derived
-   * title). 409 when the session is parked. */
   updateSession(id: string, patch: UpdateSessionRequest): Promise<SessionInfo>;
   deleteSession(id: string): Promise<SessionInfo>;
-  /** List the files currently in a session's scratch filesystem (deliverables the
-   * agent wrote; see the `file_delivered` event). 404s when the session's engine
-   * has no file store (Claude-engine sessions). */
   listSessionFiles(sessionId: string): Promise<SessionFileInfo[]>;
-  /** Download one session file as text. */
   fetchSessionFile(sessionId: string, path: string): Promise<string>;
-  /**
-   * Upload one file for the session, ahead of the message that will carry it.
-   * The returned `id` goes to {@link SessionHandle.send}.
-   *
-   * The body is the raw bytes — no multipart — so anything `fetch` accepts as a
-   * body works: a `File`/`Blob` from a picker, a `Uint8Array`, a string.
-   */
   uploadAttachment(sessionId: string, file: {
     name: string;
     mediaType: string;
     data: FetchBody;
   }): Promise<MessageAttachment>;
-  /** Direct URL for an uploaded attachment — an `<img src>` on a cookie-authenticated
-   * same-origin server. Header-authenticated clients must fetch it themselves. */
   attachmentUrl(sessionId: string, attachmentId: string): string;
-  /**
-   * Direct URL for a file the session's ENGINE produced on the host — the
-   * `fileId` of a `file_produced` event. Same caveat as `attachmentUrl`: usable
-   * as an `<img src>` only where the credential is a same-origin cookie; a
-   * header-authenticated client (the phone) fetches it and makes its own blob.
-   *
-   * Unlike `/fs/read`, this needs no host-file roots and no raised byte cap —
-   * see the `file_produced` note in the protocol for why that is sound.
-   */
   producedFileUrl(sessionId: string, fileId: string): string;
-  /** Fetch a produced file's bytes. For clients that cannot put a credential on
-   * an `<img src>`. Throws {@link WorkerDeckError} with the response status —
-   * a 404 means the file is gone from disk, not that the route is missing. */
   readProducedFile(sessionId: string, fileId: string): Promise<Blob>;
-  /**
-   * The URL behind a `ProjectIcon.image`. Session-scoped, like
-   * {@link producedFileUrl}: the fetch rides the same `canSee` gate as every
-   * other `/sessions/:id/*` route, and it takes **no path** — the gateway
-   * serves whatever its own discovery resolved for this session's cwd.
-   */
   projectIconUrl(sessionId: string): string;
-  /**
-   * Fetch a project icon's bytes.
-   *
-   * Here rather than left to each client for the reason `readProducedFile`
-   * exists, plus one this route makes sharper: a VS Code webview has **no
-   * external `connect-src` at all**, so it cannot point an `<img src>` at a
-   * gateway even in principle — the bytes have to come back through a bridged
-   * fetch, which is exactly what this wraps. Three clients building the same
-   * URL from `baseUrl` was the other half of the argument.
-   *
-   * Cache the result by `ProjectIcon.image.hash`, never by session: two
-   * sessions in one project serve identical bytes, and the hash is on the wire
-   * precisely so a client fetches once per project.
-   *
-   * A 404 is the uniform "no icon" — no project, a glyph-only project, or an
-   * icon the gateway refused. It is deliberately not distinguishable, so treat
-   * it as "draw no image", never as an error worth reporting.
-   */
   projectIcon(sessionId: string): Promise<Blob>;
-  /** The session's MCP servers and their tools, live from the engine. 501 when the
-   * session's engine has no MCP surface; 409 while the session is parked. */
   listMcpServers(sessionId: string): Promise<McpServerStatusInfo[]>;
-  /** Reconnect, enable or disable one MCP server; answers with the refreshed list. */
   mcpServerAction(sessionId: string, serverName: string, action: McpServerActionRequest['action']): Promise<McpServerStatusInfo[]>;
-  /** Direct download URL for a session file (e.g. an <a download> href). Carries
-   * no headers — on authenticated servers, use fetchSessionFile instead. */
   sessionFileUrl(sessionId: string, path: string): string;
-  /** Resolve a pending permission over REST — the remote-controller counterpart of the
-   * WS `permission_decision` command (e.g. answering a job's AskUserQuestion from a
-   * webhook consumer; the request rides on job_progress deliveries). Throws if the
-   * request is unknown, already resolved, or expired. */
   resolvePermission(sessionId: string, requestId: string, decision: ResolvePermissionRequest): Promise<void>;
-  /**
-   * Deliver the result of a deferred tool execution — the callback a remote
-   * worker (or a human) makes when the work a session parked on is done. The
-   * session is rehydrated if its runner was torn down, and the agent loop
-   * continues with this as the tool's output.
-   *
-   * Applied idempotently by `executionId`: a duplicate, or one racing the
-   * execution watchdog, resolves with `applied: false` instead of applying twice.
-   * Throws (404) when no session is waiting on that id.
-   */
   submitExecutionResult(executionId: string, result: SubmitExecutionResultRequest): Promise<SubmitExecutionResultResponse>;
-  /** List the profiles (named Claude Code config dirs) this server declares, filtered
-   * to what the caller may use. Feed a result's `name` to createSession({ profile }).
-   * Servers predating profiles 404 here — catch and treat as none declared. */
-  /** The profiles this caller may use, plus whether it may create new ones.
-   * Each profile carries `managed: true` when it is store-backed and therefore
-   * editable; profiles declared in server options are not. */
   listProfiles(): Promise<ListProfilesResponse>;
-  /** One profile plus a fresh, view-only snapshot of its config directory (settings,
-   * skills, agents, commands — env var names only, never values). */
   getProfile(name: string): Promise<GetProfileResponse>;
-  /**
-   * Create a managed profile. Requires a server with a profile store and a
-   * principal allowed to manage profiles; 409 if the name is already taken by a
-   * managed or a startup-declared profile.
-   */
   createProfile(profile: CreateProfileRequest): Promise<ProfileInfo>;
-  /** Merge into a managed profile. The name is the route: profiles cannot be
-   * renamed, since sessions and jobs are already pinned to the old one. */
   updateProfile(name: string, patch: UpdateProfileRequest): Promise<ProfileInfo>;
-  /** Delete a managed profile. Startup-declared profiles are refused (403) —
-   * they live in the server's options. */
   deleteProfile(name: string): Promise<void>;
-  /** List an engine's on-disk sessions (for resume across server restarts).
-   * Feed a result's `sessionId` to createSession({ resume }) — under a profile
-   * of the same engine. `profile` names whose store to list (claude profiles →
-   * the Agent SDK store, codex profiles → CODEX_HOME threads); absent, the
-   * server resolves it implicitly when it declares exactly one profile, else
-   * lists the Claude engine's store. */
   listSdkSessions(params?: {
     dir?: string;
     limit?: number;
     offset?: number;
     profile?: string;
   }): Promise<SdkSessionSummary[]>;
-  /**
-   * The host directories this server will let a client browse, and whether it
-   * accepts writes. Servers without host-file access configured 404 here — catch
-   * and treat as "no file browser", the same way `listProfiles` handles an older
-   * server.
-   *
-   * These are operator-privileged routes: the auth key is the whole authorization
-   * story, and they bypass the agent permission flow entirely. See the protocol
-   * package's `HostFileRoot` for why that framing is deliberate.
-   */
   listHostRoots(): Promise<ListHostRootsResponse>;
-  /** One host directory, not recursive. Symlinks are reported as symlinks, never
-   * followed here — read one to find out whether it resolves somewhere allowed. */
   listHostDir(path: string): Promise<ListHostDirResponse>;
-  /** Recursive fuzzy file search under one host directory — the `@file` picker's
-   * query. Cheap enough to call per keystroke: build directories are skipped and
-   * the walk is bounded, truncating rather than erroring. */
   findHostFiles(path: string, query?: string, limit?: number): Promise<FindHostFilesResponse>;
-  /** Read one host file. Binary content comes back base64-encoded; the returned
-   * `hash` is what a later `writeHostFile` needs as its `expectedHash`. */
   readHostFile(path: string): Promise<ReadHostFileResponse>;
-  /**
-   * Write one host file, conditionally — always. Pass the `hash` from the read this
-   * edit is based on; a 409 means the agent (or anything else) changed the file
-   * underneath you, and the edit must be rebased rather than forced. Omit
-   * `expectedHash` only to create a file that does not exist yet.
-   */
   writeHostFile(request: WriteHostFileRequest): Promise<WriteHostFileResponse>;
-  /** Schedule a one-shot run. The returned job's `sessionId` (once running) can be
-   * fed to `attach()` to watch the run live. */
   createJob(request: CreateJobRequest): Promise<JobInfo>;
   listJobs(): Promise<JobInfo[]>;
   getJob(id: string): Promise<JobInfo>;
-  /** Cancel a queued or running job. */
   cancelJob(id: string): Promise<JobInfo>;
   queueStats(): Promise<QueueStats>;
   attach(sessionId: string, options?: AttachOptions): SessionHandle;
-  /** Stream the job queue live (requires the server to be configured with `queue`).
-   * Servers without a queue refuse the socket — check REST first or expect retries. */
   attachQueue(options?: {
     reconnect?: boolean;
   }): QueueHandle;
-  /** @internal used by SessionHandle */
   openSocket(sessionId: string, afterSeq: number, truncateResults?: boolean, imageRefs?: boolean): WebSocket;
-  /**
-   * The whole of a tool result whose replay delivered only its head.
-   *
-   * `toolUseId` is required and the gateway verifies it against the block: a
-   * woken dormant session has a fresh log with fresh seqs, so a `sourceSeq`
-   * cached across a gateway restart can name a different event, and being handed
-   * another tool's output under the row you pressed is the exact failure this
-   * feature exists to remove. A 404 here means "ask again with a fresh attach",
-   * not "empty".
-   */
   toolResult(sessionId: string, seq: number, toolUseId: string, options?: {
     imageRefs?: boolean;
   }): Promise<{
@@ -410,27 +145,9 @@ declare class WorkerDeckClient {
     content: ToolResultBlock['content'];
     isError: boolean;
   }>;
-  /**
-   * One image part's bytes, addressed by the `image_ref` a replay delivered in
-   * its place.
-   *
-   * A `Blob` and not a URL, and that is the whole reason this method exists: an
-   * `<img src>` pointing at the gateway carries a credential in exactly one of
-   * this project's four clients (the dashboard's same-origin implicit host,
-   * where the cookie rides along). Everywhere else — an added cross-origin
-   * gateway on a Bearer header, the VS Code webview whose every byte crosses a
-   * postMessage bridge, iOS — the URL is unauthenticated and the picture is a
-   * broken icon. Fetched rather than pointed at, then handed to
-   * `URL.createObjectURL`; `readProducedFile` is the shipped precedent.
-   *
-   * A 404 means "ask again with a fresh attach": a woken dormant session has a
-   * fresh log with fresh seqs, and the gateway refuses a stale address rather
-   * than serving another call's pixels under the row you are looking at.
-   */
   toolResultImage(sessionId: string, seq: number, toolUseId: string, partIndex: number): Promise<Blob>;
-  /** @internal used by QueueHandle */
   openQueueSocket(): WebSocket;
 }
 //#endregion
-export { AttachOptions, ClientOptions, FetchBody, type HostUrl, QueueHandle, QueueHandleEvents, SessionHandle, SessionHandleEvents, WorkerDeckClient, WorkerDeckError, apiUrl, hostAuth, isLoopbackHost };
+export { type AttachOptions, ClientOptions, FetchBody, type HostUrl, QueueHandle, type QueueHandleEvents, SessionHandle, type SessionHandleEvents, WorkerDeckClient, WorkerDeckError, apiUrl, hostAuth, isLoopbackHost };
 //# sourceMappingURL=index.d.mts.map