@getorrery/client 0.0.0-stage → 0.2.1

package/dist/chunk-RQUTHT7N.js

@@ -0,0 +1,1551 @@
+import {
+  __export
+} from "./chunk-P3UGNLD6.js";
+
+// src/events.ts
+var CONSENT_REQUEST = "orrery.consent.request";
+var CONSENT_RESOLVED = "orrery.consent.resolved";
+var TURN_CANCELLED = "orrery.turn.cancelled";
+var PLACED = "orrery.placed";
+var UNPLACED = "orrery.unplaced";
+function frameOf(raw) {
+  if (typeof raw !== "object" || raw === null) return null;
+  const { metadata, ...event } = raw;
+  const out = { ...metadata?.orrery ?? {}, ...event };
+  return typeof out["seq"] === "number" ? out : null;
+}
+function firstSeq(frame) {
+  return frame.merged_from ?? frame.seq;
+}
+
+// src/anim.ts
+var ANIM = "orrery.ui.anim";
+var OUT_OF_ORDER = 0;
+function parseAnim(value) {
+  const def = value;
+  if (def === null || typeof def !== "object") throw new Error("anim: not an object");
+  const need = (field, ok) => {
+    if (!ok) throw new Error(`anim \`${String(def.id ?? "?")}\`: \`${field}\` is missing or the wrong type`);
+  };
+  need("id", typeof def.id === "string" && def.id !== "");
+  need("viewBox", Array.isArray(def.viewBox) && def.viewBox.length === 4);
+  need("template", typeof def.template === "string");
+  need("slots", Array.isArray(def.slots));
+  need("themes", typeof def.themes === "object" && def.themes !== null);
+  need("states", typeof def.states === "object" && def.states !== null);
+  const d = def;
+  const id = d.id;
+  if (Object.keys(d.themes).length === 0) {
+    throw new Error(`anim \`${id}\`: \`themes\` is empty; give it at least \`graphite\``);
+  }
+  for (const [state, spec] of Object.entries(d.states)) {
+    for (const [theme, t] of Object.entries(d.themes)) {
+      const frames = t.frames?.[state];
+      if (!frames) {
+        throw new Error(
+          `anim \`${id}\`: \`themes.${theme}.frames.${state}\` is missing; \`states.${state}\` needs its frames in every theme`
+        );
+      }
+      if (frames.length !== spec.frames) {
+        throw new Error(
+          `anim \`${id}\`: \`themes.${theme}.frames.${state}\` has ${frames.length} frames but \`states.${state}.frames\` says ${spec.frames}`
+        );
+      }
+      const at = frames.findIndex((f) => f.length !== d.slots.length);
+      if (at >= 0) {
+        throw new Error(
+          `anim \`${id}\`: \`themes.${theme}.frames.${state}[${at}]\` has ${frames[at].length} values but \`slots\` has ${d.slots.length}`
+        );
+      }
+    }
+    if (spec.loopFrom != null && spec.loopFrom >= spec.frames) {
+      throw new Error(`anim \`${id}\`: \`states.${state}.loopFrom\` is past its last frame`);
+    }
+  }
+  for (const m of d.template.matchAll(/\{\{([^}]*)\}\}/g)) {
+    const name = m[1];
+    const known = d.slots.includes(name) || Object.values(d.themes).every((t) => name in (t.statics ?? {})) || (d.sizes?.length ?? 0) > 0 && d.sizes.every((s) => name in s.statics);
+    if (!known) {
+      throw new Error(
+        `anim \`${id}\`: \`template\` names \`{{${name}}}\`, which is in no \`slots\`, theme \`statics\` or size \`statics\``
+      );
+    }
+  }
+  return d;
+}
+
+// src/store.ts
+import { EventType } from "@ag-ui/core";
+var SESSION_CHANGES = "orrery.session.changes";
+var USER_MESSAGE = "orrery.user.message";
+var DETACHED_TURN = "(detached)";
+var BLOCK_GAP = "\n\n";
+function choosingLine(requester, ownConn) {
+  const r = requester;
+  if (!r || typeof r.conn !== "number" || r.conn === ownConn) return null;
+  return `${typeof r.client === "string" && r.client ? r.client : "another client"} is choosing\u2026`;
+}
+function thoughtMs(r) {
+  if (r.started_ms === null || r.ended_ms === null) return null;
+  return Math.max(0, r.ended_ms - r.started_ms);
+}
+var NOTICES = "notices";
+function emptyState() {
+  return { last_seq: null, live: null, gaps: [], turns: [] };
+}
+function newTurn(id) {
+  return {
+    id,
+    settled: false,
+    cancelled: false,
+    error: null,
+    surfaces: [],
+    prompts: []
+  };
+}
+function unescape(token) {
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function splitPointer(path) {
+  if (!path.startsWith("/surfaces/")) return null;
+  const rest = path.slice("/surfaces/".length);
+  const parts = rest.split("/");
+  const id = unescape(parts[0] ?? "");
+  if (!id) return null;
+  return { id, rest: parts.slice(1).map(unescape) };
+}
+function outcomeStatus(outcome) {
+  const t = outcome?.t;
+  if (t === "ok" || t === "truncated") return "done";
+  if (t === "cancelled") return "cancelled";
+  if (t === void 0) return "done";
+  return "failed";
+}
+function outcomeSurface(outcome) {
+  const o = outcome;
+  return o?.surface;
+}
+var SurfaceStore = class {
+  data = emptyState();
+  /** Kept beside the state, not in it: the fixtures assert the surfaces alone. */
+  segs = /* @__PURE__ */ new Map();
+  /** The whole state, as the conformance fixtures spell it. */
+  state() {
+    return this.data;
+  }
+  /** One turn by run id. */
+  turn(id) {
+    return this.data.turns.find((t) => t.id === id);
+  }
+  /** Every settled turn, oldest first. What scrollback shows. */
+  settled() {
+    return this.data.turns.filter((t) => t.settled);
+  }
+  /** The turn in flight. What the live region shows. */
+  live() {
+    const id = this.data.live;
+    return id === null ? void 0 : this.turn(id);
+  }
+  /** The UI document, as the host last declared it. */
+  ui() {
+    return this.data.ui;
+  }
+  /** Every extension segment, oldest first. */
+  segments() {
+    return [...this.segs.values()];
+  }
+  /** The segment surface `id` belongs to, if any. */
+  segmentOf(id) {
+    for (const seg of this.segs.values()) if (seg.surfaces.includes(id)) return seg;
+    return void 0;
+  }
+  /** The host's notices, newest first (decision 0083 §2). */
+  notices() {
+    const n = this.data.ui?.nodes[NOTICES];
+    return Array.isArray(n?.props?.toasts) ? n.props.toasts : [];
+  }
+  /** The footer's extension segments, in the order first set (decision 0083 §3). */
+  extStatus() {
+    const f = Object.values(this.data.ui?.nodes ?? {}).find((n) => n.type === "footer");
+    return Array.isArray(f?.ext_status) ? f.ext_status : [];
+  }
+  /** The keys bound on the input (decision 0083 §4). */
+  keys() {
+    const i = Object.values(this.data.ui?.nodes ?? {}).find((n) => n.type === "input");
+    return Array.isArray(i?.keys) ? i.keys : [];
+  }
+  /** Every gap detected so far. */
+  gaps() {
+    return this.data.gaps;
+  }
+  /**
+   * Apply one frame. Never rejects: an unknown event is reported as `ignored`
+   * and still consumes its sequence number.
+   */
+  apply(frame) {
+    const changes = frame.seq === OUT_OF_ORDER ? [] : this.note(firstSeq(frame), frame.seq);
+    return changes.concat(this.applyEvent(frame));
+  }
+  /**
+   * 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, what) {
+    const changes = this.note(seq, seq);
+    changes.push({ kind: "ignored", what });
+    return changes;
+  }
+  note(first, seq) {
+    const changes = [];
+    const prev = this.data.last_seq;
+    if (prev !== null && first !== prev + 1) {
+      const gap = { expected: prev + 1, got: first };
+      this.data.gaps.push(gap);
+      changes.push({ kind: "gap-detected", ...gap });
+    }
+    this.data.last_seq = seq;
+    return changes;
+  }
+  applyEvent(event) {
+    switch (event.type) {
+      case EventType.RUN_STARTED: {
+        this.data.turns.push(newTurn(event.runId));
+        this.data.live = event.runId;
+        return [{ kind: "turn-started", turn: event.runId }];
+      }
+      case EventType.RUN_FINISHED:
+        return this.settle(null);
+      case EventType.RUN_ERROR:
+        return this.settle({
+          message: event.message,
+          code: event.code ?? null
+        });
+      case EventType.TEXT_MESSAGE_START:
+        this.join(event.subagentRunId, event.messageId);
+        return this.upsert(event.messageId, (s) => {
+          s.status = "running";
+          s.kind = { t: "markdown", value: "", complete: false };
+        });
+      case EventType.TEXT_MESSAGE_CONTENT:
+        return this.upsert(event.messageId, (s) => {
+          if (s.kind.t === "markdown") {
+            s.kind.value += event.delta;
+          } else {
+            s.kind = { t: "markdown", value: event.delta, complete: false };
+            s.status = "running";
+          }
+        });
+      case EventType.TEXT_MESSAGE_END:
+        return this.upsert(event.messageId, (s) => {
+          if (s.kind.t === "markdown") s.kind.complete = true;
+          s.status = "done";
+        });
+      case EventType.TOOL_CALL_START:
+        this.join(event.subagentRunId, event.toolCallId);
+        return this.upsert(event.toolCallId, (s) => {
+          s.status = "running";
+          s.kind = {
+            t: "stack",
+            dir: "column",
+            title: event.toolCallName,
+            collapsed: false,
+            children: [{ kind: { t: "text", value: "", style: "code" } }]
+          };
+        });
+      case EventType.TOOL_CALL_ARGS:
+        return this.upsert(event.toolCallId, (s) => {
+          if (s.kind.t !== "stack") return;
+          const first = s.kind.children?.[0];
+          if (first && first.kind.t === "text") first.kind.value += event.delta;
+        });
+      // The arguments are complete; the call is not. Nothing to draw yet.
+      case EventType.TOOL_CALL_END:
+        return [{ kind: "ignored", what: `TOOL_CALL_END:${event.toolCallId}` }];
+      case EventType.TOOL_CALL_RESULT: {
+        const status = outcomeStatus(event.outcome);
+        const result = outcomeSurface(event.outcome) ?? {
+          kind: { t: "text", value: event.content }
+        };
+        if (result.id !== void 0 && result.id !== null) {
+          const turn = this.holding(result.id);
+          turn.surfaces = turn.surfaces.filter((s) => s.id !== result.id);
+        }
+        return this.upsert(event.toolCallId, (s) => {
+          s.status = status;
+          if (s.kind.t === "stack") {
+            s.kind.children = [...s.kind.children ?? [], result];
+          }
+        });
+      }
+      case EventType.REASONING_START:
+        return this.reasoning((r) => {
+          const at = event.timestamp ?? null;
+          if (at !== null && r.started_ms !== null && r.ended_ms !== null) {
+            r.started_ms = Math.max(0, at - Math.max(0, r.ended_ms - r.started_ms));
+          } else if (r.started_ms === null) {
+            r.started_ms = at;
+          }
+          if (r.text !== "" && !r.text.endsWith(BLOCK_GAP)) r.text += BLOCK_GAP;
+          r.complete = false;
+        });
+      case EventType.REASONING_MESSAGE_START:
+      case EventType.REASONING_MESSAGE_END:
+        return [{ kind: "ignored", what: event.type }];
+      case EventType.REASONING_MESSAGE_CONTENT:
+        return this.reasoning((r) => {
+          r.text += event.delta;
+        });
+      case EventType.REASONING_END:
+        return this.reasoning((r) => {
+          r.ended_ms = event.timestamp ?? r.ended_ms ?? r.started_ms;
+          r.complete = true;
+        });
+      case EventType.STATE_SNAPSHOT: {
+        const changes = this.uiSnapshot(event.snapshot);
+        const hasSurfaces = event.snapshot?.surfaces !== void 0;
+        return hasSurfaces || changes.length === 0 ? [...changes, ...this.snapshot(event.snapshot)] : changes;
+      }
+      case EventType.STATE_DELTA:
+        return event.delta.flatMap(
+          (op) => uiRelative(op.path) !== void 0 ? this.uiPatch(op) : this.patch(op)
+        );
+      case EventType.CUSTOM:
+        return this.custom(event.name, event.value);
+      case EventType.SUBAGENT_STARTED: {
+        const dot = event.name.indexOf(".");
+        this.segs.set(event.subagentRunId, {
+          id: event.subagentRunId,
+          ext: dot >= 0 ? event.name.slice(0, dot) : event.name,
+          what: dot >= 0 ? event.name.slice(dot + 1) : "model",
+          description: event.description ?? "",
+          parentToolCallId: event.parentToolCallId ?? null,
+          turn: this.target().id,
+          surfaces: [],
+          status: "running",
+          usage: null,
+          error: null
+        });
+        return [{ kind: "segment-changed", segment: event.subagentRunId }];
+      }
+      case EventType.SUBAGENT_FINISHED:
+      case EventType.SUBAGENT_ERROR: {
+        const seg = this.segs.get(event.subagentRunId);
+        if (!seg) return [{ kind: "ignored", what: `${event.type}:${event.subagentRunId}` }];
+        if (event.type === EventType.SUBAGENT_ERROR) {
+          seg.status = "failed";
+          seg.error = { message: event.message, code: event.code ?? null };
+        } else {
+          seg.status = "done";
+          seg.usage = event.result ?? null;
+        }
+        return [{ kind: "segment-changed", segment: seg.id }];
+      }
+      default:
+        return [{ kind: "ignored", what: event.type }];
+    }
+  }
+  /** Note that surface `id` is part of segment `seg`. */
+  join(seg, id) {
+    const s = seg === void 0 ? void 0 : this.segs.get(seg);
+    if (s && !s.surfaces.includes(id)) s.surfaces.push(id);
+  }
+  /** The turn new surfaces land in. */
+  target() {
+    if (this.data.live !== null) {
+      const live = this.turn(this.data.live);
+      if (live) return live;
+    }
+    for (let i = this.data.turns.length - 1; i >= 0; i -= 1) {
+      const turn = this.data.turns[i];
+      if (!turn.settled) return turn;
+    }
+    const detached = newTurn(DETACHED_TURN);
+    this.data.turns.push(detached);
+    return detached;
+  }
+  /**
+   * 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.
+   */
+  holding(id) {
+    const target = this.target();
+    if (target.surfaces.some((s) => s.id === id)) return target;
+    for (let i = this.data.turns.length - 1; i >= 0; i -= 1) {
+      const turn = this.data.turns[i];
+      if (turn.surfaces.some((s) => s.id === id)) return turn;
+    }
+    return target;
+  }
+  upsert(id, edit) {
+    const turn = this.target();
+    let surface = turn.surfaces.find((s) => s.id === id);
+    if (!surface) {
+      surface = { id, status: null, kind: { t: "text", value: "" } };
+      turn.surfaces.push(surface);
+    }
+    edit(surface);
+    return [{ kind: "surface-changed", turn: turn.id, surface: id }];
+  }
+  /** Change the live turn's reasoning, opening it if this is the first. */
+  reasoning(edit) {
+    const turn = this.target();
+    turn.reasoning ??= { text: "", started_ms: null, ended_ms: null, complete: false };
+    edit(turn.reasoning);
+    return [{ kind: "reasoning-changed", turn: turn.id }];
+  }
+  settle(error) {
+    const turn = this.target();
+    turn.settled = true;
+    turn.error = error;
+    if (turn.reasoning && !turn.reasoning.complete) {
+      turn.reasoning.complete = true;
+      turn.reasoning.ended_ms ??= turn.reasoning.started_ms;
+    }
+    const closing = turn.cancelled ? "cancelled" : "done";
+    for (const surface of turn.surfaces) {
+      if (surface.status === "running") {
+        if (surface.kind.t === "markdown") surface.kind.complete = true;
+        surface.status = closing;
+      }
+    }
+    this.data.live = null;
+    return [{ kind: "turn-settled", turn: turn.id }];
+  }
+  /** A snapshot's `ui` replaces the document whole. It touches no turn. */
+  uiSnapshot(snapshot) {
+    const ui = snapshot?.ui;
+    if (ui === void 0) return [];
+    if (ui === null || typeof ui !== "object") {
+      return [{ kind: "ignored", what: "unreadable ui snapshot" }];
+    }
+    this.data.ui = structuredClone(ui);
+    return [{ kind: "ui-changed", path: "" }];
+  }
+  /** One op under `/ui`, with the RFC 6902 rules. Session-wide. */
+  uiPatch(op) {
+    const rel = uiRelative(op.path);
+    if (!this.data.ui) {
+      return [{ kind: "ignored", what: `ui patch before any ui snapshot: ${op.path}` }];
+    }
+    const why = jsonPatch(this.data.ui, op, rel);
+    if (why) return [{ kind: "ignored", what: `ui patch ${op.path}: ${why}` }];
+    return [{ kind: "ui-changed", path: rel }];
+  }
+  snapshot(snapshot) {
+    const surfaces = snapshot?.surfaces;
+    if (!surfaces) return [{ kind: "ignored", what: "STATE_SNAPSHOT" }];
+    const turn = this.target();
+    turn.surfaces = [];
+    const changes = [];
+    for (const [id, value] of Object.entries(surfaces)) {
+      turn.surfaces.push(surfaceFromJson(id, value));
+      changes.push({ kind: "surface-changed", turn: turn.id, surface: id });
+    }
+    return changes;
+  }
+  patch(op) {
+    const split = splitPointer(op.path);
+    if (!split) {
+      return [{ kind: "ignored", what: `patch outside /surfaces: ${op.path}` }];
+    }
+    const { id, rest } = split;
+    const turn = this.holding(id);
+    if (rest.length === 0) {
+      if (op.op === "remove") {
+        turn.surfaces = turn.surfaces.filter((s) => s.id !== id);
+        return [{ kind: "surface-removed", turn: turn.id, surface: id }];
+      }
+      const view = surfaceFromJson(id, op.value);
+      const at = turn.surfaces.findIndex((s) => s.id === id);
+      if (at >= 0) turn.surfaces[at] = view;
+      else turn.surfaces.push(view);
+      return [{ kind: "surface-changed", turn: turn.id, surface: id }];
+    }
+    const surface = turn.surfaces.find((s) => s.id === id);
+    if (!surface) {
+      return [{ kind: "ignored", what: `patch to an unknown surface ${id}` }];
+    }
+    const field = rest.join("/");
+    if (field === "kind/chunks" || field === "kind/chunks/-") {
+      if (op.op === "remove") return [];
+      if (op.op !== "add") return [{ kind: "ignored", what: `${op.op} on ${op.path}` }];
+      const text2 = Array.isArray(op.value) ? op.value.filter((v) => typeof v === "string").join("") : typeof op.value === "string" ? op.value : "";
+      const kind = surface.kind;
+      kind.value = (typeof kind.value === "string" ? kind.value : "") + text2;
+      return [{ kind: "surface-changed", turn: turn.id, surface: id }];
+    }
+    let slot = surface;
+    for (const segment of rest.slice(0, -1)) {
+      const next = slot[segment];
+      if (next === null || typeof next !== "object") {
+        return [{ kind: "ignored", what: `no such field ${op.path}` }];
+      }
+      slot = next;
+    }
+    const leaf = rest[rest.length - 1];
+    if (!(leaf in slot)) {
+      return [{ kind: "ignored", what: `no such field ${op.path}` }];
+    }
+    if (op.op === "remove") {
+      slot[leaf] = null;
+    } else {
+      slot[leaf] = op.value;
+    }
+    return [{ kind: "surface-changed", turn: turn.id, surface: id }];
+  }
+  custom(name, value) {
+    if (name === CONSENT_REQUEST) {
+      const prompt = promptFromJson(value);
+      if (!prompt) return [{ kind: "ignored", what: name }];
+      this.target().prompts.push(prompt);
+      return [{ kind: "prompt-raised", prompt: prompt.id }];
+    }
+    if (name === CONSENT_RESOLVED) {
+      const id = String(value["prompt_id"] ?? "");
+      const resolution = {
+        answer: String(value["answer"] ?? "deny"),
+        by: String(value["by"] ?? "fallback")
+      };
+      const existing = this.data.turns.flatMap((t) => t.prompts).find((p) => p.id === id);
+      if (existing) {
+        existing.resolved = resolution;
+      } else {
+        const prompt = promptFromJson(value) ?? {
+          id,
+          reason: "",
+          deadline_ms: 0,
+          resolved: null
+        };
+        prompt.resolved = resolution;
+        this.target().prompts.push(prompt);
+      }
+      return [{ kind: "prompt-resolved", prompt: id }];
+    }
+    if (name === ANIM) {
+      try {
+        const def = parseAnim(value);
+        (this.data.anims ??= {})[def.id] = structuredClone(def);
+        return [{ kind: "anim-changed", id: def.id }];
+      } catch (e) {
+        return [{ kind: "ignored", what: `${name}: ${e.message}` }];
+      }
+    }
+    if (name === SESSION_CHANGES) {
+      const v = value;
+      if (v === null || typeof v !== "object" || !Array.isArray(v.files) || !Array.isArray(v.changed) || v.totals == null) {
+        return [{ kind: "ignored", what: `${name}: not a change set` }];
+      }
+      const set = structuredClone(v);
+      set.files = set.files.filter((f) => f.kind !== "clean");
+      this.data.changes = set;
+      return [{ kind: "changes-updated" }];
+    }
+    if (name === TURN_CANCELLED) {
+      const turn = this.target();
+      turn.cancelled = true;
+      return [{ kind: "turn-settled", turn: turn.id }];
+    }
+    return [{ kind: "ignored", what: name }];
+  }
+};
+function surfaceFromJson(id, value) {
+  const raw = value ?? {};
+  return {
+    id,
+    status: raw.status ?? null,
+    kind: structuredClone(raw.kind ?? { t: "text", value: "" }),
+    ...raw.requester ? { requester: structuredClone(raw.requester) } : {}
+  };
+}
+function promptFromJson(value) {
+  const prompt = value["prompt"];
+  const id = prompt?.["id"];
+  if (typeof id !== "string") return null;
+  return {
+    id,
+    reason: typeof prompt?.["reason"] === "string" ? prompt["reason"] : "",
+    deadline_ms: typeof value["deadline_ms"] === "number" ? value["deadline_ms"] : 0,
+    resolved: null
+  };
+}
+function uiRelative(path) {
+  if (!path.startsWith("/ui")) return void 0;
+  const rest = path.slice(3);
+  return rest === "" || rest.startsWith("/") ? rest : void 0;
+}
+function jsonPatch(doc, op, rel) {
+  const tokens = rel.split("/").slice(1).map(unescape);
+  const last = tokens.pop();
+  if (last === void 0) return "cannot replace the whole document with a patch";
+  let parent = doc;
+  for (const token of tokens) {
+    if (Array.isArray(parent)) parent = parent[Number(token)];
+    else if (parent !== null && typeof parent === "object") {
+      parent = parent[token];
+    } else parent = void 0;
+    if (parent === void 0) return `no parent at ${tokens.join("/")}`;
+  }
+  if (Array.isArray(parent)) {
+    const at = last === "-" ? parent.length : Number(last);
+    if (!Number.isInteger(at)) return `bad index ${last}`;
+    if (op.op === "add") {
+      if (at > parent.length) return `index ${at} past the end`;
+      parent.splice(at, 0, structuredClone(op.value));
+    } else if (op.op === "replace") {
+      if (at >= parent.length) return `no element ${at}`;
+      parent[at] = structuredClone(op.value);
+    } else if (op.op === "remove") {
+      if (at >= parent.length) return `no element ${at}`;
+      parent.splice(at, 1);
+    }
+    return void 0;
+  }
+  if (parent === null || typeof parent !== "object") return "parent is not an object or an array";
+  const map = parent;
+  if (op.op === "add" || op.op === "replace") map[last] = structuredClone(op.value);
+  else {
+    if (!(last in map)) return `no key ${last}`;
+    delete map[last];
+  }
+  return void 0;
+}
+
+// src/transport.ts
+var AGUI_PROTOCOL_VERSION = "1.0";
+var ControlError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "ControlError";
+    this.code = code;
+  }
+};
+function framesOf(transport) {
+  return {
+    [Symbol.asyncIterator]() {
+      const queue = [];
+      let done = false;
+      let failure;
+      let wake;
+      const stop = transport.subscribe(
+        (raw) => {
+          const frame = frameOf(raw);
+          if (!frame) return;
+          queue.push(frame);
+          wake?.();
+        },
+        (error) => {
+          done = true;
+          failure = error;
+          wake?.();
+        }
+      );
+      return {
+        async next() {
+          for (; ; ) {
+            const frame = queue.shift();
+            if (frame !== void 0) return { value: frame, done: false };
+            if (failure) throw failure;
+            if (done) return { value: void 0, done: true };
+            await new Promise((r) => wake = r);
+            wake = void 0;
+          }
+        },
+        async return() {
+          stop();
+          done = true;
+          return { value: void 0, done: true };
+        }
+      };
+    }
+  };
+}
+var FrameHub = class {
+  frames = /* @__PURE__ */ new Set();
+  closes = /* @__PURE__ */ new Set();
+  pending = [];
+  ended = null;
+  subscribe(onFrame, onClose) {
+    this.frames.add(onFrame);
+    if (onClose) this.closes.add(onClose);
+    if (this.pending.length > 0) {
+      const held = this.pending;
+      this.pending = [];
+      for (const f of held) onFrame(f);
+    }
+    if (this.ended && onClose) onClose(this.ended.error);
+    return () => {
+      this.frames.delete(onFrame);
+      if (onClose) this.closes.delete(onClose);
+    };
+  }
+  push(frame) {
+    if (this.frames.size === 0) {
+      this.pending.push(frame);
+      return;
+    }
+    for (const f of [...this.frames]) f(frame);
+  }
+  end(error) {
+    if (this.ended) return;
+    this.ended = error ? { error } : {};
+    for (const c of [...this.closes]) c(error);
+  }
+  get isEnded() {
+    return this.ended !== null;
+  }
+};
+function parseAddress(raw) {
+  const text2 = raw.trim();
+  const parts = text2.split("/");
+  const ok = (s) => s !== void 0 && s !== "" && !/\s/.test(s);
+  if (parts.length === 1 && ok(parts[0])) return { machine: null, session: parts[0] };
+  if (parts.length === 2 && ok(parts[0]) && ok(parts[1])) return { machine: parts[0], session: parts[1] };
+  throw new Error(`\`${raw}\` is not a session address: expected \`session\` or \`machine/session\``);
+}
+function formatAddress(a) {
+  return a.machine ? `${a.machine}/${a.session}` : a.session;
+}
+
+// src/transport-http.ts
+var HttpSseTransport = class {
+  kind = "http";
+  url;
+  token;
+  hub = new FrameHub();
+  abort = null;
+  /** The subscription's number from `GET /events` (decision 0058), sent back on every `POST /control`. */
+  conn = null;
+  constructor(options) {
+    this.url = options.url.replace(/\/+$/, "");
+    this.token = options.token;
+  }
+  /** The headers every request carries. */
+  headers() {
+    return {
+      "content-type": "application/json",
+      ...this.token ? { Authorization: `Bearer ${this.token}` } : {},
+      // Without it a request is anonymous: it answers no question and no consent.
+      ...this.conn !== null ? { "x-orrery-conn": this.conn } : {}
+    };
+  }
+  async connect(hello) {
+    this.abort?.abort();
+    if (this.hub.isEnded || this.abort) this.hub = new FrameHub();
+    const abort = new AbortController();
+    this.abort = abort;
+    this.conn = null;
+    const params = new URLSearchParams();
+    if (hello.since !== void 0) params.set("since", String(hello.since));
+    if (hello.session !== void 0) params.set("session", hello.session);
+    if (hello.machine !== void 0) params.set("machine", hello.machine);
+    if (hello.client !== void 0) {
+      params.set("client", hello.client);
+      params.set("draws", (hello.draws ?? []).join(","));
+    }
+    const query = params.size > 0 ? `?${params.toString()}` : "";
+    const response = await fetch(`${this.url}/events${query}`, {
+      headers: this.headers(),
+      signal: abort.signal
+    });
+    if (!response.ok || !response.body) {
+      const why = response.ok ? "" : await response.text().catch(() => "");
+      throw new Error(`GET /events: ${response.status}${why ? ` ${why}` : ""}`);
+    }
+    this.conn = response.headers.get("x-orrery-conn");
+    const hub = this.hub;
+    void this.pump(response.body, hub, abort.signal);
+    const conn = Number(this.conn ?? NaN);
+    return { format: "json", protocol: AGUI_PROTOCOL_VERSION, ...Number.isInteger(conn) ? { conn } : {} };
+  }
+  subscribe(onFrame, onClose) {
+    return this.hub.subscribe(onFrame, onClose);
+  }
+  async send(request) {
+    const response = await fetch(`${this.url}/control`, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify(request)
+    });
+    if (!response.ok) {
+      throw new ControlError(
+        `POST /control: ${response.status} ${await response.text().catch(() => "")}`.trim(),
+        response.headers.get("x-orrery-code") ?? void 0
+      );
+    }
+    return response.json();
+  }
+  async close() {
+    this.abort?.abort();
+    this.abort = null;
+    this.hub.end();
+  }
+  async pump(body, hub, signal) {
+    try {
+      for await (const frame of sse(body)) {
+        if (signal.aborted) break;
+        hub.push(frame);
+      }
+      hub.end();
+    } catch (e) {
+      hub.end(signal.aborted ? void 0 : e instanceof Error ? e : new Error(String(e)));
+    }
+  }
+};
+async function* sse(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) return;
+    buffer += decoder.decode(value, { stream: true }).replace(/\r\n/g, "\n");
+    let at = buffer.indexOf("\n\n");
+    while (at >= 0) {
+      const block = buffer.slice(0, at);
+      buffer = buffer.slice(at + 2);
+      for (const line of block.split("\n")) {
+        if (!line.startsWith("data: ")) continue;
+        const frame = frameOf(JSON.parse(line.slice("data: ".length)));
+        if (frame) yield frame;
+      }
+      at = buffer.indexOf("\n\n");
+    }
+  }
+}
+
+// src/transport-ws.ts
+var OPEN = 1;
+var REPLY_TIMEOUT_MS = 3e4;
+function text(data) {
+  if (typeof data === "string") return data;
+  if (data instanceof ArrayBuffer) return new TextDecoder().decode(data);
+  if (ArrayBuffer.isView(data)) return new TextDecoder().decode(data);
+  if (Array.isArray(data)) return data.map((d) => text(d) ?? "").join("");
+  return null;
+}
+var WebSocketTransport = class {
+  kind = "ws";
+  url;
+  token;
+  Ctor;
+  socket = null;
+  hub = new FrameHub();
+  pending = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.url = options.url;
+    this.token = options.token;
+    const ctor = options.WebSocket ?? globalThis.WebSocket;
+    if (!ctor) {
+      throw new Error("no WebSocket here: pass one as `WebSocket` (in Node < 22, the `ws` package)");
+    }
+    this.Ctor = ctor;
+  }
+  connect(hello) {
+    if (this.socket) this.socket.close(1e3, "reconnect");
+    if (this.hub.isEnded || this.socket) this.hub = new FrameHub();
+    const hub = this.hub;
+    const socket = new this.Ctor(this.url);
+    socket.binaryType = "arraybuffer";
+    this.socket = socket;
+    const first = { ...hello, format: "json", ...this.token && hello.token === void 0 ? { token: this.token } : {} };
+    return new Promise((resolve, reject) => {
+      let acked = false;
+      socket.addEventListener("open", () => socket.send(JSON.stringify(first)));
+      socket.addEventListener("message", (event) => {
+        const body = text(event.data);
+        if (body === null) return;
+        let value;
+        try {
+          value = JSON.parse(body);
+        } catch {
+          if (!acked) {
+            acked = true;
+            reject(new Error(`ws ${this.url}: the first message is not a HelloAck: ${body.slice(0, 120)}`));
+            socket.close(1002, "bad handshake");
+          }
+          return;
+        }
+        if (!acked) {
+          acked = true;
+          const ack = value;
+          const no = ack.refused ?? ack.error;
+          if (typeof no === "string" || typeof ack.protocol !== "string") {
+            reject(new Error(`ws ${this.url}: refused: ${no ?? body.slice(0, 200)}`));
+            socket.close(1e3, "refused");
+            return;
+          }
+          resolve({ format: "json", ...ack });
+          return;
+        }
+        const reply = value;
+        if (typeof reply === "object" && reply !== null && reply.t === "reply") {
+          if (typeof reply.reqId !== "string") return;
+          const waiting = this.pending.get(reply.reqId);
+          if (!waiting) return;
+          this.pending.delete(reply.reqId);
+          clearTimeout(waiting.timer);
+          if (reply.ok === true) waiting.resolve(reply.value ?? null);
+          else
+            waiting.reject(
+              new ControlError(
+                typeof reply.error === "string" ? reply.error : "the server refused the request",
+                typeof reply.code === "string" ? reply.code : void 0
+              )
+            );
+          return;
+        }
+        const frame = frameOf(value);
+        if (frame) hub.push(frame);
+      });
+      socket.addEventListener("error", () => {
+        if (acked) return;
+        acked = true;
+        const why = new Error(
+          `ws ${this.url}: could not open the WebSocket (refused, unreachable, or a certificate this process does not trust)`
+        );
+        reject(why);
+        if (this.socket === socket) this.socket = null;
+        this.failPending(why);
+        hub.end(why);
+        try {
+          socket.close();
+        } catch {
+        }
+      });
+      socket.addEventListener("close", (event) => {
+        if (this.socket === socket) this.socket = null;
+        const clean = event.code === 1e3 || event.code === 1005;
+        const why = new Error(`ws ${this.url}: closed (${event.code}${event.reason ? ` ${event.reason}` : ""})`);
+        if (!acked) {
+          acked = true;
+          reject(new Error(`ws ${this.url}: closed before the HelloAck (${event.code}${event.reason ? ` ${event.reason}` : ""})`));
+        }
+        if (this.socket === null) this.failPending(why);
+        hub.end(clean ? void 0 : why);
+      });
+    });
+  }
+  subscribe(onFrame, onClose) {
+    return this.hub.subscribe(onFrame, onClose);
+  }
+  async send(request) {
+    const socket = this.socket;
+    if (!socket || socket.readyState !== OPEN) {
+      throw new Error(`ws ${this.url}: not connected; call connect() first`);
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(request.id);
+        reject(new Error(`ws ${this.url}: no reply to \`${request.t}\` in ${REPLY_TIMEOUT_MS / 1e3} s`));
+      }, REPLY_TIMEOUT_MS);
+      this.pending.set(request.id, { resolve, reject, timer });
+      try {
+        socket.send(JSON.stringify(request));
+      } catch (error) {
+        clearTimeout(timer);
+        this.pending.delete(request.id);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+  failPending(why) {
+    for (const [id, p] of [...this.pending]) {
+      clearTimeout(p.timer);
+      this.pending.delete(id);
+      p.reject(new Error(`${why.message}; the request got no reply`));
+    }
+  }
+  async close() {
+    const socket = this.socket;
+    this.socket = null;
+    this.failPending(new Error(`ws ${this.url}: closed`));
+    socket?.close(1e3, "bye");
+    this.hub.end();
+  }
+};
+
+// src/session.ts
+import { HttpAgent } from "@ag-ui/client";
+function filePart(name, mimeType, base64) {
+  const source = { type: "data", value: base64, mimeType };
+  const metadata = { filename: name };
+  return mimeType.startsWith("image/") ? { type: "image", source, metadata } : { type: "document", source, metadata };
+}
+var MAX_FILE_BYTES = 5 * 1024 * 1024;
+var MAX_MESSAGE_BYTES = 10 * 1024 * 1024;
+function parseEndpoint(raw) {
+  if (raw === "inproc:" || raw === "inproc") return { kind: "inproc" };
+  if (raw.startsWith("pipe:")) {
+    const name = raw.slice("pipe:".length);
+    if (!name) throw new Error(`\`${raw}\` is not an endpoint`);
+    return { kind: "pipe", name };
+  }
+  for (const scheme of ["http://", "https://", "ws://", "wss://"]) {
+    if (!raw.startsWith(scheme)) continue;
+    const rest = raw.slice(scheme.length);
+    const at = rest.indexOf("@");
+    const token = at > 0 ? rest.slice(0, at) : void 0;
+    const host = (at >= 0 ? rest.slice(at + 1) : rest).replace(/\/+$/, "");
+    if (!host) throw new Error(`\`${raw}\` is not an endpoint`);
+    const kind = scheme.startsWith("ws") ? "ws" : "http";
+    return token === void 0 ? { kind, url: `${scheme}${host}` } : { kind, url: `${scheme}${host}`, token };
+  }
+  throw new Error(
+    `\`${raw}\` is not an endpoint: expected \`inproc:\`, \`pipe:<name>\`, \`http://[token@]host:port\` or \`ws://[token@]host:port/path\``
+  );
+}
+function reqId() {
+  return crypto.randomUUID();
+}
+var STATE_CHANGED = "orrery.state.changed";
+var MOVED = "orrery.moved";
+function movedOf(frame) {
+  const f = frame;
+  if (f.type !== "CUSTOM" || f.name !== MOVED || typeof f.value?.machine !== "string" || typeof f.value?.session !== "string") return null;
+  return f.value;
+}
+var AguiSession = class _AguiSession {
+  constructor(transport, session) {
+    this.transport = transport;
+    this.session = session;
+  }
+  agent = null;
+  lastSeq = null;
+  declared = null;
+  machine = null;
+  ownConn = 0;
+  /** Watch id → callback, for `orrery.state.changed` frames (decision 0016). */
+  watchers = /* @__PURE__ */ new Map();
+  /** Connect to an endpoint: `http(s)://` or `ws(s)://`. */
+  static connect(endpoint, options = {}) {
+    const parsed = typeof endpoint === "string" ? parseEndpoint(endpoint) : endpoint;
+    if (parsed.kind === "http") {
+      return new _AguiSession(new HttpSseTransport({ url: parsed.url, ...parsed.token ? { token: parsed.token } : {} }), null);
+    }
+    if (parsed.kind === "ws") {
+      return new _AguiSession(
+        new WebSocketTransport({
+          url: parsed.url,
+          ...parsed.token || options.token ? { token: parsed.token ?? options.token } : {},
+          ...options.WebSocket ? { WebSocket: options.WebSocket } : {}
+        }),
+        null
+      );
+    }
+    throw new Error(
+      `${parsed.kind} is not reachable from this entry; use the HTTP or WebSocket listener (or \`@getorrery/client/node\` for the client channel)`
+    );
+  }
+  /** A session over a transport this SDK did not build. */
+  static over(transport) {
+    return new _AguiSession(transport, null);
+  }
+  /** The stock `@ag-ui/client` agent, unmodified, for anyone who wants it. HTTP only. */
+  httpAgent() {
+    const t = this.http("httpAgent()");
+    const auth = t.headers()["Authorization"];
+    this.agent ??= new HttpAgent({ url: `${t.url}/run`, headers: auth ? { Authorization: auth } : {} });
+    return this.agent;
+  }
+  /**
+   * 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() {
+    return this.ownConn;
+  }
+  /** The last `seq` this session has seen. */
+  seq() {
+    return this.lastSeq;
+  }
+  /** The session attached to, as `[machine/]session`. */
+  address() {
+    if (!this.session) return null;
+    return this.machine ? `${this.machine}/${this.session}` : this.session;
+  }
+  /**
+   * 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, draws) {
+    this.declared = { client, draws: [...draws] };
+  }
+  /**
+   * 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.
+   */
+  async attach(address, since) {
+    const a = parseAddress(address);
+    this.session = a.session;
+    this.machine = a.machine;
+    if (this.transport.kind !== "http") return;
+    await this.control({
+      t: "session.attach",
+      id: reqId(),
+      session: a.session,
+      ...since === void 0 ? {} : { since }
+    });
+  }
+  /**
+   * 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.
+   */
+  async submit(text2, parts = []) {
+    const answer = await this.control({
+      t: "turn.submit",
+      id: reqId(),
+      session: this.requireSession(),
+      input: parts.length > 0 ? { text: text2, parts: [...parts] } : { text: text2 }
+    });
+    if (answer === null || answer === void 0) return null;
+    const turn = answer.turn;
+    if (!turn) throw new Error(`no turn id in ${JSON.stringify(answer)}`);
+    return turn;
+  }
+  /** Cancel a turn in flight. */
+  async cancel(turn) {
+    await this.control({
+      t: "turn.cancel",
+      id: reqId(),
+      session: this.requireSession(),
+      turn
+    });
+  }
+  /** Answer a consent prompt. */
+  async answer(prompt, answer) {
+    await this.control({ t: "consent.answer", id: reqId(), prompt, answer });
+  }
+  /**
+   * 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.
+   */
+  async intent(surface, value) {
+    await this.control({
+      t: "intent",
+      id: reqId(),
+      session: this.requireSession(),
+      surface,
+      value
+    });
+  }
+  /**
+   * An action on a node of the UI document: a list item chosen, a button
+   * pressed (decision 0002).
+   */
+  async uiIntent(node, action, value) {
+    await this.control({
+      t: "ui.intent",
+      id: reqId(),
+      session: this.requireSession(),
+      node,
+      action,
+      value: value ?? null
+    });
+  }
+  /**
+   * 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.
+   */
+  async watch(ext, key, onChange) {
+    const answer = await this.control({
+      t: "state.watch",
+      id: reqId(),
+      session: this.requireSession(),
+      ext,
+      key
+    });
+    if (answer === null) {
+      throw new Error(`the ${this.transport.kind} server returned no answer to state.watch`);
+    }
+    this.watchers.set(answer.watch, onChange);
+    onChange(answer.value);
+    let stopped = false;
+    return async () => {
+      if (stopped) return;
+      stopped = true;
+      this.watchers.delete(answer.watch);
+      await this.control({ t: "state.unwatch", id: reqId(), session: this.requireSession(), watch: answer.watch });
+    };
+  }
+  /** Hand a frame's `orrery.state.changed` to the watch it names. */
+  dispatch(frame) {
+    const f = frame;
+    if (f.type !== "CUSTOM" || f.name !== STATE_CHANGED || typeof f.value?.watch !== "number") return;
+    this.watchers.get(f.value.watch)?.(f.value.value);
+  }
+  /**
+   * 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.
+   */
+  async handoff(to, options = {}) {
+    return this.control({
+      t: "session.handoff",
+      id: reqId(),
+      session: this.requireSession(),
+      to,
+      ...options.untracked ? { untracked: options.untracked } : {},
+      ...options.turn ? { turn: options.turn } : {}
+    });
+  }
+  /** Run a command the host owns: `/model`, `/providers`, `/help`. */
+  async command(name, args) {
+    await this.control({
+      t: "command",
+      id: reqId(),
+      session: this.requireSession(),
+      name,
+      ...args === void 0 ? {} : { args }
+    });
+  }
+  /**
+   * 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.
+   */
+  async *events(since) {
+    const hello = { format: "json", protocol: AGUI_PROTOCOL_VERSION };
+    if (since !== void 0) hello.since = since;
+    if (this.transport.kind !== "http") {
+      if (this.session) hello.session = this.session;
+      if (this.machine) hello.machine = this.machine;
+    }
+    if (this.declared) {
+      hello.client = this.declared.client;
+      hello.draws = this.declared.draws;
+    }
+    this.ownConn = (await this.transport.connect(hello)).conn ?? 0;
+    for await (const frame of framesOf(this.transport)) {
+      this.seen(frame);
+      yield frame;
+    }
+  }
+  /** `events()` from where this session left off: what a renderer's `frames()` wants. */
+  frames() {
+    return this.events(this.lastSeq ?? void 0);
+  }
+  /**
+   * 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.
+   */
+  async *run(text2) {
+    const t = this.http("run()");
+    const response = await fetch(`${t.url}/run`, {
+      method: "POST",
+      headers: t.headers(),
+      body: JSON.stringify({
+        threadId: this.requireSession(),
+        messages: [{ role: "user", content: text2 }]
+      })
+    });
+    if (!response.ok || !response.body) {
+      throw new Error(`POST /run: ${response.status}`);
+    }
+    for await (const frame of sse(response.body)) {
+      this.seen(frame);
+      yield frame;
+    }
+  }
+  /** Stop the stream. */
+  async close() {
+    await this.transport.close();
+  }
+  seen(frame) {
+    if (frame.seq !== OUT_OF_ORDER) this.lastSeq = frame.seq;
+    this.dispatch(frame);
+  }
+  http(what) {
+    if (this.transport instanceof HttpSseTransport) return this.transport;
+    throw new Error(`${what} is HTTP-only; over ${this.transport.kind}, use submit() and events()`);
+  }
+  requireSession() {
+    if (!this.session) throw new Error("not attached to a session");
+    return this.session;
+  }
+  async control(request) {
+    return this.transport.send(request);
+  }
+};
+
+// src/workspace.ts
+var WORKSPACE_READ = "workspace.read";
+var WORKSPACE_COMMIT = "workspace.commit";
+var WORKSPACE_PUSH = "workspace.push";
+var WORKSPACE_READ_CAP_BYTES = 1 << 20;
+function requestId() {
+  return globalThis.crypto?.randomUUID?.() ?? `ws-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+var workspaceRequest = {
+  read(ask) {
+    const req = { t: WORKSPACE_READ, id: requestId(), session: ask.session, path: ask.path };
+    if (ask.base) req["base"] = true;
+    return req;
+  },
+  commit(ask) {
+    const req = { t: WORKSPACE_COMMIT, id: requestId(), session: ask.session, message: ask.message };
+    if (ask.paths !== void 0) req["paths"] = ask.paths;
+    return req;
+  },
+  push(ask) {
+    return { t: WORKSPACE_PUSH, id: requestId(), session: ask.session };
+  }
+};
+async function workspaceRead(transport, ask) {
+  return await transport.send(workspaceRequest.read(ask));
+}
+async function workspaceCommit(transport, ask) {
+  return await transport.send(workspaceRequest.commit(ask));
+}
+async function workspacePush(transport, ask) {
+  return await transport.send(workspaceRequest.push(ask));
+}
+function workspaceErrorCode(error) {
+  return error instanceof ControlError ? error.code : void 0;
+}
+
+// src/kept.ts
+function resumeFrom(cursor, epoch) {
+  if (epoch === void 0 || cursor.epoch === void 0 || cursor.epoch === epoch) {
+    return cursor.frameSeq === void 0 ? { replay: false } : { since: cursor.frameSeq, replay: false };
+  }
+  return { replay: true };
+}
+function afterOf(cursor) {
+  return cursor.entrySeq === void 0 ? void 0 : `${cursor.epoch ?? 0},${cursor.entrySeq}`;
+}
+async function readKept(page, cursor, seen) {
+  const fresh = [];
+  let at = cursor;
+  let last = null;
+  for (let after = afterOf(cursor), n = 0; n < 1e3; n += 1) {
+    const p = await page(after);
+    last = p;
+    for (const e of p.entries) {
+      const id = `${e.epoch},${e.seq}`;
+      if (seen.has(id)) continue;
+      seen.add(id);
+      fresh.push(e);
+      at = { ...at, epoch: e.epoch, entrySeq: e.seq };
+    }
+    if (!p.next) break;
+    after = `${p.next.epoch},${p.next.seq}`;
+  }
+  return { entries: fresh, cursor: at, page: last };
+}
+function keptTranscript(entries) {
+  const out = [];
+  const tools = /* @__PURE__ */ new Map();
+  const settle = (call, outcome) => {
+    const tool = call ? tools.get(call) : void 0;
+    if (tool) tool.ok = outcome?.t === "ok" || outcome?.t === "truncated";
+  };
+  for (const e of entries) {
+    if (e.kind !== "turn") continue;
+    const row = e.body;
+    const p = row?.payload;
+    if (!p) continue;
+    switch (p.t) {
+      case "user":
+        out.push({ role: "user", text: p.input?.text ?? "", key: e.key });
+        break;
+      case "assistant":
+        (p.content ?? []).forEach((b, i) => {
+          const key = `${e.key}:${i}`;
+          if (b.t === "text" && b.text) out.push({ role: "assistant", text: b.text, key });
+          else if (b.t === "thinking" && b.text) out.push({ role: "thinking", text: b.text, key });
+          else if (b.t === "image") out.push({ role: "assistant", text: `[image ${b.media_type ?? ""}]`.trim(), key });
+          else if (b.t === "tool-use" && b.call) {
+            const tool = { role: "tool", name: b.name ?? "tool", call: b.call, ok: null, key };
+            tools.set(b.call, tool);
+            out.push(tool);
+          } else if (b.t === "tool-result") settle(b.call, b.outcome);
+        });
+        break;
+      case "tool-result":
+        settle(p.call, p.outcome);
+        break;
+      case "summary":
+        if (p.text) out.push({ role: "assistant", text: p.text, key: e.key });
+        break;
+    }
+  }
+  return out;
+}
+
+// src/conformance.ts
+var conformance_exports = {};
+__export(conformance_exports, {
+  SCENARIO_COUNT: () => SCENARIO_COUNT,
+  checkpoints: () => checkpoints,
+  framesOf: () => framesOf2,
+  parse: () => parse,
+  replay: () => replay
+});
+var KNOWN = /* @__PURE__ */ new Set([
+  "RUN_STARTED",
+  "RUN_FINISHED",
+  "RUN_ERROR",
+  "STEP_STARTED",
+  "STEP_FINISHED",
+  "TEXT_MESSAGE_START",
+  "TEXT_MESSAGE_CONTENT",
+  "TEXT_MESSAGE_END",
+  "TOOL_CALL_START",
+  "TOOL_CALL_ARGS",
+  "TOOL_CALL_END",
+  "TOOL_CALL_RESULT",
+  "REASONING_START",
+  "REASONING_MESSAGE_START",
+  "REASONING_MESSAGE_CONTENT",
+  "REASONING_MESSAGE_END",
+  "REASONING_END",
+  "STATE_SNAPSHOT",
+  "STATE_DELTA",
+  "CUSTOM",
+  "SUBAGENT_STARTED",
+  "SUBAGENT_FINISHED",
+  "SUBAGENT_ERROR"
+]);
+function parse(text2, name, path = `${name}.jsonl`) {
+  const steps = [];
+  text2.split(/\r?\n/).forEach((raw, index) => {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) return;
+    let value;
+    try {
+      value = JSON.parse(line);
+    } catch (e) {
+      throw new Error(`${path}:${index + 1}: ${e.message}`);
+    }
+    if ("ev" in value) {
+      const ev = frameOf(value["ev"]);
+      if (!ev) {
+        throw new Error(`${path}:${index + 1}: an event with no seq`);
+      }
+      steps.push(
+        KNOWN.has(ev.type ?? "") ? { kind: "event", frame: ev } : { kind: "unknown", seq: ev.seq, what: ev.type ?? "?" }
+      );
+    } else if ("expect" in value) {
+      steps.push({ kind: "expect", state: value["expect"] });
+    } else {
+      throw new Error(`${path}:${index + 1}: expected \`ev\` or \`expect\``);
+    }
+  });
+  return { name, path, steps };
+}
+function framesOf2(scenario) {
+  return scenario.steps.flatMap((s) => s.kind === "event" ? [s.frame] : []);
+}
+var SCENARIO_COUNT = 68;
+function checkpoints(scenario) {
+  const store = new SurfaceStore();
+  const out = [];
+  for (const step of scenario.steps) {
+    if (step.kind === "event") store.apply(step.frame);
+    else if (step.kind === "unknown") store.applyUnknown(step.seq, step.what);
+    else {
+      out.push({
+        index: out.length + 1,
+        actual: structuredClone(store.state()),
+        expected: step.state
+      });
+    }
+  }
+  return out;
+}
+function replay(scenario) {
+  const store = new SurfaceStore();
+  for (const step of scenario.steps) {
+    if (step.kind === "event") store.apply(step.frame);
+    else if (step.kind === "unknown") store.applyUnknown(step.seq, step.what);
+  }
+  return store;
+}
+
+export {
+  CONSENT_REQUEST,
+  CONSENT_RESOLVED,
+  TURN_CANCELLED,
+  PLACED,
+  UNPLACED,
+  frameOf,
+  firstSeq,
+  ANIM,
+  OUT_OF_ORDER,
+  parseAnim,
+  SESSION_CHANGES,
+  USER_MESSAGE,
+  DETACHED_TURN,
+  choosingLine,
+  thoughtMs,
+  NOTICES,
+  SurfaceStore,
+  AGUI_PROTOCOL_VERSION,
+  ControlError,
+  framesOf,
+  FrameHub,
+  parseAddress,
+  formatAddress,
+  HttpSseTransport,
+  sse,
+  WebSocketTransport,
+  filePart,
+  MAX_FILE_BYTES,
+  MAX_MESSAGE_BYTES,
+  parseEndpoint,
+  STATE_CHANGED,
+  MOVED,
+  movedOf,
+  AguiSession,
+  WORKSPACE_READ,
+  WORKSPACE_COMMIT,
+  WORKSPACE_PUSH,
+  WORKSPACE_READ_CAP_BYTES,
+  workspaceRequest,
+  workspaceRead,
+  workspaceCommit,
+  workspacePush,
+  workspaceErrorCode,
+  resumeFrom,
+  afterOf,
+  readKept,
+  keptTranscript,
+  parse,
+  framesOf2,
+  SCENARIO_COUNT,
+  checkpoints,
+  replay,
+  conformance_exports
+};