@ellipsis-dev/sdk 0.34.0 → 0.35.0

package/dist/store/index.js

@@ -1,7 +1,3 @@
-import {
-  SESSION_STREAM_PROTOCOL_VERSION
-} from "../chunk-6V7QTLLF.js";
-
 // src/store/claude.ts
 function claudePayload(record) {
   if (record.kind === "claude_sdk") return record.payload;
@@ -104,124 +100,6 @@ function codexAppServerContent(event) {
   }
 }
 
-// src/store/progress.ts
-function messageProgress(records) {
-  const messages = /* @__PURE__ */ new Map();
-  const pending = /* @__PURE__ */ new Map();
-  const turns = /* @__PURE__ */ new Map();
-  let ready = false;
-  const getTurn = (id) => {
-    let turn = turns.get(id);
-    if (!turn) {
-      turn = {
-        timing: { id, startedAt: null, completedAt: null },
-        phase: ready ? "working" : "starting",
-        messages: /* @__PURE__ */ new Set()
-      };
-      turns.set(id, turn);
-    }
-    return turn;
-  };
-  const attach = (messageId, turnId) => {
-    const message = messages.get(messageId);
-    if (!message) return;
-    const turn = getTurn(turnId);
-    if (!turn.messages.has(messageId)) {
-      turn.messages.add(messageId);
-      message.turns.push(turn.timing);
-    }
-    pending.delete(messageId);
-    message.phase = turn.phase;
-  };
-  const setPending = (turnId, phase) => {
-    for (const [id, turn] of pending) {
-      if (turnId == null || turn == null || turn === turnId)
-        messages.get(id).phase = phase;
-    }
-  };
-  for (const record of records) {
-    if (record.kind === "platform") {
-      const p = record.payload;
-      const messageId = typeof p.message_id === "string" ? p.message_id : null;
-      const turnId = typeof p.turn_id === "string" ? p.turn_id : record.turn_id;
-      switch (record.record_type) {
-        case "message_received":
-          if (messageId && !messages.has(messageId)) {
-            messages.set(messageId, { phase: "queued", turns: [] });
-            if (turnId && turns.has(turnId)) attach(messageId, turnId);
-            else pending.set(messageId, turnId ?? null);
-          }
-          break;
-        case "message_delivered":
-          if (messageId && turnId) attach(messageId, turnId);
-          break;
-        case "message_requeued":
-          if (messageId && messages.has(messageId)) {
-            const requeued = typeof p.requeued_turn_id === "string" ? p.requeued_turn_id : null;
-            pending.set(messageId, requeued);
-            messages.get(messageId).phase = "queued";
-          }
-          break;
-        case "environment_phase":
-        case "environment_output":
-          ready = false;
-          setPending(turnId ?? null, "preparing");
-          break;
-        case "environment_ready":
-          ready = false;
-          setPending(turnId ?? null, "starting");
-          break;
-        case "turn_started":
-          if (turnId) {
-            getTurn(turnId).timing.startedAt = record.created_at;
-            for (const [id, turn] of pending) {
-              if (turn === turnId) attach(id, turnId);
-            }
-          }
-          break;
-        case "turn_ended":
-          if (turnId) {
-            const turn = getTurn(turnId);
-            turn.timing.completedAt = record.created_at;
-            turn.phase = null;
-            for (const id of turn.messages) {
-              if (!pending.has(id)) messages.get(id).phase = null;
-            }
-            for (const [id, pendingTurn] of pending) {
-              if (pendingTurn === turnId) {
-                pending.delete(id);
-                messages.get(id).phase = null;
-              }
-            }
-          }
-          break;
-        case "session_closed":
-          ready = false;
-          for (const id of pending.keys()) messages.get(id).phase = null;
-          break;
-      }
-      continue;
-    }
-    const claude = claudePayload(record);
-    const agentStarted = record.kind === "codex_app_server" && record.payload.method === "turn/started" || record.kind === "codex" && record.payload.type === "turn.started" || claude != null && (claude.kind === "assistant" || claude.kind === "user" || claude.kind === "system" && claude.subtype === "init");
-    if (agentStarted) {
-      ready = true;
-      if (record.turn_id) {
-        const turn = getTurn(record.turn_id);
-        if (turn.timing.completedAt == null) {
-          turn.timing.startedAt ??= record.created_at;
-          turn.phase = "working";
-          for (const id of turn.messages) messages.get(id).phase = "working";
-        }
-      }
-    }
-    if (record.session_message_id && record.turn_id) {
-      attach(record.session_message_id, record.turn_id);
-    }
-  }
-  return messages;
-}
-
 // src/store/lifecycle.ts
 function environmentOutputStep(payload) {
   if (typeof payload.step === "string" && payload.step) return payload.step;
@@ -623,6 +501,55 @@ function recordToItems(record, keyBase, options = {}) {
         }
       ] : [];
     }
+    case "gemini": {
+      const content = geminiStreamContent(record.payload);
+      if (!content) return [];
+      if (content.kind === "end") {
+        return content.isError ? [
+          {
+            key: keyBase,
+            kind: "summary",
+            text: "turn ended with an error",
+            isError: true,
+            spaceBefore: true
+          }
+        ] : [];
+      }
+      if (content.kind === "tool") {
+        return [
+          {
+            key: keyBase,
+            kind: "tool",
+            gutter: "\u25CF",
+            text: content.name,
+            detail: content.summary ? `(${content.summary})` : void 0,
+            spaceBefore: true,
+            tool: { name: content.name, input: content.input ?? void 0 }
+          }
+        ];
+      }
+      if (content.kind === "tool_result") {
+        return [
+          {
+            key: keyBase,
+            kind: "tool_result",
+            gutter: "\u23BF",
+            text: content.text || "(completed)",
+            isError: content.isError,
+            spaceBefore: false
+          }
+        ];
+      }
+      return [
+        {
+          key: keyBase,
+          kind: content.kind,
+          text: content.text.trim(),
+          isError: content.kind === "error",
+          spaceBefore: true
+        }
+      ];
+    }
     case "platform": {
       const text2 = lifecycleText(record.record_type, record.payload);
       return text2 ? [{ key: keyBase, kind: "notice", text: text2, spaceBefore: true }] : [];
@@ -728,6 +655,155 @@ function statusActivityText(status) {
   }
 }
 
+// src/store/geminiStream.ts
+function geminiStreamContent(event) {
+  switch (event.type) {
+    case "message":
+      return event.role === "assistant" && !event.delta && event.content.trim() ? { kind: "assistant", text: event.content } : null;
+    case "tool_use": {
+      const input = event.parameters ?? null;
+      return {
+        kind: "tool",
+        toolId: event.tool_id,
+        name: event.tool_name,
+        input,
+        summary: oneLine(summarizeToolInput(event.tool_name, input ?? {}), 100)
+      };
+    }
+    case "tool_result":
+      return {
+        kind: "tool_result",
+        toolId: event.tool_id,
+        text: (event.output ?? event.error?.message ?? "").trim(),
+        isError: event.status === "error"
+      };
+    case "error":
+      return { kind: "error", text: event.message };
+    case "result":
+      return { kind: "end", isError: event.status === "error" };
+    default:
+      return null;
+  }
+}
+
+// src/store/progress.ts
+function messageProgress(records) {
+  const messages = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  const turns = /* @__PURE__ */ new Map();
+  let ready = false;
+  const getTurn = (id) => {
+    let turn = turns.get(id);
+    if (!turn) {
+      turn = {
+        timing: { id, startedAt: null, completedAt: null },
+        phase: ready ? "working" : "starting",
+        messages: /* @__PURE__ */ new Set()
+      };
+      turns.set(id, turn);
+    }
+    return turn;
+  };
+  const attach = (messageId, turnId) => {
+    const message = messages.get(messageId);
+    if (!message) return;
+    const turn = getTurn(turnId);
+    if (!turn.messages.has(messageId)) {
+      turn.messages.add(messageId);
+      message.turns.push(turn.timing);
+    }
+    pending.delete(messageId);
+    message.phase = turn.phase;
+  };
+  const setPending = (turnId, phase) => {
+    for (const [id, turn] of pending) {
+      if (turnId == null || turn == null || turn === turnId)
+        messages.get(id).phase = phase;
+    }
+  };
+  for (const record of records) {
+    if (record.kind === "platform") {
+      const p = record.payload;
+      const messageId = typeof p.message_id === "string" ? p.message_id : null;
+      const turnId = typeof p.turn_id === "string" ? p.turn_id : record.turn_id;
+      switch (record.record_type) {
+        case "message_received":
+          if (messageId && !messages.has(messageId)) {
+            messages.set(messageId, { phase: "queued", turns: [] });
+            if (turnId && turns.has(turnId)) attach(messageId, turnId);
+            else pending.set(messageId, turnId ?? null);
+          }
+          break;
+        case "message_delivered":
+          if (messageId && turnId) attach(messageId, turnId);
+          break;
+        case "message_requeued":
+          if (messageId && messages.has(messageId)) {
+            const requeued = typeof p.requeued_turn_id === "string" ? p.requeued_turn_id : null;
+            pending.set(messageId, requeued);
+            messages.get(messageId).phase = "queued";
+          }
+          break;
+        case "environment_phase":
+        case "environment_output":
+          ready = false;
+          setPending(turnId ?? null, "preparing");
+          break;
+        case "environment_ready":
+          ready = false;
+          setPending(turnId ?? null, "starting");
+          break;
+        case "turn_started":
+          if (turnId) {
+            getTurn(turnId).timing.startedAt = record.created_at;
+            for (const [id, turn] of pending) {
+              if (turn === turnId) attach(id, turnId);
+            }
+          }
+          break;
+        case "turn_ended":
+          if (turnId) {
+            const turn = getTurn(turnId);
+            turn.timing.completedAt = record.created_at;
+            turn.phase = null;
+            for (const id of turn.messages) {
+              if (!pending.has(id)) messages.get(id).phase = null;
+            }
+            for (const [id, pendingTurn] of pending) {
+              if (pendingTurn === turnId) {
+                pending.delete(id);
+                messages.get(id).phase = null;
+              }
+            }
+          }
+          break;
+        case "session_closed":
+          ready = false;
+          for (const id of pending.keys()) messages.get(id).phase = null;
+          break;
+      }
+      continue;
+    }
+    const claude = claudePayload(record);
+    const agentStarted = record.kind === "codex_app_server" && record.payload.method === "turn/started" || record.kind === "codex" && record.payload.type === "turn.started" || record.kind === "gemini" && record.payload.type === "init" || claude != null && (claude.kind === "assistant" || claude.kind === "user" || claude.kind === "system" && claude.subtype === "init");
+    if (agentStarted) {
+      ready = true;
+      if (record.turn_id) {
+        const turn = getTurn(record.turn_id);
+        if (turn.timing.completedAt == null) {
+          turn.timing.startedAt ??= record.created_at;
+          turn.phase = "working";
+          for (const id of turn.messages) messages.get(id).phase = "working";
+        }
+      }
+    }
+    if (record.session_message_id && record.turn_id) {
+      attach(record.session_message_id, record.turn_id);
+    }
+  }
+  return messages;
+}
+
 // src/store/chatTurns.ts
 var isInitEvent = (data) => data.kind === "system" && data.subtype === "init";
 var ENVIRONMENT_RECORD_TYPES = /* @__PURE__ */ new Set([
@@ -738,6 +814,7 @@ var ENVIRONMENT_RECORD_TYPES = /* @__PURE__ */ new Set([
 function groupRecordsToChatTurns(records, session) {
   const turns = [];
   const toolNodeByUseId = /* @__PURE__ */ new Map();
+  const openGeminiTools = /* @__PURE__ */ new Map();
   const userTurnByMessageId = /* @__PURE__ */ new Map();
   const turnByMessageId = /* @__PURE__ */ new Map();
   const unansweredTurnIds = /* @__PURE__ */ new Set();
@@ -897,6 +974,49 @@ function groupRecordsToChatTurns(records, session) {
       });
       continue;
     }
+    if (record.kind === "gemini") {
+      const content = geminiStreamContent(record.payload);
+      if (!content) continue;
+      if (content.kind === "end") {
+        if (openIdx >= 0) {
+          turns[openIdx].completedAt = record.created_at;
+          if (content.isError) turns[openIdx].isError = true;
+          openIdx = -1;
+        }
+      } else if (content.kind === "tool") {
+        const node = {
+          key: nextKey(record.id),
+          kind: "tool",
+          name: content.name,
+          input: content.input,
+          summary: content.summary,
+          result: null,
+          isError: false,
+          startedAt: record.created_at,
+          completedAt: null
+        };
+        openSessionTurn(record).nodes.push(node);
+        openGeminiTools.set(content.toolId, node);
+      } else if (content.kind === "tool_result") {
+        const node = openGeminiTools.get(content.toolId);
+        if (node) {
+          node.result = content.text;
+          node.isError = content.isError;
+          node.completedAt = record.created_at;
+          openGeminiTools.delete(content.toolId);
+        }
+      } else {
+        const turn2 = openSessionTurn(record);
+        if (content.kind === "error") turn2.isError = true;
+        turn2.nodes.push({
+          key: nextKey(record.id),
+          kind: "assistant",
+          text: content.text.trim(),
+          createdAt: record.created_at
+        });
+      }
+      continue;
+    }
     if (record.kind === "codex_app_server") {
       const content = codexAppServerContent(record.payload);
       if (!content) continue;
@@ -1866,7 +1986,6 @@ function isConversationOver(session) {
 function seedTranscriptStore(store, seed) {
   store.ingest({
     type: "snapshot",
-    protocol: SESSION_STREAM_PROTOCOL_VERSION,
     earliest_feed_seq: seed.earliestFeedSeq ?? null,
     session: seed.session,
     messages: [...seed.messages ?? []]
@@ -1894,13 +2013,13 @@ var SessionTranscriptStore = class {
   snapshot = EMPTY_SNAPSHOT;
   listeners = /* @__PURE__ */ new Set();
   acknowledged = /* @__PURE__ */ new Set();
-  // The inbox projection (protocol v3): message_received/delivered/requeued
+  // The inbox projection: message_received/delivered/requeued
   // RECORDS drive it; the snapshot seeds the pending set at connect. Keyed by
   // message id so a requeue can restore a message the delivered record
   // removed from the pending view.
   inbox = /* @__PURE__ */ new Map();
   // The resume cursor: the highest feed_seq received via records_append. Only
-  // records advance it (§3.4) — never messages/session frames. streamSession
+  // records advance it — never messages/session frames. streamSession
   // tracks its own copy; this one seeds a NEW streamSession call (e.g. a
   // page-level reconnect after unmount) from already-held state.
   cursorSeq = 0;
@@ -1933,7 +2052,7 @@ var SessionTranscriptStore = class {
   // The current pending set, in feed order — what queued chips render.
   pendingMessages = () => [...this.inbox.values()].filter((m) => m.status === "pending").sort((a, b) => (a.feed_seq ?? 0) - (b.feed_seq ?? 0));
   // Fold one lifecycle record into the inbox projection; returns whether the
-  // pending view changed. Unknown fields/types are ignored (§3.6).
+  // pending view changed. Unknown fields/types are ignored.
   applyMessageRecord = (record) => {
     if (record.kind !== "platform") return false;
     const payload = record.payload;
@@ -1984,7 +2103,7 @@ var SessionTranscriptStore = class {
     }
   };
   // Ingest one frame from the stream client. Unknown frame types stamp
-  // liveness and change nothing else (§3.6).
+  // liveness and change nothing else.
   ingest = (rawFrame) => {
     const prev = this.snapshot;
     const next = {

package/dist/stream/index.d.ts

@@ -1,10 +1,7 @@
-import { cS as StreamFrame, ca as Session } from '../types-sNAOvELB.js';
+import { d2 as StreamFrame, cm as Session } from '../types-BrLpRRde.js';
 
-declare const SESSION_STREAM_PROTOCOL_VERSION = 7;
 declare const WS_CLOSE_NORMAL = 1000;
 declare const WS_CLOSE_GOING_AWAY = 1001;
-declare const WS_CLOSE_UNSUPPORTED_PROTOCOL_VERSION = 1002;
-declare const WS_CLOSE_NO_PROTOCOL = 1003;
 declare const WS_CLOSE_AUTH_FAILED = 1008;
 declare const WS_CLOSE_SERVER_ERROR = 1011;
 declare const WS_CLOSE_OVER_CAPACITY = 1013;
@@ -38,11 +35,11 @@ type OpenSocket = (args: {
     query: string;
 }) => StreamSocket | Promise<StreamSocket>;
 declare function streamQuery(afterSeq: number): string;
-type CloseKind = 'normal' | 'auth' | 'unsupported' | 'retry';
+type CloseKind = 'normal' | 'auth' | 'retry';
 declare function classifyCloseCode(code: number): CloseKind;
 declare function nextReconnectDelayMs(attempt: number): number;
 interface ReconnectDecision {
-    action: 'reconnect' | 'fallback' | 'fail-auth';
+    action: 'reconnect' | 'give-up' | 'fail-auth';
     delayMs?: number;
 }
 declare function decideReconnect(params: {
@@ -61,4 +58,4 @@ interface StreamSessionOptions {
 }
 declare function streamSession(opts: StreamSessionOptions): Promise<StreamOutcome>;
 
-export { type CloseKind, type OpenSocket, type ReconnectDecision, SESSION_STREAM_PROTOCOL_VERSION, StreamAuthError, StreamFrame, type StreamOutcome, type StreamSessionOptions, type StreamSocket, StreamUnavailableError, WS_CLOSE_AUTH_FAILED, WS_CLOSE_GOING_AWAY, WS_CLOSE_NORMAL, WS_CLOSE_NO_PROTOCOL, WS_CLOSE_OVER_CAPACITY, WS_CLOSE_SERVER_ERROR, WS_CLOSE_UNSUPPORTED_PROTOCOL_VERSION, classifyCloseCode, decideReconnect, nextReconnectDelayMs, sessionStatusWord, streamQuery, streamSession };
+export { type CloseKind, type OpenSocket, type ReconnectDecision, StreamAuthError, StreamFrame, type StreamOutcome, type StreamSessionOptions, type StreamSocket, StreamUnavailableError, WS_CLOSE_AUTH_FAILED, WS_CLOSE_GOING_AWAY, WS_CLOSE_NORMAL, WS_CLOSE_OVER_CAPACITY, WS_CLOSE_SERVER_ERROR, classifyCloseCode, decideReconnect, nextReconnectDelayMs, sessionStatusWord, streamQuery, streamSession };

package/dist/stream/index.js

@@ -1,32 +1,198 @@
-import {
-  SESSION_STREAM_PROTOCOL_VERSION,
-  StreamAuthError,
-  StreamUnavailableError,
-  WS_CLOSE_AUTH_FAILED,
-  WS_CLOSE_GOING_AWAY,
-  WS_CLOSE_NORMAL,
-  WS_CLOSE_NO_PROTOCOL,
-  WS_CLOSE_OVER_CAPACITY,
-  WS_CLOSE_SERVER_ERROR,
-  WS_CLOSE_UNSUPPORTED_PROTOCOL_VERSION,
-  classifyCloseCode,
-  decideReconnect,
-  nextReconnectDelayMs,
-  sessionStatusWord,
-  streamQuery,
-  streamSession
-} from "../chunk-6V7QTLLF.js";
+// src/stream/index.ts
+var WS_CLOSE_NORMAL = 1e3;
+var WS_CLOSE_GOING_AWAY = 1001;
+var WS_CLOSE_AUTH_FAILED = 1008;
+var WS_CLOSE_SERVER_ERROR = 1011;
+var WS_CLOSE_OVER_CAPACITY = 1013;
+function sessionStatusWord(session) {
+  return session.turn?.status ?? "none";
+}
+var StreamUnavailableError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "StreamUnavailableError";
+  }
+};
+var StreamAuthError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "StreamAuthError";
+  }
+};
+function streamQuery(afterSeq) {
+  return afterSeq > 0 ? `after_seq=${afterSeq}` : "";
+}
+var HEARTBEAT_TIMEOUT_MS = 45e3;
+var DEFAULT_MAX_RECONNECTS = 5;
+function classifyCloseCode(code) {
+  switch (code) {
+    case WS_CLOSE_NORMAL:
+      return "normal";
+    case WS_CLOSE_AUTH_FAILED:
+    case 4401:
+    // dashboard ticket door: bad/expired ticket
+    case 4403:
+      return "auth";
+    default:
+      return "retry";
+  }
+}
+function nextReconnectDelayMs(attempt) {
+  const base = 500;
+  const max = 8e3;
+  return Math.min(max, base * 2 ** Math.max(0, attempt - 1));
+}
+function decideReconnect(params) {
+  const { closeKind, everReceivedFrame, attempt, maxReconnects } = params;
+  if (closeKind === "auth") return { action: "fail-auth" };
+  const cap = everReceivedFrame ? maxReconnects : Math.min(2, maxReconnects);
+  if (attempt >= cap) return { action: "give-up" };
+  return { action: "reconnect", delayMs: nextReconnectDelayMs(attempt) };
+}
+function connectOnce(sock, emit, signal) {
+  return new Promise((resolve) => {
+    let settled = false;
+    let heartbeat;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      if (heartbeat) clearTimeout(heartbeat);
+      if (signal) signal.removeEventListener("abort", onAbort);
+      sock.close();
+      resolve(result);
+    };
+    const onAbort = () => finish({ kind: "aborted" });
+    const bumpHeartbeat = () => {
+      if (heartbeat) clearTimeout(heartbeat);
+      heartbeat = setTimeout(
+        () => finish({ kind: "error", err: new Error("heartbeat timeout") }),
+        HEARTBEAT_TIMEOUT_MS
+      );
+    };
+    if (signal) {
+      if (signal.aborted) {
+        finish({ kind: "aborted" });
+        return;
+      }
+      signal.addEventListener("abort", onAbort);
+    }
+    sock.onOpen(() => bumpHeartbeat());
+    sock.onMessage((data) => {
+      bumpHeartbeat();
+      let frame;
+      try {
+        frame = JSON.parse(data);
+      } catch {
+        return;
+      }
+      if (!frame || ![
+        "snapshot",
+        "records_append",
+        "session",
+        "delta",
+        "heartbeat",
+        "done",
+        "error"
+      ].includes(frame.type))
+        return;
+      emit(frame);
+      if (frame.type === "done") {
+        finish({ kind: "done" });
+      } else if (frame.type === "error") {
+        finish({
+          kind: "frameError",
+          message: frame.message ?? "stream error"
+        });
+      }
+    });
+    sock.onClose((code) => finish({ kind: "closed", code }));
+    sock.onError((err) => finish({ kind: "error", err }));
+  });
+}
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        resolve();
+      },
+      { once: true }
+    );
+  });
+}
+async function streamSession(opts) {
+  const maxReconnects = opts.maxReconnects ?? DEFAULT_MAX_RECONNECTS;
+  let afterSeq = opts.afterSeq ?? 0;
+  let everReceivedFrame = false;
+  let attempt = 0;
+  let lastStatusWord = "";
+  let lastReason = null;
+  const emit = (frame) => {
+    everReceivedFrame = true;
+    attempt = 0;
+    if (frame.type === "records_append") {
+      const records = frame.records;
+      for (const record of records) {
+        if (typeof record.feed_seq === "number") {
+          afterSeq = Math.max(afterSeq, record.feed_seq);
+        }
+      }
+    } else if (frame.type === "snapshot" || frame.type === "session") {
+      const session = frame.session;
+      lastStatusWord = sessionStatusWord(session);
+      lastReason = session.turn?.reason ?? null;
+    }
+    opts.onFrame(frame);
+  };
+  for (; ; ) {
+    if (opts.signal?.aborted) return { type: "aborted" };
+    let res;
+    try {
+      const sock = await opts.openSocket({
+        sessionId: opts.sessionId,
+        afterSeq,
+        query: streamQuery(afterSeq)
+      });
+      res = await connectOnce(sock, emit, opts.signal);
+    } catch (err) {
+      res = {
+        kind: "error",
+        err: err instanceof Error ? err : new Error(String(err))
+      };
+    }
+    if (res.kind === "done") {
+      return { type: "done", status: lastStatusWord, reason: lastReason };
+    }
+    if (res.kind === "frameError")
+      return { type: "error", message: res.message };
+    if (res.kind === "aborted") return { type: "aborted" };
+    attempt++;
+    const decision = decideReconnect({
+      closeKind: res.kind === "closed" ? classifyCloseCode(res.code) : void 0,
+      everReceivedFrame,
+      attempt,
+      maxReconnects
+    });
+    if (decision.action === "fail-auth") {
+      throw new StreamAuthError("not authorized to stream this session");
+    }
+    if (decision.action === "give-up") {
+      const why = res.kind === "error" ? res.err.message : `stream closed (code ${res.code})`;
+      throw new StreamUnavailableError(why);
+    }
+    await sleep(decision.delayMs ?? 0, opts.signal);
+  }
+}
 export {
-  SESSION_STREAM_PROTOCOL_VERSION,
   StreamAuthError,
   StreamUnavailableError,
   WS_CLOSE_AUTH_FAILED,
   WS_CLOSE_GOING_AWAY,
   WS_CLOSE_NORMAL,
-  WS_CLOSE_NO_PROTOCOL,
   WS_CLOSE_OVER_CAPACITY,
   WS_CLOSE_SERVER_ERROR,
-  WS_CLOSE_UNSUPPORTED_PROTOCOL_VERSION,
   classifyCloseCode,
   decideReconnect,
   nextReconnectDelayMs,