@getorrery/client 0.0.0-stage → 0.2.2

package/dist/node.js

@@ -0,0 +1,175 @@
+import {
+  AGUI_PROTOCOL_VERSION,
+  ANIM,
+  AguiSession,
+  CONSENT_REQUEST,
+  CONSENT_RESOLVED,
+  ControlError,
+  DETACHED_TURN,
+  FrameHub,
+  HttpSseTransport,
+  MAX_FILE_BYTES,
+  MAX_MESSAGE_BYTES,
+  MOVED,
+  NOTICES,
+  OUT_OF_ORDER,
+  PLACED,
+  SCENARIO_COUNT,
+  SESSION_CHANGES,
+  STATE_CHANGED,
+  SurfaceStore,
+  TURN_CANCELLED,
+  UNPLACED,
+  USER_MESSAGE,
+  WORKSPACE_COMMIT,
+  WORKSPACE_PUSH,
+  WORKSPACE_READ,
+  WORKSPACE_READ_CAP_BYTES,
+  WebSocketTransport,
+  afterOf,
+  checkpoints,
+  choosingLine,
+  filePart,
+  firstSeq,
+  formatAddress,
+  frameOf,
+  framesOf,
+  framesOf2,
+  keptTranscript,
+  movedOf,
+  parse,
+  parseAddress,
+  parseAnim,
+  parseEndpoint,
+  readKept,
+  replay,
+  resumeFrom,
+  sse,
+  thoughtMs,
+  workspaceCommit,
+  workspaceErrorCode,
+  workspacePush,
+  workspaceRead,
+  workspaceRequest
+} from "./chunk-RQUTHT7N.js";
+import {
+  CloudEventsError,
+  SseParser,
+  __export,
+  backoffMs,
+  cloudEventOf,
+  cloudEvents
+} from "./chunk-P3UGNLD6.js";
+
+// src/channel.ts
+import net from "node:net";
+import { CLIENT_PROTOCOL, connect } from "@getorrery/ext";
+function pipePath(endpoint, platform = process.platform) {
+  if (!endpoint.startsWith("pipe:")) return void 0;
+  const name = endpoint.slice("pipe:".length);
+  return platform === "win32" && !name.startsWith("\\\\") ? `\\\\.\\pipe\\${name}` : name;
+}
+async function connectClient(options = {}) {
+  const endpoint = (options.env ?? process.env)["ORRERY_ENDPOINT"] ?? "";
+  const path = options.input && options.output ? void 0 : pipePath(endpoint);
+  if (path !== void 0) {
+    const socket = net.createConnection(path);
+    await new Promise((resolve, reject) => {
+      socket.once("connect", resolve);
+      socket.once("error", (e) => reject(new Error(`cannot reach the host at ${endpoint} (${e.message})`)));
+    });
+    options = { ...options, input: socket, output: socket };
+  }
+  const channel = await connect(options);
+  const raw = channel.frames.bind(channel);
+  channel.frames = async function* () {
+    for await (const f of raw()) {
+      const frame = frameOf(f);
+      if (frame) yield frame;
+    }
+  };
+  return channel;
+}
+
+// src/conformance-node.ts
+var conformance_node_exports = {};
+__export(conformance_node_exports, {
+  SCENARIO_COUNT: () => SCENARIO_COUNT,
+  checkpoints: () => checkpoints,
+  fixturesDir: () => fixturesDir,
+  framesOf: () => framesOf2,
+  load: () => load,
+  loadAll: () => loadAll,
+  parse: () => parse,
+  replay: () => replay
+});
+import { readFileSync, readdirSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+function fixturesDir() {
+  return join(dirname(fileURLToPath(import.meta.url)), "../../conformance");
+}
+function load(path) {
+  return parse(readFileSync(path, "utf8"), basename(path).replace(/\.jsonl$/, ""), path);
+}
+function loadAll(dir = fixturesDir()) {
+  return readdirSync(dir).filter((f) => f.endsWith(".jsonl")).sort().map((f) => load(join(dir, f)));
+}
+export {
+  AGUI_PROTOCOL_VERSION,
+  ANIM,
+  AguiSession,
+  CLIENT_PROTOCOL,
+  CONSENT_REQUEST,
+  CONSENT_RESOLVED,
+  CloudEventsError,
+  ControlError,
+  DETACHED_TURN,
+  FrameHub,
+  HttpSseTransport,
+  MAX_FILE_BYTES,
+  MAX_MESSAGE_BYTES,
+  MOVED,
+  NOTICES,
+  OUT_OF_ORDER,
+  PLACED,
+  SESSION_CHANGES,
+  STATE_CHANGED,
+  SseParser,
+  SurfaceStore,
+  TURN_CANCELLED,
+  UNPLACED,
+  USER_MESSAGE,
+  WORKSPACE_COMMIT,
+  WORKSPACE_PUSH,
+  WORKSPACE_READ,
+  WORKSPACE_READ_CAP_BYTES,
+  WebSocketTransport,
+  afterOf,
+  backoffMs,
+  choosingLine,
+  cloudEventOf,
+  cloudEvents,
+  conformance_node_exports as conformance,
+  connectClient,
+  filePart,
+  firstSeq,
+  formatAddress,
+  frameOf,
+  framesOf,
+  keptTranscript,
+  movedOf,
+  parseAddress,
+  parseAnim,
+  parseEndpoint,
+  pipePath,
+  readKept,
+  resumeFrom,
+  sse,
+  thoughtMs,
+  workspaceCommit,
+  workspaceErrorCode,
+  workspacePush,
+  workspaceRead,
+  workspaceRequest
+};

package/dist/session.d.ts

@@ -0,0 +1,210 @@
+/**
+ * `AguiSession`, the TypeScript half.
+ *
+ * The subscribe half is stock `@ag-ui/client`: `HttpAgent` runs the agent and
+ * emits AG-UI events, exactly as it would against any AG-UI server. That *is*
+ * the "existing AG-UI clients work unmodified" proof — if this file had to patch
+ * the agent, the claim would be false.
+ *
+ * The control half is a small `fetch` client, because AG-UI's input path is a
+ * run invocation and has no vocabulary for `session.attach(since)`,
+ * `turn.cancel`, `intent` or `query`.
+ */
+import { HttpAgent } from "@ag-ui/client";
+import type { ContentPart } from "@getorrery/protocol";
+import type { Frame } from "./events.js";
+import { type Transport } from "./transport.js";
+import { type WebSocketCtor } from "./transport-ws.js";
+export type { Request } from "./transport.js";
+export type { ContentPart } from "@getorrery/protocol";
+/**
+ * A file as an AG-UI content part (harness decision 0050): an `image` part
+ * for `image/*`, a `document` otherwise, its bytes inline as base64 and its
+ * name in `metadata.filename`.
+ */
+export declare function filePart(name: string, mimeType: string, base64: string): ContentPart;
+/** The most one file may be, decoded (the kernel's `attach::MAX_FILE_BYTES`). */
+export declare const MAX_FILE_BYTES: number;
+/** The most one message's files may be together, decoded. */
+export declare const MAX_MESSAGE_BYTES: number;
+/** One of the four ways to reach a kernel. */
+export type Endpoint = {
+    kind: "inproc";
+} | {
+    kind: "pipe";
+    name: string;
+} | {
+    kind: "http";
+    url: string;
+    token?: string;
+} | {
+    kind: "ws";
+    url: string;
+    token?: string;
+};
+/**
+ * Parse an endpoint string.
+ *
+ * The token rides the authority rather than a query parameter because a query
+ * string ends up in logs, in shell history and in `ps` output, and a bearer
+ * token is the whole of phase 1's auth story.
+ */
+export declare function parseEndpoint(raw: string): Endpoint;
+/** The CUSTOM frame a watched key's change arrives as (decision 0016). */
+export declare const STATE_CHANGED = "orrery.state.changed";
+/**
+ * The CUSTOM frame a node closes its clients with when their session moved
+ * to another machine (platform decision 0014 §8). Re-attach to `session` on
+ * `machine`; the epoch is the new one (decision 0013 §6).
+ */
+export declare const MOVED = "orrery.moved";
+/** What an `orrery.moved` frame says. */
+export interface Moved {
+    session: string;
+    /** The machine it moved to: its id on the account. */
+    machine: string;
+    /** Its name, for a line. */
+    machine_name?: string;
+    epoch?: number;
+    /** The client that asked. */
+    by?: string;
+    /** Unix seconds. */
+    at?: number;
+}
+/** The move a frame announces, or `null` when it is not `orrery.moved`. */
+export declare function movedOf(frame: Frame): Moved | null;
+/** `session.handoff`'s options: the untracked files, and a running turn. */
+export interface HandoffOptions {
+    untracked?: "include" | "skip";
+    turn?: "wait" | "cancel";
+}
+/** Options for [`AguiSession.connect`] beyond the endpoint. */
+export interface SessionConnectOptions {
+    /** The `WebSocket` implementation for a `ws://` endpoint (the global one when absent). */
+    WebSocket?: WebSocketCtor;
+    /** Bearer token for a `ws://` endpoint with none in its authority (sent in the Hello). */
+    token?: string;
+}
+/**
+ * A connected session, over any [`Transport`].
+ *
+ * `AguiSession.connect("http://…")` is the HTTP + SSE transport it always was;
+ * `ws://…` is the WebSocket transport; [`AguiSession.over`] takes any other.
+ * Drawing code holds an `AguiSession` and never learns which.
+ */
+export declare class AguiSession {
+    readonly transport: Transport;
+    private session;
+    private agent;
+    private lastSeq;
+    private declared;
+    private machine;
+    private ownConn;
+    /** Watch id → callback, for `orrery.state.changed` frames (decision 0016). */
+    private readonly watchers;
+    private constructor();
+    /** Connect to an endpoint: `http(s)://` or `ws(s)://`. */
+    static connect(endpoint: Endpoint | string, options?: SessionConnectOptions): AguiSession;
+    /** A session over a transport this SDK did not build. */
+    static over(transport: Transport): AguiSession;
+    /** The stock `@ag-ui/client` agent, unmodified, for anyone who wants it. HTTP only. */
+    httpAgent(): HttpAgent;
+    /**
+     * This client's connection (harness decision 0058), from the last `events()`
+     * ack: a surface whose `requester.conn` is another is somebody else's
+     * question ([`choosingLine`]). `0` until then, and for a server too old to say.
+     */
+    get conn(): number;
+    /** The last `seq` this session has seen. */
+    seq(): number | null;
+    /** The session attached to, as `[machine/]session`. */
+    address(): string | null;
+    /**
+     * Say what this client is and what it draws, so the host knows whether it
+     * can answer consent (decision 0041 §2). An HTTP client has no manifest;
+     * this is its `client/attach`, sent with `events()`. Without it the host
+     * counts the client as unable to answer.
+     */
+    declare(client: string, draws: readonly string[]): void;
+    /**
+     * Attach to a session, `[machine/]session`, optionally replaying from where
+     * this client left off.
+     *
+     * Over HTTP this is the `session.attach` request it always was. Over a
+     * transport whose `Hello` names the session (the WebSocket), the address is
+     * remembered and travels in the next `events()`'s `Hello`, as on the pipe.
+     */
+    attach(address: string, since?: number): Promise<void>;
+    /**
+     * Submit a turn. Resolves with the turn's id from the server's answer
+     * (the HTTP body, or the WebSocket `reply` value), and `null` when the
+     * answer carries none.
+     *
+     * `parts` are files, as AG-UI 1.0 content parts (harness decision 0050):
+     * the kernel puts each into the turn's context, or the turn says why not.
+     * [`filePart`] makes one from a file's bytes.
+     */
+    submit(text: string, parts?: readonly ContentPart[]): Promise<string | null>;
+    /** Cancel a turn in flight. */
+    cancel(turn: string): Promise<void>;
+    /** Answer a consent prompt. */
+    answer(prompt: string, answer: string): Promise<void>;
+    /**
+     * Send what a surface produced.
+     *
+     * The whole of a client's write path. A client edit arrives here, as an intent
+     * the kernel validates, never as a state mutation.
+     */
+    intent(surface: string, value: unknown): Promise<void>;
+    /**
+     * An action on a node of the UI document: a list item chosen, a button
+     * pressed (decision 0002).
+     */
+    uiIntent(node: string, action: string, value: unknown): Promise<void>;
+    /**
+     * The context API's `watch(ext, key, onChange)` (decision 0016), the same
+     * call an extension makes in any runtime: `onChange` gets the key's value
+     * now, then every change, picked out of the `events()` stream. Resolves to
+     * `stop()`. Rejects, naming the key, when it does not exist or is private.
+     * Works over HTTP and WebSocket: both answer requests, and changes arrive
+     * as `orrery.state.changed` frames.
+     */
+    watch(ext: string, key: string, onChange: (value: unknown) => void): Promise<() => Promise<void>>;
+    /** Hand a frame's `orrery.state.changed` to the watch it names. */
+    private dispatch;
+    /**
+     * Move this session to another machine of the account (platform decision
+     * 0014): `to` is its name or id. The move runs as the session's `/handoff`
+     * flow, so its steps arrive as frames; the node then sends `orrery.moved`
+     * ([`movedOf`]). Needs the `handoff` client grant.
+     */
+    handoff(to: string, options?: HandoffOptions): Promise<unknown>;
+    /** Run a command the host owns: `/model`, `/providers`, `/help`. */
+    command(name: string, args?: unknown): Promise<void>;
+    /**
+     * Every frame of the session, from now (or from `since`) on: the transport's
+     * `Hello`, then its frames.
+     *
+     * The passive half: a client that subscribes here sees every run — its own
+     * and anybody else's — and the screen the host declares, which the kernel
+     * re-sends on every subscription. `run` only ever sees the run it started.
+     */
+    events(since?: number): AsyncGenerator<Frame>;
+    /** `events()` from where this session left off: what a renderer's `frames()` wants. */
+    frames(): AsyncIterable<Frame>;
+    /**
+     * Start a run and yield its frames. HTTP only.
+     *
+     * `POST /run` with a `RunAgentInput`, parsed as SSE. `@ag-ui/client` would
+     * give the same events with its own subscriber API; this form exists because
+     * ours carry a `seq` the stock agent drops, and `seq` is the whole of the
+     * resumption story.
+     */
+    run(text: string): AsyncGenerator<Frame>;
+    /** Stop the stream. */
+    close(): Promise<void>;
+    private seen;
+    private http;
+    private requireSession;
+    private control;
+}

package/dist/store.d.ts

@@ -0,0 +1,277 @@
+/**
+ * `SurfaceStore`, the TypeScript half.
+ *
+ * The same projection as `clients/sdk-rs`, asserted against the same fixtures.
+ * Text deltas become a markdown surface and tool calls become a tool stack
+ * **here**, so no Ink component and no ratatui widget reimplements that — and
+ * if these two files ever disagree, the conformance suite says so before a user
+ * does.
+ *
+ * The store is a projection, never an authority. AG-UI's shared state is
+ * bidirectional by design and ours is not: an edit a person makes travels back
+ * as an `intent` the kernel validates.
+ */
+import type { AnimDef, SessionChanges, Status, SurfaceKind, UiDoc } from "@getorrery/protocol";
+import { type Frame } from "./events.js";
+/** The `Custom` name live file changes ride under (platform plan 07). */
+export declare const SESSION_CHANGES = "orrery.session.changes";
+/**
+ * The `Custom` name the person's message rides under (harness decision 0053):
+ * `{ id, role: "user", content, run_id, attachments, steer }`, one per prompt
+ * or steer any client sent, in history and on resume too.
+ */
+export declare const USER_MESSAGE = "orrery.user.message";
+/** The turn surfaces land in when replay picks up mid-turn. */
+export declare const DETACHED_TURN = "(detached)";
+/** A hole in the sequence. */
+export interface Gap {
+    expected: number;
+    got: number;
+}
+/**
+ * Who a flow's question belongs to (harness decision 0058 §5): the connection
+ * that sent the `command`, and what that client calls itself.
+ */
+export interface Requester {
+    conn: number;
+    client?: string;
+}
+/** One surface, as a client holds it. */
+export interface SurfaceView {
+    id: string;
+    status: Status | null;
+    kind: SurfaceKind;
+    /** Set on a flow's Question / Form: another connection's draws read-only. */
+    requester?: Requester;
+}
+/**
+ * The read-only line for a question another connection asked (decision 0058
+ * §5): `"<client> is choosing…"`, or `null` when it is this client's own (or
+ * nobody's). Takes a surface's `requester` or an overlay node's
+ * `props.requester` as it came off the wire.
+ */
+export declare function choosingLine(requester: unknown, ownConn: number): string | null;
+/** How a consent prompt was settled. */
+export interface Resolution {
+    answer: string;
+    by: string;
+}
+/** A consent prompt, and how it stands. */
+export interface PromptView {
+    id: string;
+    reason: string;
+    deadline_ms: number;
+    resolved: Resolution | null;
+}
+/** What went wrong in a turn. */
+export interface TurnError {
+    message: string;
+    code: string | null;
+}
+/**
+ * A turn's reasoning (decision 0005): drawn folded, as one line, until a
+ * person opens it. `ended_ms - started_ms` is the time spent thinking: the
+ * start moves forward past any gap between blocks, so a tool's time between
+ * two blocks is not counted.
+ */
+export interface ReasoningView {
+    text: string;
+    started_ms: number | null;
+    ended_ms: number | null;
+    /** `false` while it streams. */
+    complete: boolean;
+}
+/** How long it thought for, when the host said. */
+export declare function thoughtMs(r: ReasoningView): number | null;
+/** One turn: everything the kernel did about one input. */
+export interface TurnView {
+    id: string;
+    settled: boolean;
+    cancelled: boolean;
+    error: TurnError | null;
+    /** In insertion order, not sorted. */
+    surfaces: SurfaceView[];
+    prompts: PromptView[];
+    /** What the model thought before answering, when it said. */
+    reasoning?: ReasoningView;
+}
+/** The whole store, in the shape the conformance fixtures assert. */
+export interface StoreState {
+    last_seq: number | null;
+    live: string | null;
+    gaps: Gap[];
+    turns: TurnView[];
+    /** The UI document the host declared (decision 0002), once it has. */
+    ui?: UiDoc;
+    /** The animation definitions the host sent, by id (decision 0043). */
+    anims?: Record<string, AnimDef>;
+    /** The latest live-changes set (platform plan 07): `files` replaced, `clean` dropped. */
+    changes?: SessionChanges;
+}
+/**
+ * An extension's model call or agent, as its own segment (decision 0076 §3):
+ * opened by `SUBAGENT_STARTED`, closed by `SUBAGENT_FINISHED` / `_ERROR`. Its
+ * messages stay among the turn's surfaces; `surfaces` names them, so a drawing
+ * client groups them under `<ext> · <what>`.
+ */
+export interface SegmentView {
+    id: string;
+    /** The extension: `git` of `git.model`. */
+    ext: string;
+    /** `model` or `agent`: the rest of the name. */
+    what: string;
+    /** The prompt, shortened by the host. */
+    description: string;
+    /** The tool call that caused it, when one did. */
+    parentToolCallId: string | null;
+    /** The turn it ran in. */
+    turn: string;
+    /** Its messages' and calls' surface ids, in order. */
+    surfaces: string[];
+    status: "running" | "done" | "failed";
+    /** What `SUBAGENT_FINISHED` reported: the segment's usage. */
+    usage: unknown;
+    error: TurnError | null;
+}
+/** One extension notice (decision 0083 §2), as the `notices` toast node holds it. */
+export interface Notice {
+    id: string;
+    level: "info" | "warn" | "error";
+    text: string;
+    source: string;
+}
+/** One extension's status-line segment (decision 0083 §3). */
+export interface ExtStatus {
+    ext: string;
+    key: string;
+    text: string;
+}
+/** A key an extension bound to a command (decision 0083 §4): `ctrl+g` → `git.status`. */
+export interface KeyBinding {
+    key: string;
+    command: string;
+}
+/** The node the host's notices live in. */
+export declare const NOTICES = "notices";
+/** What changed, so a renderer can redraw a part rather than everything. */
+export type StoreChange = {
+    kind: "turn-started";
+    turn: string;
+} | {
+    kind: "turn-settled";
+    turn: string;
+} | {
+    kind: "surface-changed";
+    turn: string;
+    surface: string;
+} | {
+    kind: "surface-removed";
+    turn: string;
+    surface: string;
+}
+/** The turn's reasoning started, grew or ended. */
+ | {
+    kind: "reasoning-changed";
+    turn: string;
+} | {
+    kind: "prompt-raised";
+    prompt: string;
+} | {
+    kind: "prompt-resolved";
+    prompt: string;
+}
+/** The UI document changed; `path` is relative to `/ui`, `""` for all of it. */
+ | {
+    kind: "ui-changed";
+    path: string;
+}
+/** An animation definition arrived (or was replaced): draw by its id. */
+ | {
+    kind: "anim-changed";
+    id: string;
+}
+/** An extension segment opened, grew or closed. */
+ | {
+    kind: "segment-changed";
+    segment: string;
+}
+/** The session's live changes arrived: redraw the change list. */
+ | {
+    kind: "changes-updated";
+}
+/** A renderer's cue to re-attach with `since = <the last seq it saw>`. */
+ | {
+    kind: "gap-detected";
+    expected: number;
+    got: number;
+}
+/** An event this client has no handler for. Ignored, not rejected. */
+ | {
+    kind: "ignored";
+    what: string;
+};
+/** The projection itself. */
+export declare class SurfaceStore {
+    private data;
+    /** Kept beside the state, not in it: the fixtures assert the surfaces alone. */
+    private segs;
+    /** The whole state, as the conformance fixtures spell it. */
+    state(): StoreState;
+    /** One turn by run id. */
+    turn(id: string): TurnView | undefined;
+    /** Every settled turn, oldest first. What scrollback shows. */
+    settled(): TurnView[];
+    /** The turn in flight. What the live region shows. */
+    live(): TurnView | undefined;
+    /** The UI document, as the host last declared it. */
+    ui(): UiDoc | undefined;
+    /** Every extension segment, oldest first. */
+    segments(): SegmentView[];
+    /** The segment surface `id` belongs to, if any. */
+    segmentOf(id: string): SegmentView | undefined;
+    /** The host's notices, newest first (decision 0083 §2). */
+    notices(): Notice[];
+    /** The footer's extension segments, in the order first set (decision 0083 §3). */
+    extStatus(): ExtStatus[];
+    /** The keys bound on the input (decision 0083 §4). */
+    keys(): KeyBinding[];
+    /** Every gap detected so far. */
+    gaps(): Gap[];
+    /**
+     * Apply one frame. Never rejects: an unknown event is reported as `ignored`
+     * and still consumes its sequence number.
+     */
+    apply(frame: Frame): StoreChange[];
+    /**
+     * Account for a frame this build could not even parse.
+     *
+     * An event type from a newer kernel still occupies a sequence number, so
+     * skipping it silently would turn every forward-compatible addition into a
+     * phantom gap.
+     */
+    applyUnknown(seq: number, what: string): StoreChange[];
+    private note;
+    private applyEvent;
+    /** Note that surface `id` is part of segment `seg`. */
+    private join;
+    /** The turn new surfaces land in. */
+    private target;
+    /**
+     * The turn holding surface `id`: the one new surfaces land in when it is
+     * there, else the newest that has it, else the one it would land in. A
+     * surface id names one block in the thread (decision 0025): a later publish
+     * of it changes that block where it was drawn, whichever turn.
+     */
+    private holding;
+    private upsert;
+    /** Change the live turn's reasoning, opening it if this is the first. */
+    private reasoning;
+    private settle;
+    /** A snapshot's `ui` replaces the document whole. It touches no turn. */
+    private uiSnapshot;
+    /** One op under `/ui`, with the RFC 6902 rules. Session-wide. */
+    private uiPatch;
+    private snapshot;
+    private patch;
+    private custom;
+}

package/dist/transport-http.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The HTTP + SSE transport: what `orrery serve`'s HTTP listener speaks
+ * (`orrery-transport/src/listener/http.rs`).
+ *
+ * - The [`Hello`] becomes `GET /events?since=…&client=…&draws=…`, parsed as
+ *   SSE. HTTP has no first frame, so the [`HelloAck`] is the response status:
+ *   a 200 is an ack, anything else is the host's refusal, in its own words.
+ * - A [`Request`] is `POST /control`, and its JSON body is the answer.
+ *
+ * Browser-safe: `fetch`, `ReadableStream` and `TextDecoder` only.
+ */
+import { type Frame } from "./events.js";
+import { type CloseListener, type FrameListener, type Hello, type HelloAck, type Request, type Transport, type Unsubscribe } from "./transport.js";
+/** `http(s)://host:port`, plus an optional bearer token. */
+export interface HttpTransportOptions {
+    url: string;
+    token?: string;
+}
+export declare class HttpSseTransport implements Transport {
+    readonly kind = "http";
+    readonly url: string;
+    private readonly token;
+    private hub;
+    private abort;
+    /** The subscription's number from `GET /events` (decision 0058), sent back on every `POST /control`. */
+    private conn;
+    constructor(options: HttpTransportOptions);
+    /** The headers every request carries. */
+    headers(): Record<string, string>;
+    connect(hello: Hello): Promise<HelloAck>;
+    subscribe(onFrame: FrameListener, onClose?: CloseListener): Unsubscribe;
+    send(request: Request): Promise<unknown>;
+    close(): Promise<void>;
+    private pump;
+}
+/** An SSE body, as frames: every `data: ` line of every event block. */
+export declare function sse(body: ReadableStream<Uint8Array>): AsyncGenerator<Frame>;