@cubos/agent-sdk 0.0.1136563

package/dist/mapping.d.ts

@@ -0,0 +1,170 @@
+import type { Activity, Block, ClientToolCall, Conversation, Message, PlanSnapshot, Todo, ToolActivity } from "./types.js";
+/** Partial view of the server's `Conversation` DTO. */
+export interface WireConversation {
+    id: string;
+    title: string | null;
+    generated_title: string | null;
+    agent: {
+        slug: string;
+    } | null;
+    last_activity_at: string;
+    archived_at: string | null;
+    is_processing: boolean;
+    has_pending_turn: boolean;
+    created_at: string;
+    updated_at: string;
+}
+/** Partial view of the server's `ConversationEventAttachment` DTO. Unexported:
+ * it is reached only through `WireEvent`, and the public shape is `Attachment`. */
+interface WireAttachment {
+    id: string;
+    kind: string;
+    mime_type: string;
+    bytes: number;
+    label: string | null;
+}
+/** The server's `TurnStatus`, carried as `conversation_status` frames on the
+ * event stream. */
+export interface WireTurnStatus {
+    is_processing: boolean;
+    has_pending_turn: boolean;
+}
+/** Partial view of the server's `ConversationEvent` DTO. */
+export interface WireEvent {
+    id: string;
+    tool_call_id?: string | null;
+    tool_name?: string | null;
+    seq: number;
+    change_seq: number;
+    type: string;
+    content: string | null;
+    tentative: boolean;
+    discarded_at: string | null;
+    created_at: string;
+    /** Absent on older servers and on the many event types that never carry
+     * media, so it is read defensively rather than required. */
+    attachments?: WireAttachment[];
+    /** Absent on every event that isn't an agent message, and on servers older
+     * than the feature — hence optional rather than required. */
+    blocks?: Block[];
+    /** Free-form per event type. Read here for `media_transcription`'s
+     * `source_event_id` and as a tool's return value. */
+    result?: unknown;
+    /** Set on a `tool_result` the tool failed. */
+    error?: string | null;
+    /** Server-measured wall clock, on the event types that time something. */
+    duration_ms?: number | null;
+    /** The provider exchange behind an `llm_call`. Read here for one thing only:
+     * the arguments of the tool calls it issued. */
+    llm_call_data?: WireLlmCallData | null;
+}
+/** The sliver of the server's `LlmCallData` this file reads. Deliberately not
+ * the whole snapshot: the rest is the prompt, and nothing on this surface
+ * should start depending on its shape. */
+interface WireLlmCallData {
+    response?: {
+        messages?: Array<{
+            type?: string;
+            tool_call_id?: string;
+            name?: string;
+            arguments?: unknown;
+        }> | null;
+    } | null;
+}
+export declare function toConversation(w: WireConversation): Conversation;
+/** The turn status, as the event stream reports it — ordered against the log
+ * rather than racing it on a second connection, which is why the conversation
+ * row's copy of the same pair is not what a client should watch. */
+export declare function toTurnStatus(w: WireTurnStatus): Activity;
+/**
+ * A message, or null for the many event types that aren't one (tool calls, LLM
+ * bookkeeping, compaction markers…).
+ *
+ * `tentative` rows are written by the harness mid-turn and may be rolled back;
+ * `discarded_at` marks one that was. Neither belongs in a transcript, and the
+ * server re-emits both over SSE precisely so clients can drop them.
+ */
+export declare function toMessage(w: WireEvent): Message | null;
+/**
+ * Folds each transcription into the media it belongs to, so a voice message is
+ * one bubble with a player and its text rather than two.
+ *
+ * The harness names the source event, and that is what pairs them. A
+ * transcription of an *image* is the fallback vision model's description, not
+ * the user's words — the picture is already on screen, so it is dropped rather
+ * than shown as something the user said.
+ *
+ * Rows written before the server recorded a source pair oldest-first instead,
+ * the same FIFO rule the harness used then: a user routinely types something
+ * between the recording and its transcription, so "the message directly before"
+ * is not a safe match.
+ *
+ * Expects `messages` ordered by `seq`.
+ */
+export declare function mergeVoiceMessages(messages: Message[]): Message[];
+/**
+ * The agent's whole current plan, or null when this event isn't one.
+ *
+ * `todo_update` carries a JSON-encoded `TodoUpdatePayload` in `content` (not in
+ * `result` — it's a pseudo-tool, so it writes its own side-effect event), and
+ * each call overwrites the entire list rather than patching it.
+ */
+export declare function toTodos(w: WireEvent): Todo[] | null;
+/**
+ * The plan revision this event carries, tagged with where it sits in the log.
+ *
+ * Same content as `toTodos`, plus the `seq` a reader needs to say *which*
+ * answer a plan belongs to — without it, a client holding several turns of
+ * history can only ever show the newest plan against all of them.
+ */
+export declare function toPlanSnapshot(w: WireEvent): PlanSnapshot | null;
+/**
+ * The `seq` of a turn that has finished, or null for every other event.
+ *
+ * The honest end of a turn, and not the same thing as `isProcessing` going
+ * false: a client tool *suspends* the turn while the app answers, and the
+ * conversation stops being "processing" for as long as that takes. A UI keyed
+ * on activity alone therefore stops its own spinner in the middle of the work
+ * and starts it again a second later — which is the flicker this exists to
+ * prevent.
+ */
+export declare function toTurnDone(w: WireEvent): number | null;
+/** The agent called a client tool, which suspends its turn until someone
+ * answers. Null for every other event. */
+export declare function toClientToolCall(w: WireEvent): ClientToolCall | null;
+/**
+ * The agent reaching for a tool, or the outcome of one. Null for every other
+ * event.
+ *
+ * Unlike a message, a `tentative` row is exactly what this wants. A
+ * `tool_result` is written tentative and only promoted when the turn
+ * consolidates, so dropping those would hide the trail until the turn was over
+ * — the opposite of showing what the agent is doing right now. `discarded_at`
+ * still disqualifies: that turn was rolled back, so its steps never happened.
+ */
+export declare function toToolActivity(w: WireEvent): ToolActivity | null;
+/**
+ * The arguments the model passed, read off the `llm_call` that issued the
+ * calls — the only event that carries them for a server-side tool, since a
+ * `tool_result` records the outcome and never the input.
+ *
+ * Deliberately **not** an activity. A pseudo-tool (`send_message`,
+ * `yield_turn`, `update_todo`) writes its own side-effect event instead of a
+ * `tool_result`, so minting an entry from every call here would leave three
+ * steps per turn stuck at `running` forever. These only ever fill in the
+ * arguments of an entry that already exists.
+ */
+export declare function toToolCallArguments(w: WireEvent): ToolCallArguments[];
+export interface ToolCallArguments {
+    toolCallId: string;
+    arguments: Record<string, unknown>;
+}
+/** Fills in what an activity could not know about itself. Never overwrites: a
+ * client tool reports its own arguments, and those are what it was actually
+ * dispatched with. */
+export declare function withToolArguments(activity: ToolActivity, known: Map<string, Record<string, unknown>>): ToolActivity;
+/** Folds each call together with its result, so one tool is one entry.
+ *
+ * Expects activities in any order and returns them by `seq`. */
+export declare function mergeToolActivities(activities: ToolActivity[]): ToolActivity[];
+export {};

package/dist/schemas.d.ts

@@ -0,0 +1,2 @@
+import type { components } from "./generated/schema.js";
+export type Schemas = components["schemas"];

package/dist/sse.d.ts

@@ -0,0 +1,48 @@
+/** Just the call signature, not `typeof fetch` — that also demands runtime
+ * extras (Bun's `preconnect`, undici's statics) a caller's wrapper won't have. */
+export type FetchLike = (input: string, init?: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string | FormData;
+    signal?: AbortSignal;
+}) => Promise<Response>;
+export interface SseOptions<T> {
+    url: string;
+    /**
+     * Only frames with one of these `event:` names are delivered; the rest are
+     * dropped. Several names on one connection is how a stream keeps two kinds of
+     * frame in a single order — split across two connections there is none, and a
+     * client cannot tell which came first.
+     */
+    event: string | string[];
+    onEvent: (data: T, event: string) => void;
+    signal: AbortSignal;
+    /** Called before each (re)connect, so the caller can mint a fresh token. */
+    headers?: () => Promise<Record<string, string>> | Record<string, string>;
+    /** Called once per successful connect, before any frame is delivered. The
+     * hook a caller needs to catch up on state the stream won't replay: it fires
+     * on every reconnect too, so a gap the backoff swallowed is covered as
+     * well. Not awaited — a slow catch-up must not stall frame delivery. */
+    onOpen?: () => void;
+    /** Resume cursor for the first connect. Later reconnects use the last `id:`
+     * the server actually sent. */
+    lastEventId?: string;
+    fetchImpl?: FetchLike;
+    onError?: (err: unknown) => void;
+}
+/**
+ * Reads `url` until `signal` aborts, reconnecting through any drop — clean
+ * close from the server included, since intermediaries (Cloudflare et al.)
+ * close idle SSE connections without warning and the caller would otherwise
+ * silently stop receiving.
+ *
+ * `Last-Event-ID` is replayed from the last frame the server sent, so the
+ * backend's catch-up query fills whatever the gap swallowed. 4xx ends the loop
+ * — a bad token or a deleted conversation won't fix itself by retrying.
+ */
+export declare function readSse<T>(opts: SseOptions<T>): Promise<void>;
+export declare function parseFrame<T>(frame: string, expectedEvent: string | string[]): {
+    data: T;
+    id: string | null;
+    event: string;
+} | null;

package/dist/sse.js

@@ -0,0 +1,209 @@
+// src/errors.ts
+class AgentError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AgentError";
+  }
+}
+
+class AgentApiError extends AgentError {
+  status;
+  requestId;
+  body;
+  constructor(message, status, requestId = null, body = "") {
+    super(message);
+    this.name = "AgentApiError";
+    this.status = status;
+    this.requestId = requestId;
+    this.body = body;
+  }
+  json() {
+    try {
+      return JSON.parse(this.body);
+    } catch {
+      return;
+    }
+  }
+  get isAuthError() {
+    return this.status === 401 || this.status === 403;
+  }
+  get isNotFound() {
+    return this.status === 404;
+  }
+  get isConflict() {
+    return this.status === 409;
+  }
+  get isRetryable() {
+    return this.status === 429 || this.status >= 500;
+  }
+}
+
+class AgentConfigError extends AgentError {
+  constructor(message) {
+    super(message);
+    this.name = "AgentConfigError";
+  }
+}
+
+class AgentNetworkError extends AgentError {
+  cause;
+  timedOut;
+  constructor(message, cause, timedOut = false) {
+    super(message);
+    this.name = "AgentNetworkError";
+    this.cause = cause;
+    this.timedOut = timedOut;
+  }
+}
+var DEFAULT_MESSAGES = {
+  400: "Invalid request.",
+  401: "Not authenticated.",
+  403: "Not allowed.",
+  404: "Not found.",
+  409: "Conflicts with the current state.",
+  413: "Payload too large.",
+  429: "Rate limited."
+};
+async function raiseForStatus(res, fallback) {
+  if (res.ok)
+    return;
+  let detail = "";
+  try {
+    detail = await res.text();
+  } catch {
+    detail = "";
+  }
+  const base = DEFAULT_MESSAGES[res.status] ?? fallback;
+  throw new AgentApiError(detail ? `${base} (${detail.slice(0, 500)})` : base, res.status, res.headers.get("x-request-id"), detail);
+}
+
+// src/sse.ts
+var MAX_BACKOFF_MS = 30000;
+
+class Fatal extends Error {
+  cause;
+  constructor(cause) {
+    super("fatal stream error");
+    this.cause = cause;
+  }
+}
+async function readSse(opts) {
+  const doFetch = opts.fetchImpl ?? globalThis.fetch;
+  let lastEventId = opts.lastEventId;
+  let attempt = 0;
+  while (!opts.signal.aborted) {
+    let madeProgress = false;
+    try {
+      const headers = {
+        ...await opts.headers?.(),
+        Accept: "text/event-stream"
+      };
+      if (lastEventId !== undefined)
+        headers["Last-Event-ID"] = lastEventId;
+      const res = await doFetch(opts.url, { headers, signal: opts.signal });
+      if (opts.signal.aborted)
+        return;
+      if (res.ok && res.body)
+        opts.onOpen?.();
+      if (!res.ok || !res.body) {
+        if (res.status >= 400 && res.status < 500) {
+          await raiseForStatus(res, `Could not open ${opts.url}.`).catch((err) => {
+            throw new Fatal(err);
+          });
+          return;
+        }
+        throw new Error(`stream open failed with HTTP ${res.status}`);
+      }
+      for await (const frame of frames(res.body, opts.signal)) {
+        const parsed = parseFrame(frame, opts.event);
+        if (parsed === null)
+          continue;
+        if (parsed.id !== null)
+          lastEventId = parsed.id;
+        opts.onEvent(parsed.data, parsed.event);
+        madeProgress = true;
+      }
+    } catch (err) {
+      if (opts.signal.aborted)
+        return;
+      if (err instanceof Fatal)
+        throw err.cause;
+      opts.onError?.(err);
+    }
+    if (opts.signal.aborted)
+      return;
+    if (madeProgress)
+      attempt = 0;
+    const delayMs = Math.min(MAX_BACKOFF_MS, 1000 * 2 ** attempt);
+    attempt += 1;
+    await sleep(delayMs, opts.signal);
+  }
+}
+async function* frames(body, signal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  try {
+    while (!signal.aborted) {
+      const { value, done } = await reader.read();
+      if (done)
+        return;
+      buffer += decoder.decode(value, { stream: true });
+      for (;; ) {
+        const sep = buffer.indexOf(`
+
+`);
+        if (sep === -1)
+          break;
+        yield buffer.slice(0, sep);
+        buffer = buffer.slice(sep + 2);
+      }
+    }
+  } finally {
+    reader.cancel().catch(() => {});
+  }
+}
+function parseFrame(frame, expectedEvent) {
+  let dataLine = null;
+  let id = null;
+  let eventName = "message";
+  for (const line of frame.split(`
+`)) {
+    if (line.startsWith(":"))
+      continue;
+    if (line.startsWith("data:"))
+      dataLine = line.slice(5).trimStart();
+    else if (line.startsWith("event:"))
+      eventName = line.slice(6).trim();
+    else if (line.startsWith("id:"))
+      id = line.slice(3).trim();
+  }
+  const wanted = typeof expectedEvent === "string" ? eventName === expectedEvent : expectedEvent.includes(eventName);
+  if (!wanted || dataLine === null)
+    return null;
+  try {
+    return { data: JSON.parse(dataLine), id, event: eventName };
+  } catch {
+    return null;
+  }
+}
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+export {
+  readSse,
+  parseFrame
+};
+
+//# debugId=85857292E5DF4F6B64756E2164756E21
+//# sourceMappingURL=sse.js.map

package/dist/sse.js.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["../src/errors.ts", "../src/sse.ts"],
+  "sourcesContent": [
+    "/** Base for everything this SDK throws, so `catch (e) { if (e instanceof\n * AgentError) }` covers both an HTTP failure and a connection that never got\n * there. */\nexport class AgentError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"AgentError\";\n  }\n}\n\n/** The server answered, and said no. */\nexport class AgentApiError extends AgentError {\n  readonly status: number;\n  /** Server's `x-request-id`, when present. Worth quoting in a bug report. */\n  readonly requestId: string | null;\n  /** The response body, verbatim and untruncated. Some routes explain the\n   * failure in there (an MCP probe's reason, a rejected cron) in a form worth\n   * showing the user; `message` only carries a truncated preview. */\n  readonly body: string;\n\n  constructor(message: string, status: number, requestId: string | null = null, body = \"\") {\n    super(message);\n    this.name = \"AgentApiError\";\n    this.status = status;\n    this.requestId = requestId;\n    this.body = body;\n  }\n\n  /** The body parsed as JSON, or `undefined` when it isn't. */\n  json<T = unknown>(): T | undefined {\n    try {\n      return JSON.parse(this.body) as T;\n    } catch {\n      return undefined;\n    }\n  }\n\n  /** The token was rejected. The client already retried once with a fresh one,\n   * so seeing this means `getToken` is handing back something unusable. */\n  get isAuthError(): boolean {\n    return this.status === 401 || this.status === 403;\n  }\n\n  get isNotFound(): boolean {\n    return this.status === 404;\n  }\n\n  /** The request clashed with current state — a slug already taken, a\n   * conversation that belongs to a channel, a user already blocked. */\n  get isConflict(): boolean {\n    return this.status === 409;\n  }\n\n  /** Worth retrying after a pause: the server is overloaded or briefly down. */\n  get isRetryable(): boolean {\n    return this.status === 429 || this.status >= 500;\n  }\n}\n\n/**\n * The client was constructed wrong — a `baseUrl` with no scheme, most often.\n * Thrown at construction, not on the first call, so the stack points at the\n * mistake.\n */\nexport class AgentConfigError extends AgentError {\n  constructor(message: string) {\n    super(message);\n    this.name = \"AgentConfigError\";\n  }\n}\n\n/**\n * The request never produced a response: DNS, TLS, a refused connection, CORS,\n * or the timeout below.\n *\n * Without this, `fetch` rejects with a bare `TypeError: fetch failed` and the\n * caller cannot tell a wrong `baseUrl` from a server that said 500 — the two\n * need completely different fixes.\n */\nexport class AgentNetworkError extends AgentError {\n  /** Whatever `fetch` (or the abort) threw. */\n  readonly cause: unknown;\n  /** True when the SDK's own timeout fired rather than the network failing. */\n  readonly timedOut: boolean;\n\n  constructor(message: string, cause: unknown, timedOut = false) {\n    super(message);\n    this.name = \"AgentNetworkError\";\n    this.cause = cause;\n    this.timedOut = timedOut;\n  }\n}\n\nconst DEFAULT_MESSAGES: Record<number, string> = {\n  400: \"Invalid request.\",\n  401: \"Not authenticated.\",\n  403: \"Not allowed.\",\n  404: \"Not found.\",\n  409: \"Conflicts with the current state.\",\n  413: \"Payload too large.\",\n  429: \"Rate limited.\",\n};\n\nexport async function raiseForStatus(res: Response, fallback: string): Promise<void> {\n  if (res.ok) return;\n  let detail = \"\";\n  try {\n    detail = await res.text();\n  } catch {\n    detail = \"\";\n  }\n  const base = DEFAULT_MESSAGES[res.status] ?? fallback;\n  throw new AgentApiError(\n    detail ? `${base} (${detail.slice(0, 500)})` : base,\n    res.status,\n    res.headers.get(\"x-request-id\"),\n    detail,\n  );\n}\n",
+    "// A `fetch`-based Server-Sent Events reader. Not `EventSource`: that can't\n// attach an Authorization header, which every stream here requires.\n//\n// Runtime-agnostic on purpose — `fetch`, `ReadableStream` and `AbortController`\n// only, no DOM. Exported as its own entry point (`@cubos/agent-sdk/sse`) so the\n// operator dashboard can reuse it without adopting the rest of the client.\n\nimport { raiseForStatus } from \"./errors.js\";\n\n/** Just the call signature, not `typeof fetch` — that also demands runtime\n * extras (Bun's `preconnect`, undici's statics) a caller's wrapper won't have. */\nexport type FetchLike = (\n  input: string,\n  init?: {\n    method?: string;\n    headers?: Record<string, string>;\n    body?: string | FormData;\n    signal?: AbortSignal;\n  },\n) => Promise<Response>;\n\nexport interface SseOptions<T> {\n  url: string;\n  /**\n   * Only frames with one of these `event:` names are delivered; the rest are\n   * dropped. Several names on one connection is how a stream keeps two kinds of\n   * frame in a single order — split across two connections there is none, and a\n   * client cannot tell which came first.\n   */\n  event: string | string[];\n  onEvent: (data: T, event: string) => void;\n  signal: AbortSignal;\n  /** Called before each (re)connect, so the caller can mint a fresh token. */\n  headers?: () => Promise<Record<string, string>> | Record<string, string>;\n  /** Called once per successful connect, before any frame is delivered. The\n   * hook a caller needs to catch up on state the stream won't replay: it fires\n   * on every reconnect too, so a gap the backoff swallowed is covered as\n   * well. Not awaited — a slow catch-up must not stall frame delivery. */\n  onOpen?: () => void;\n  /** Resume cursor for the first connect. Later reconnects use the last `id:`\n   * the server actually sent. */\n  lastEventId?: string;\n  fetchImpl?: FetchLike;\n  onError?: (err: unknown) => void;\n}\n\nconst MAX_BACKOFF_MS = 30_000;\n\n/** Marks an error the reconnect loop must not swallow. */\nclass Fatal extends Error {\n  override readonly cause: unknown;\n  constructor(cause: unknown) {\n    super(\"fatal stream error\");\n    this.cause = cause;\n  }\n}\n\n/**\n * Reads `url` until `signal` aborts, reconnecting through any drop — clean\n * close from the server included, since intermediaries (Cloudflare et al.)\n * close idle SSE connections without warning and the caller would otherwise\n * silently stop receiving.\n *\n * `Last-Event-ID` is replayed from the last frame the server sent, so the\n * backend's catch-up query fills whatever the gap swallowed. 4xx ends the loop\n * — a bad token or a deleted conversation won't fix itself by retrying.\n */\nexport async function readSse<T>(opts: SseOptions<T>): Promise<void> {\n  const doFetch = opts.fetchImpl ?? globalThis.fetch;\n  let lastEventId = opts.lastEventId;\n  let attempt = 0;\n\n  while (!opts.signal.aborted) {\n    let madeProgress = false;\n    try {\n      const headers: Record<string, string> = {\n        ...(await opts.headers?.()),\n        Accept: \"text/event-stream\",\n      };\n      if (lastEventId !== undefined) headers[\"Last-Event-ID\"] = lastEventId;\n\n      const res = await doFetch(opts.url, { headers, signal: opts.signal });\n      if (opts.signal.aborted) return;\n      if (res.ok && res.body) opts.onOpen?.();\n\n      if (!res.ok || !res.body) {\n        if (res.status >= 400 && res.status < 500) {\n          // Wrapped so the catch below can tell it apart from a transient\n          // failure and rethrow instead of reconnecting forever.\n          await raiseForStatus(res, `Could not open ${opts.url}.`).catch((err) => {\n            throw new Fatal(err);\n          });\n          return;\n        }\n        throw new Error(`stream open failed with HTTP ${res.status}`);\n      }\n\n      for await (const frame of frames(res.body, opts.signal)) {\n        const parsed = parseFrame<T>(frame, opts.event);\n        if (parsed === null) continue;\n        if (parsed.id !== null) lastEventId = parsed.id;\n        opts.onEvent(parsed.data, parsed.event);\n        madeProgress = true;\n      }\n    } catch (err) {\n      if (opts.signal.aborted) return;\n      // A bad token or a deleted conversation won't fix itself by retrying.\n      if (err instanceof Fatal) throw err.cause;\n      // Everything else is transient (network, 5xx, proxy hangup) — report and\n      // back off rather than end the subscription.\n      opts.onError?.(err);\n    }\n\n    if (opts.signal.aborted) return;\n\n    // Any delivered frame resets the backoff: a long-lived stream that did real\n    // work and then dropped should come back fast, not wait out the ceiling.\n    if (madeProgress) attempt = 0;\n    const delayMs = Math.min(MAX_BACKOFF_MS, 1_000 * 2 ** attempt);\n    attempt += 1;\n    await sleep(delayMs, opts.signal);\n  }\n}\n\nasync function* frames(\n  body: ReadableStream<Uint8Array>,\n  signal: AbortSignal,\n): AsyncGenerator<string> {\n  const reader = body.getReader();\n  const decoder = new TextDecoder();\n  let buffer = \"\";\n  try {\n    while (!signal.aborted) {\n      const { value, done } = await reader.read();\n      if (done) return;\n      buffer += decoder.decode(value, { stream: true });\n      for (;;) {\n        const sep = buffer.indexOf(\"\\n\\n\");\n        if (sep === -1) break;\n        yield buffer.slice(0, sep);\n        buffer = buffer.slice(sep + 2);\n      }\n    }\n  } finally {\n    reader.cancel().catch(() => {});\n  }\n}\n\nexport function parseFrame<T>(\n  frame: string,\n  expectedEvent: string | string[],\n): { data: T; id: string | null; event: string } | null {\n  let dataLine: string | null = null;\n  let id: string | null = null;\n  let eventName = \"message\";\n  for (const line of frame.split(\"\\n\")) {\n    if (line.startsWith(\":\")) continue;\n    if (line.startsWith(\"data:\")) dataLine = line.slice(5).trimStart();\n    else if (line.startsWith(\"event:\")) eventName = line.slice(6).trim();\n    else if (line.startsWith(\"id:\")) id = line.slice(3).trim();\n  }\n  const wanted =\n    typeof expectedEvent === \"string\"\n      ? eventName === expectedEvent\n      : expectedEvent.includes(eventName);\n  if (!wanted || dataLine === null) return null;\n  try {\n    return { data: JSON.parse(dataLine) as T, id, event: eventName };\n  } catch {\n    return null;\n  }\n}\n\nfunction sleep(ms: number, signal: AbortSignal): Promise<void> {\n  return new Promise((resolve) => {\n    const onAbort = () => {\n      clearTimeout(timer);\n      resolve();\n    };\n    const timer = setTimeout(() => {\n      signal.removeEventListener(\"abort\", onAbort);\n      resolve();\n    }, ms);\n    signal.addEventListener(\"abort\", onAbort, { once: true });\n  });\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "85857292E5DF4F6B64756E2164756E21",
+  "names": []
+}