@vinaverse/client 0.0.0-stage → 0.1.0-alpha.2

package/dist/chunk-AWHPWRGT.js

@@ -0,0 +1,1318 @@
+// src/contract.ts
+var CONTRACT = {
+  api: "v1-draft.17",
+  commit: "fe4fb7d2945e1ced2bce7d44e85a4b28005e46df"
+};
+
+// src/engine.ts
+var UNLOCKS_KEEP_LOCKED = /* @__PURE__ */ new Set([
+  "card_superseded",
+  "client_event_id_reused"
+]);
+var RESEND = /* @__PURE__ */ new Set(["turn_in_progress", "screen_unavailable"]);
+var FLOW_RESULTS = /* @__PURE__ */ new Set(["ok", "refused", "failed"]);
+var OUTCOMES = /* @__PURE__ */ new Set(["confirmed", "declined", "failed", "expired"]);
+var RECONNECTABLE = /* @__PURE__ */ new Set(["server_restart"]);
+var NEW_SESSION = /* @__PURE__ */ new Set(["idle", "expired", "limit_reached"]);
+var str = (v) => typeof v === "string" ? v : void 0;
+var ConversationEngine = class {
+  sessionId = null;
+  conversationId = null;
+  connection = null;
+  reconnect = "allowed";
+  messages = [];
+  cards = /* @__PURE__ */ new Map();
+  unacknowledged = /* @__PURE__ */ new Map();
+  resend = [];
+  held = [];
+  refused = {};
+  flow = null;
+  turn = null;
+  tools = [];
+  handoffs = [];
+  errors = [];
+  expiring = null;
+  streaming = null;
+  takeover = null;
+  rejections = {};
+  disclosure = null;
+  turnsLeft = null;
+  /** The next arrival number for a message or a card. */
+  seq = 0;
+  /** The cards drawn before a resumed flow's transcript replaced them: proposal outcomes carry over. */
+  replaced = null;
+  /** client_event_id → the first event the app sent under it, until it is settled. */
+  inputs = /* @__PURE__ */ new Map();
+  // ------------------------------------------------------------ what happens around the frames
+  /** The tenant's backend created a session (and named its conversation). */
+  sessionCreated(sessionId, conversationId) {
+    this.sessionId = sessionId;
+    this.conversationId = conversationId ?? null;
+  }
+  /** A connection opened: the user's own action, or an allowed reconnect, so it lifts a hold on reconnecting. */
+  connected(name) {
+    this.connection = { name, state: "open" };
+    this.reconnect = "allowed";
+  }
+  /** A connection closed with its code. `4403` (revoked) and `4409` (replaced) hold reconnecting for a user action. */
+  closed(name, code) {
+    if (this.connection?.name !== name) return;
+    this.connection.state = "closed";
+    this.connection.code = code;
+    if (this.connection.reason === void 0) {
+      if (code === 4403 || code === 4409) this.reconnect = "user_action_only";
+      else if (code === 4408) this.reconnect = "new_session_on_next_action";
+    }
+    this.cutOff("interrupted");
+    this.turn = null;
+  }
+  /** The app was killed: what it drew is gone; what it sent and never saw acknowledged it kept, to resend. */
+  killed() {
+    this.messages = [];
+    this.cards = /* @__PURE__ */ new Map();
+    this.turn = null;
+    this.streaming = null;
+    this.takeover = null;
+  }
+  // ------------------------------------------------------------ what the app sends
+  sent(event) {
+    const id = str(event.client_event_id);
+    switch (event.type) {
+      case "ui.answer": {
+        if (id === void 0) return;
+        if (!this.inputs.has(id)) this.inputs.set(id, event);
+        this.unqueue(id);
+        this.unacknowledged.set(id, event);
+        const card = this.cards.get(str(event.card_id) ?? "");
+        const questionId = str(event.question_id);
+        if (card && questionId) lock(card, questionId);
+        return;
+      }
+      case "input.text": {
+        if (id === void 0) return;
+        if (!this.inputs.has(id)) this.inputs.set(id, event);
+        this.unqueue(id);
+        delete this.refused[id];
+        this.unacknowledged.set(id, event);
+        return;
+      }
+      case "ui.action": {
+        if (id !== void 0) {
+          if (!this.inputs.has(id)) this.inputs.set(id, event);
+          this.unqueue(id);
+          this.unacknowledged.set(id, event);
+        }
+        const card = this.cards.get(str(event.card_id) ?? "");
+        const action = str(event.action);
+        if (card?.kind === "proposal" && action && OUTCOMES.has(action) && card.outcome === null) {
+          card.outcome = action;
+          if (id !== void 0) card.outcomeBy = id;
+        }
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  // ------------------------------------------------------------ what the server sends
+  received(event) {
+    switch (event.type) {
+      case "session.ready":
+        this.ready(event);
+        return;
+      case "turn.started": {
+        this.turn = str(event.turn_id) ?? null;
+        const id = str(event.client_event_id);
+        if (id !== void 0) {
+          const sent = this.inputs.get(id);
+          this.settle(id);
+          if (sent?.type === "input.text") {
+            this.say("person", str(sent.text) ?? "", id);
+          }
+        }
+        return;
+      }
+      case "message.delta": {
+        const turnId = str(event.turn_id) ?? "";
+        const text = str(event.text) ?? "";
+        if (this.streaming?.turnId === turnId)
+          this.streaming = {
+            ...this.streaming,
+            text: this.streaming.text + text
+          };
+        else {
+          this.cutOff("interrupted");
+          this.streaming = { turnId, text, seq: this.seq++ };
+        }
+        return;
+      }
+      case "message.completed": {
+        const turnId = str(event.turn_id) ?? "";
+        const streaming = this.streaming?.turnId === turnId ? this.streaming : null;
+        if (streaming) this.streaming = null;
+        this.say(
+          "assistant",
+          str(event.text) ?? "",
+          `a:${turnId}`,
+          {},
+          streaming?.seq
+        );
+        return;
+      }
+      case "ui.cards":
+        for (const card of asArray(event.cards))
+          this.hold(card, str(event.turn_id));
+        return;
+      case "tool.status": {
+        const line = {
+          turn_id: str(event.turn_id) ?? "",
+          label: str(event.label) ?? "",
+          state: str(event.state) ?? ""
+        };
+        const at = this.tools.findIndex(
+          (t) => t.turn_id === line.turn_id && t.label === line.label
+        );
+        if (at === -1) this.tools = [...this.tools, line].slice(-100);
+        else this.tools[at] = line;
+        return;
+      }
+      case "handoff.created":
+        this.handoffs.push(event.ticket);
+        return;
+      case "turn.completed":
+        this.turn = null;
+        return;
+      case "turn.failed": {
+        const code = str(event.code) ?? "";
+        if (this.streaming?.turnId === str(event.turn_id))
+          this.cutOff(
+            code === "output_blocked" ? "blocked" : code === "cancelled" ? "interrupted" : "failed"
+          );
+        this.turn = null;
+        this.error(code);
+        return;
+      }
+      case "takeover.started":
+        this.takeover = {
+          by: str(event.by) ?? null,
+          at: str(event.at) ?? ""
+        };
+        return;
+      case "takeover.ended":
+        this.takeover = null;
+        return;
+      case "message.staff": {
+        const id = str(event.message_id);
+        if (id !== void 0)
+          this.say("staff", str(event.text) ?? "", `s:${id}`);
+        return;
+      }
+      case "input.received": {
+        const id = str(event.client_event_id);
+        if (id === void 0) return;
+        const sent = this.inputs.get(id);
+        this.settle(id);
+        if (sent?.type === "input.text")
+          this.say("person", str(sent.text) ?? "", id, { received: true });
+        return;
+      }
+      case "ui.answer.recorded":
+        this.recorded(event);
+        return;
+      case "ui.answer.rejected":
+        this.rejected(event);
+        return;
+      case "input.rejected":
+        this.inputRejected(event);
+        return;
+      case "flow.completed": {
+        const result = str(event.result) ?? "";
+        this.flow = {
+          flow: event.flow,
+          result: FLOW_RESULTS.has(result) ? result : "failed"
+        };
+        return;
+      }
+      case "session.closed": {
+        const reason = str(event.reason);
+        if (reason === void 0) return;
+        if (NEW_SESSION.has(reason))
+          this.reconnect = "new_session_on_next_action";
+        else if (!RECONNECTABLE.has(reason))
+          this.reconnect = "user_action_only";
+        if (this.connection) this.connection.reason = reason;
+        return;
+      }
+      case "session.expiring":
+        this.expiring = typeof event.seconds_left === "number" ? event.seconds_left : null;
+        return;
+      case "error": {
+        this.error(str(event.code) ?? "");
+        const id = str(event.client_event_id);
+        if (id !== void 0 && event.code === "screen_unavailable") {
+          this.inputRejected(event);
+        } else if (id !== void 0) {
+          this.settle(id);
+        }
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  ready(event) {
+    const session = event.session;
+    this.sessionId = str(session?.id) ?? this.sessionId;
+    this.turn = null;
+    this.expiring = null;
+    this.disclosure = str(event.disclosure) ?? this.disclosure;
+    const limits = event.limits;
+    this.turnsLeft = typeof limits?.turns_left === "number" ? limits.turns_left : null;
+    this.takeover = null;
+    this.cutOff("interrupted");
+    if (event.resumed !== true) return;
+    if (event.transcript !== void 0) {
+      this.messages = [];
+      this.replaced = this.cards;
+      this.cards = /* @__PURE__ */ new Map();
+      for (const item of asArray(event.transcript)) {
+        if (item.role === "card")
+          this.hold(item.card);
+        else {
+          const role = str(item.role) ?? "";
+          this.say(
+            role,
+            str(item.text) ?? "",
+            transcriptKey(role, str(item.id), str(item.at)),
+            item.interrupted === true ? { partial: "interrupted" } : {}
+          );
+        }
+      }
+    }
+    for (const card of asArray(event.pending_cards))
+      this.hold(card, str(card.turn_id));
+    this.replaced = null;
+  }
+  hold(raw, turnId) {
+    if (!raw) return;
+    const id = str(raw.id);
+    if (id === void 0) return;
+    const kind = str(raw.kind) ?? "";
+    const question = raw.question;
+    const card = {
+      id,
+      kind,
+      card: raw,
+      ...question ? { question: structuredCopy(question) } : {},
+      locked: lockedFrom(question),
+      ...turnId !== void 0 ? { turnId } : {},
+      // A card still held keeps its place when it is drawn again (a reconnect's pending cards, a repeated ui.cards).
+      seq: this.cards.get(id)?.seq ?? this.seq++
+    };
+    for (const held of this.held) {
+      const sent = this.inputs.get(held);
+      if (sent?.type === "ui.answer" && sent.card_id === id) {
+        const questionId = str(sent.question_id);
+        if (questionId !== void 0) lock(card, questionId);
+      }
+    }
+    if (kind === "proposal") {
+      const held = this.cards.get(id) ?? this.replaced?.get(id);
+      card.outcome = held?.outcome ?? null;
+      if (held?.outcomeBy !== void 0) card.outcomeBy = held.outcomeBy;
+    }
+    this.cards.delete(id);
+    this.cards.set(id, card);
+  }
+  recorded(event) {
+    const id = str(event.client_event_id) ?? "";
+    const card = this.cards.get(str(event.card_id) ?? "");
+    const sent = this.inputs.get(id);
+    this.settle(id);
+    if (!card?.question || !sent) return;
+    const q = card.question;
+    const questionId = str(event.question_id) ?? "";
+    lock(card, questionId);
+    if (q.kind === "rate_each") {
+      const rows = (q.row_answers ?? []).filter(
+        (r) => r.question_id !== questionId
+      );
+      q.row_answers = [
+        ...rows,
+        { question_id: questionId, answer: sent.answer }
+      ];
+      const answered = q.row_answers;
+      if ((q.rows ?? []).every(
+        (r) => answered.some((a) => a.question_id === r.question_id)
+      )) {
+        q.state = "answered";
+        lock(card, q.question_id);
+      }
+    } else {
+      q.answer = sent.answer;
+      q.state = "answered";
+    }
+  }
+  rejected(event) {
+    this.settle(str(event.client_event_id) ?? "");
+    const card = this.cards.get(str(event.card_id) ?? "");
+    const questionId = str(event.question_id);
+    if (!card || questionId === void 0) return;
+    if (UNLOCKS_KEEP_LOCKED.has(str(event.code) ?? "")) lock(card, questionId);
+    else unlock(card, questionId);
+  }
+  inputRejected(event) {
+    const id = str(event.client_event_id);
+    if (id === void 0) return;
+    this.unacknowledged.delete(id);
+    const code = str(event.code) ?? "";
+    this.rejections[id] = { code, message: str(event.message) ?? "" };
+    if (RESEND.has(code)) {
+      if (!this.resend.includes(id)) this.resend.push(id);
+      return;
+    }
+    if (code === "limit_reached") {
+      this.unqueue(id);
+      const kind = this.inputs.get(id)?.type;
+      if (kind === "input.text" || kind === "ui.answer") {
+        if (!this.held.includes(id)) this.held.push(id);
+      } else this.inputs.delete(id);
+      this.reconnect = "new_session_on_next_action";
+      return;
+    }
+    if (code !== "duplicate") this.refused[id] = code;
+    const sent = this.inputs.get(id);
+    if (code === "guardrail" && sent?.type === "input.text") {
+      this.say("person", str(sent.text) ?? "", id);
+      this.say("assistant", str(event.message) ?? "", `r:${id}`, {
+        refusal: true
+      });
+    }
+    this.inputs.delete(id);
+  }
+  /** No longer to resend, nor held for the next session (sent again, or settled). */
+  unqueue(id) {
+    this.resend = this.resend.filter((r) => r !== id);
+    this.held = this.held.filter((r) => r !== id);
+  }
+  /** An input acknowledged or refused for good: nothing more is resent under its id. */
+  settle(id) {
+    delete this.rejections[id];
+    this.unacknowledged.delete(id);
+    this.inputs.delete(id);
+    this.unqueue(id);
+  }
+  /** Adds a message once: a key already held (a frame seen twice) changes nothing. */
+  say(role, text, key, extra = {}, seq = this.seq++) {
+    if (this.messages.some((m) => m.key === key)) return;
+    this.messages.push({ role, text, key, seq, ...extra });
+  }
+  /** The turn's streamed text, kept as the agent's message when the turn ends without its `message.completed`. */
+  cutOff(partial) {
+    const streaming = this.streaming;
+    this.streaming = null;
+    const text = streaming?.text.trim();
+    if (streaming && text)
+      this.say(
+        "assistant",
+        text,
+        `a:${streaming.turnId}`,
+        { partial },
+        streaming.seq
+      );
+  }
+  error(code) {
+    this.errors = [...this.errors, code].slice(-100);
+  }
+  /**
+   * An input that could not be delivered, or whose retries are spent (`screen_unavailable` after the last try): it is
+   * no longer resent. A typed message is shown as not sent, with `code`; an answer's question unlocks so the person
+   * can answer again; a proposal outcome it reported is taken back, so it can be reported again.
+   */
+  giveUp(clientEventId, code) {
+    const sent = this.inputs.get(clientEventId);
+    if (!sent) return;
+    const rejection = this.rejections[clientEventId];
+    this.resend = this.resend.filter((r) => r !== clientEventId);
+    this.settle(clientEventId);
+    const card = this.cards.get(str(sent.card_id) ?? "");
+    if (sent.type === "input.text") {
+      this.refused[clientEventId] = code;
+      if (rejection) this.rejections[clientEventId] = rejection;
+    } else if (sent.type === "ui.answer") {
+      const questionId = str(sent.question_id);
+      if (card && questionId !== void 0) unlock(card, questionId);
+    } else if (card?.outcomeBy === clientEventId) {
+      card.outcome = null;
+      delete card.outcomeBy;
+    }
+  }
+  /** A turn the app stopped where no event will say so (an SSE turn cancelled): none is in progress. */
+  turnEnded() {
+    this.turn = null;
+  }
+  // ------------------------------------------------------------ reading it
+  /** The event first sent under a `client_event_id`, to resend it unchanged. */
+  input(clientEventId) {
+    return this.inputs.get(clientEventId);
+  }
+  state() {
+    const cards = [...this.cards.values()].map(freeze);
+    const open = cards.filter(
+      (c) => c.kind === "question" && c.question?.state === "open"
+    );
+    return {
+      sessionId: this.sessionId,
+      conversationId: this.conversationId,
+      connection: this.connection ? { ...this.connection } : null,
+      reconnect: this.reconnect,
+      messages: [...this.messages],
+      cards,
+      openQuestion: open.length ? open[open.length - 1].id : null,
+      unacknowledged: [...this.unacknowledged.values()],
+      resend: [...this.resend],
+      held: [...this.held],
+      refused: { ...this.refused },
+      flow: this.flow,
+      turn: this.turn,
+      tools: [...this.tools],
+      handoffs: [...this.handoffs],
+      errors: [...this.errors],
+      streaming: this.streaming,
+      takeover: this.takeover,
+      rejections: { ...this.rejections },
+      disclosure: this.disclosure,
+      turnsLeft: this.turnsLeft,
+      heldForNextSession: this.reconnect === "new_session_on_next_action" ? [
+        .../* @__PURE__ */ new Set([
+          ...this.unacknowledged.keys(),
+          ...this.resend,
+          ...this.held
+        ])
+      ] : [],
+      expiring: this.expiring
+    };
+  }
+};
+function transcriptKey(role, id, at) {
+  if (id === void 0) return `t:${at ?? ""}:${role}`;
+  if (role === "assistant") return `a:${id}`;
+  if (role === "staff") return `s:${id}`;
+  return id;
+}
+function lockedFrom(question) {
+  if (!question) return [];
+  if (question.state !== "open") {
+    return [
+      question.question_id,
+      ...(question.rows ?? []).map((r) => r.question_id)
+    ];
+  }
+  return (question.row_answers ?? []).map((r) => r.question_id);
+}
+function lock(card, id) {
+  if (!card.locked.includes(id)) card.locked.push(id);
+}
+function unlock(card, id) {
+  card.locked = card.locked.filter((q) => q !== id);
+}
+function freeze(card) {
+  return {
+    id: card.id,
+    kind: card.kind,
+    card: card.card,
+    ...card.question ? { question: { ...card.question } } : {},
+    locked: [...card.locked],
+    ...card.turnId !== void 0 ? { turnId: card.turnId } : {},
+    ...card.outcome !== void 0 ? { outcome: card.outcome } : {},
+    seq: card.seq
+  };
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function structuredCopy(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/errors.ts
+var VinaverseClientError = class extends Error {
+  name = "VinaverseClientError";
+  code;
+  status;
+  constructor(code, message, status) {
+    super(message);
+    this.code = code;
+    this.status = status;
+  }
+};
+
+// src/events.ts
+var CARD_KINDS = {
+  professional: true,
+  workspace: true,
+  service: true,
+  time_slots: true,
+  booking: true,
+  quote: true,
+  policy: true,
+  handoff: true,
+  metric_chart: true,
+  metric_table: true,
+  gap_list: true,
+  cluster: true,
+  claim: true,
+  document: true,
+  question: true,
+  proposal: true,
+  next_step: true
+};
+function isKnownCard(card) {
+  return Object.hasOwn(CARD_KINDS, card.kind);
+}
+
+// src/secret.ts
+var CLIENT_SECRET = /^vv_cs_[A-Za-z0-9_-]{16,}$/;
+function clientSecret(value) {
+  const secret = typeof value === "object" && value !== null ? value.value : value;
+  if (typeof secret === "string" && secret.startsWith("vv_sk_")) {
+    throw new VinaverseClientError(
+      "service_key",
+      "A Vinaverse service key belongs on your backend only. Pass the session client secret (vv_cs_\u2026) to the app."
+    );
+  }
+  if (typeof secret !== "string" || !CLIENT_SECRET.test(secret)) {
+    throw new VinaverseClientError(
+      "invalid_secret",
+      "Expected a session client secret (vv_cs_\u2026)."
+    );
+  }
+  return secret;
+}
+
+// src/sse.ts
+var MAX_EVENT_CHARS = 1024 * 1024;
+function turnSse(target, input) {
+  return post(target, target.turnsUrl, input);
+}
+function cardActionSse(target, turnId, input) {
+  return post(
+    target,
+    `${target.turnsUrl.replace(/\/+$/, "")}/${encodeURIComponent(turnId)}/actions`,
+    input
+  );
+}
+async function* post(target, url, body) {
+  const doFetch = target.fetch ?? globalThis.fetch;
+  const response = await doFetch(url, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${target.secret}`,
+      "content-type": "application/json",
+      accept: "text/event-stream"
+    },
+    body: JSON.stringify(body),
+    ...target.signal ? { signal: target.signal } : {}
+  });
+  if (!response.ok) {
+    throw new VinaverseClientError(
+      "http_error",
+      `The turn request failed with HTTP ${response.status}.`,
+      response.status
+    );
+  }
+  const chunks = response.body ? decode(response.body) : once(await response.text());
+  yield* sseFrames(chunks);
+}
+async function* sseFrames(chunks) {
+  let buffer = "";
+  for await (const chunk of chunks) {
+    buffer += chunk;
+    if (buffer.length > MAX_EVENT_CHARS && boundary(buffer) === null) {
+      throw new VinaverseClientError(
+        "http_error",
+        "An SSE event is larger than 1 MiB."
+      );
+    }
+    let end = boundary(buffer);
+    while (end !== null) {
+      const frame = parseEvent(buffer.slice(0, end.at));
+      buffer = buffer.slice(end.at + end.length);
+      if (frame) yield frame;
+      end = boundary(buffer);
+    }
+  }
+  const last = parseEvent(buffer);
+  if (last) yield last;
+}
+function boundary(buffer) {
+  const match = /\r?\n\r?\n|\r\r/.exec(buffer);
+  return match ? { at: match.index, length: match[0].length } : null;
+}
+function parseEvent(block) {
+  let type;
+  const data = [];
+  for (const line of block.split(/\r?\n|\r/)) {
+    if (line === "" || line.startsWith(":")) continue;
+    const colon = line.indexOf(":");
+    const field = colon === -1 ? line : line.slice(0, colon);
+    let value = colon === -1 ? "" : line.slice(colon + 1);
+    if (value.startsWith(" ")) value = value.slice(1);
+    if (field === "event") type = value;
+    else if (field === "data") data.push(value);
+  }
+  if (data.length === 0) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(data.join("\n"));
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+    return null;
+  const frame = parsed;
+  const kind = typeof frame.type === "string" ? frame.type : type;
+  return kind === void 0 ? null : { ...frame, type: kind };
+}
+async function* decode(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      yield decoder.decode(value, { stream: true });
+    }
+    const rest = decoder.decode();
+    if (rest) yield rest;
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function* once(text) {
+  yield text;
+}
+
+// src/session.ts
+var OPEN = 1;
+var SUBPROTOCOL = "vinaverse.v1";
+var DEFAULT_RECONNECT = [1e3, 2e3, 4e3, 8e3, 16e3, 3e4];
+var DEFAULT_SCREEN_RETRY = [2e3, 4e3, 8e3];
+var NO_RECONNECT = /* @__PURE__ */ new Set([4403, 4409]);
+var FALLBACK_AFTER = 2;
+var STABLE_MS = 3e4;
+var VinaverseSession = class {
+  engine;
+  info;
+  secret;
+  options;
+  socket = null;
+  /** The engine's name for the connection in `socket`, once it opened. */
+  opened = null;
+  connection = 0;
+  ready = false;
+  current = "idle";
+  everOpened = false;
+  firstFailures = 0;
+  attempts = 0;
+  /** The reason of the `session.closed` that preceded the close, on the current connection. */
+  closeReason = null;
+  stableTimer;
+  /** SSE requests in flight. */
+  streams = /* @__PURE__ */ new Map();
+  reconnectTimer;
+  pingTimer;
+  foreground = true;
+  refreshed = false;
+  /** client_event_id → why it waits: after the turn, or after a backoff. */
+  waiting = /* @__PURE__ */ new Map();
+  /** client_event_id → the session that refused it for its turn limit: resent only on another session. */
+  heldForSession = /* @__PURE__ */ new Map();
+  screenTries = /* @__PURE__ */ new Map();
+  screenTimers = /* @__PURE__ */ new Map();
+  listeners = {
+    event: /* @__PURE__ */ new Set(),
+    state: /* @__PURE__ */ new Set(),
+    status: /* @__PURE__ */ new Set(),
+    error: /* @__PURE__ */ new Set()
+  };
+  constructor(options) {
+    this.options = options;
+    this.info = options.session;
+    this.secret = clientSecret(options.session.client_secret);
+    this.engine = options.engine ?? new ConversationEngine();
+    this.named(options.session);
+  }
+  /** The engine names the session, and keeps the conversation it already knew when this one does not say. */
+  named(session) {
+    this.engine.sessionCreated(
+      session.id,
+      session.conversation_id ?? this.engine.state().conversationId
+    );
+  }
+  get status() {
+    return this.current;
+  }
+  get state() {
+    return this.engine.state();
+  }
+  on(name, listener) {
+    this.listeners[name].add(listener);
+    return () => this.listeners[name].delete(listener);
+  }
+  // ------------------------------------------------------------ connecting
+  /**
+   * Connect, or reconnect: the user's own action, so it also resumes after the conversation continued elsewhere
+   * or the secret was refused.
+   */
+  connect() {
+    if (this.current === "closed") throw ended();
+    if (this.engine.state().reconnect === "new_session_on_next_action") {
+      throw new VinaverseClientError(
+        "needs_new_session",
+        "This session has ended; create a new session for the conversation and call resume() with it."
+      );
+    }
+    this.start();
+  }
+  start() {
+    this.cancelReconnect();
+    this.attempts = 0;
+    this.refreshed = false;
+    this.open();
+  }
+  /**
+   * Continue the conversation on a new session the tenant's backend created for it (by `conversation_key` or
+   * `conversation_id`): its `session.ready` brings the transcript and pending cards, and what was never
+   * acknowledged is resent there. A user action, like `connect()`.
+   */
+  resume(session) {
+    const secret = clientSecret(session.client_secret);
+    if (this.current === "closed") throw ended();
+    this.info = session;
+    this.secret = secret;
+    this.named(session);
+    this.drop(1e3);
+    this.start();
+  }
+  /** Close for good: the connection, any SSE turn still streaming, and every timer. */
+  close() {
+    this.cancelReconnect();
+    this.drop(1e3);
+    this.stopSse("close");
+    for (const timer of this.screenTimers.values()) clearTimeout(timer);
+    this.screenTimers.clear();
+    this.setStatus("closed");
+  }
+  /** Ping only while the app is in the foreground (every 25 s); in the background the connection may idle out. */
+  setForeground(foreground) {
+    this.foreground = foreground;
+    if (foreground && this.ready) this.startPing();
+    else this.stopPing();
+  }
+  open() {
+    this.drop(1e3);
+    const factory = this.options.webSocket ?? defaultWebSocket();
+    if (!factory) {
+      this.fallBack();
+      return;
+    }
+    const auth = this.options.auth ?? "subprotocol";
+    const protocols = auth === "subprotocol" ? [SUBPROTOCOL, `bearer.${this.secret}`] : [SUBPROTOCOL];
+    const headers = auth === "header" ? { authorization: `Bearer ${this.secret}` } : void 0;
+    const name = `c${++this.connection}`;
+    this.closeReason = null;
+    let socket;
+    try {
+      socket = factory(this.info.realtime_url, protocols, headers);
+    } catch {
+      this.fallBack();
+      return;
+    }
+    this.socket = socket;
+    this.ready = false;
+    this.setStatus(this.attempts > 0 ? "reconnecting" : "connecting");
+    socket.onopen = () => {
+      if (this.socket !== socket) return;
+      this.opened = name;
+      this.everOpened = true;
+      this.engine.connected(name);
+      this.emitState();
+      if (auth === "first_frame")
+        socket.send(
+          JSON.stringify({ type: "session.auth", client_secret: this.secret })
+        );
+    };
+    socket.onmessage = (event) => {
+      if (this.socket === socket) this.frame(event.data);
+    };
+    socket.onerror = () => {
+    };
+    socket.onclose = (event) => {
+      if (this.socket !== socket) return;
+      const opened = this.opened !== null;
+      this.forget(event.code);
+      this.afterClose(event.code, opened);
+    };
+  }
+  afterClose(code, opened) {
+    if (this.current === "closed") return;
+    if (this.engine.state().reconnect !== "allowed" || NO_RECONNECT.has(code)) {
+      this.setStatus("ended");
+      return;
+    }
+    if (code === 4401) {
+      this.refresh();
+      return;
+    }
+    if (!opened && !this.everOpened) {
+      this.firstFailures++;
+      if (this.firstFailures >= FALLBACK_AFTER && this.options.sseFallback !== false) {
+        this.fallBack();
+        return;
+      }
+      this.scheduleReconnect();
+      return;
+    }
+    if (this.closeReason === "server_restart") {
+      this.scheduleReconnect();
+      return;
+    }
+    if (code === 1e3) {
+      this.setStatus("idle");
+      return;
+    }
+    this.scheduleReconnect();
+  }
+  /** After a 4401: one fresh secret for the session in use, unless it moved on or was closed meanwhile. */
+  refresh() {
+    const refreshSecret = this.options.refreshSecret;
+    if (!refreshSecret || this.refreshed) {
+      this.setStatus("unauthorized");
+      return;
+    }
+    this.refreshed = true;
+    const sessionId = this.info.id;
+    const current = () => this.current !== "closed" && this.info.id === sessionId;
+    refreshSecret(sessionId).then((fresh) => {
+      if (!current()) return;
+      this.secret = clientSecret(fresh);
+      this.open();
+    }).catch((error) => {
+      if (!current()) return;
+      this.setStatus("unauthorized");
+      this.emit("error", asClientError(error, "invalid_secret"));
+    });
+  }
+  scheduleReconnect() {
+    const max = this.options.maxReconnects ?? 8;
+    if (this.attempts >= max) {
+      this.setStatus("idle");
+      return;
+    }
+    const delays = this.options.reconnectDelays ?? DEFAULT_RECONNECT;
+    const delay = delays[Math.min(this.attempts, delays.length - 1)] ?? 0;
+    this.attempts++;
+    this.setStatus("reconnecting");
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = void 0;
+      this.open();
+    }, delay);
+  }
+  cancelReconnect() {
+    if (this.reconnectTimer !== void 0) clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = void 0;
+  }
+  fallBack() {
+    this.socket = null;
+    if (this.options.sseFallback === false) {
+      this.setStatus("idle");
+      return;
+    }
+    this.setStatus("sse");
+    for (const event of this.engine.state().unacknowledged) this.overSse(event);
+    if (this.streams.size === 0) this.resendWaiting("turn");
+  }
+  /** Close the current connection, if any, without reacting to its close event. */
+  drop(code) {
+    const socket = this.socket;
+    this.forget(code);
+    if (socket && socket.readyState <= OPEN) {
+      try {
+        socket.close(code);
+      } catch {
+      }
+    }
+  }
+  forget(code) {
+    this.socket = null;
+    this.ready = false;
+    this.stopPing();
+    if (this.stableTimer !== void 0) clearTimeout(this.stableTimer);
+    this.stableTimer = void 0;
+    if (this.opened !== null) {
+      this.engine.closed(this.opened, code);
+      this.opened = null;
+      this.emitState();
+    }
+  }
+  // ------------------------------------------------------------ receiving
+  frame(data) {
+    if (typeof data !== "string") return;
+    let parsed;
+    try {
+      parsed = JSON.parse(data);
+    } catch {
+      return;
+    }
+    if (typeof parsed !== "object" || parsed === null || typeof parsed.type !== "string")
+      return;
+    this.receive(parsed);
+  }
+  receive(event) {
+    if (this.current === "closed") return;
+    this.engine.received(event);
+    this.emit("event", event);
+    const id = typeof event.client_event_id === "string" ? event.client_event_id : void 0;
+    switch (event.type) {
+      case "session.ready":
+        this.ready = true;
+        this.refreshed = false;
+        this.firstFailures = 0;
+        this.stableTimer = setTimeout(() => {
+          this.stableTimer = void 0;
+          this.attempts = 0;
+        }, STABLE_MS);
+        this.setStatus("ready");
+        if (this.foreground) this.startPing();
+        this.resendUnacknowledged();
+        this.resendWaiting("turn");
+        this.resendHeldForSession();
+        break;
+      case "turn.completed":
+      case "turn.failed":
+      // A tap or an answer refused with turn_in_progress during a takeover waits for no turn: the hand-back frees it.
+      case "takeover.ended":
+        this.resendWaiting("turn");
+        break;
+      case "turn.started":
+      case "ui.answer.recorded":
+      case "ui.answer.rejected":
+        if (id !== void 0) this.screenTries.delete(id);
+        break;
+      case "input.rejected":
+      case "error":
+        this.refusedForNow(event);
+        break;
+      case "session.closed":
+        this.closeReason = typeof event.reason === "string" ? event.reason : "";
+        if (this.engine.state().reconnect !== "allowed")
+          this.setStatus("ended");
+        break;
+    }
+    this.emitState();
+  }
+  refusedForNow(event) {
+    const id = typeof event.client_event_id === "string" ? event.client_event_id : void 0;
+    if (id === void 0) return;
+    if (event.code === "limit_reached") {
+      this.heldForSession.set(id, this.info.id);
+      this.setStatus("ended");
+      return;
+    }
+    if (!this.engine.state().resend.includes(id)) return;
+    if (event.code === "turn_in_progress") {
+      this.waiting.set(id, "turn");
+      return;
+    }
+    const tries = this.screenTries.get(id) ?? 0;
+    const delays = this.options.screenRetryDelays ?? DEFAULT_SCREEN_RETRY;
+    if (tries >= delays.length) {
+      this.screenTries.delete(id);
+      this.waiting.delete(id);
+      this.engine.giveUp(id, "screen_unavailable");
+      return;
+    }
+    this.screenTries.set(id, tries + 1);
+    this.waiting.set(id, "screen");
+    this.screenTimers.set(
+      id,
+      setTimeout(() => {
+        this.screenTimers.delete(id);
+        if (this.waiting.get(id) === "screen") this.resend(id);
+      }, delays[tries])
+    );
+  }
+  resendUnacknowledged() {
+    for (const event of this.engine.state().unacknowledged)
+      this.transmit(event);
+  }
+  /** What a turn limit held, on a session other than the one that refused it. */
+  resendHeldForSession() {
+    for (const [id, refusedIn] of [...this.heldForSession]) {
+      if (refusedIn === this.info.id) continue;
+      this.heldForSession.delete(id);
+      this.resend(id);
+    }
+  }
+  resendWaiting(reason) {
+    for (const [id, why] of [...this.waiting])
+      if (why === reason) this.resend(id);
+  }
+  resend(id) {
+    this.waiting.delete(id);
+    const event = this.engine.input(id);
+    if (!event) return;
+    if (this.live() || this.awaitingNewSession()) this.deliver(event);
+    else this.hold(event);
+  }
+  /** Keep an input for a later session: unacknowledged, so the next `session.ready` (after resume()) sends it. */
+  hold(event) {
+    if (this.current === "closed") return;
+    this.engine.sent(event);
+    this.emitState();
+  }
+  /** The session ended: retries waiting on a timer would go nowhere, so their inputs are held for the next session. */
+  holdRetries() {
+    for (const [id, timer] of [...this.screenTimers]) {
+      clearTimeout(timer);
+      this.screenTimers.delete(id);
+      this.waiting.delete(id);
+      const event = this.engine.input(id);
+      if (event) this.hold(event);
+    }
+  }
+  // ------------------------------------------------------------ sending
+  /** Send a typed message; returns its `client_event_id`. Over SSE it runs the turn there. */
+  sendText(text) {
+    const id = this.newId();
+    this.deliver({ type: "input.text", text, client_event_id: id });
+    return id;
+  }
+  /** Answer a question card (or a `rate_each` row, by the row's `question_id`); returns the `client_event_id`. */
+  answer(cardId, questionId, answer) {
+    if (this.current === "sse") {
+      throw new VinaverseClientError(
+        "needs_websocket",
+        "Question cards are answered over the WebSocket."
+      );
+    }
+    const id = this.newId();
+    this.deliver({
+      type: "ui.answer",
+      client_event_id: id,
+      card_id: cardId,
+      question_id: questionId,
+      answer
+    });
+    return id;
+  }
+  /**
+   * Report a proposal's outcome after the tenant's backend answered (§6): `confirmed`, `declined`, `failed` or
+   * `expired`. The first outcome per card is final. Returns the `client_event_id`.
+   */
+  reportOutcome(cardId, outcome) {
+    return this.action(cardId, outcome);
+  }
+  /** A card action (`ui.action`), named by the card's `id`; the card's turn is taken from the state. */
+  action(cardId, action) {
+    const turnId = this.engine.state().cards.find((c) => c.id === cardId)?.turnId;
+    if (turnId === void 0)
+      throw new RangeError(`No turn is known for card ${cardId}.`);
+    const id = this.newId();
+    this.deliver({
+      type: "ui.action",
+      client_event_id: id,
+      turn_id: turnId,
+      card_id: cardId,
+      action
+    });
+    return id;
+  }
+  /** Stop the turn in progress: `input.cancel` on the WebSocket; over SSE, the turn's request is stopped. */
+  cancel(turnId) {
+    if (this.current === "sse") {
+      this.stopSse("cancel");
+      this.engine.turnEnded();
+      this.emitState();
+      return;
+    }
+    this.transmit({ type: "input.cancel", turn_id: turnId });
+  }
+  /** Ended idle: inputs are held for the new session that `resume()` brings. */
+  awaitingNewSession() {
+    return this.current === "ended" && this.engine.state().reconnect === "new_session_on_next_action";
+  }
+  live() {
+    return this.current !== "closed" && this.current !== "ended" && this.current !== "unauthorized";
+  }
+  /**
+   * Every input goes through here: recorded as sent (unacknowledged until the server answers it), then over SSE,
+   * or on the WebSocket when the session is ready, or held and resent once `session.ready` arrives.
+   */
+  deliver(event) {
+    if (!this.live() && !this.awaitingNewSession()) throw ended();
+    this.engine.sent(event);
+    this.emitState();
+    if (this.current === "sse") this.overSse(event);
+    else if (this.ready) this.transmit(event);
+    else if (this.current === "idle") this.connect();
+  }
+  transmit(event) {
+    const socket = this.socket;
+    if (!socket || socket.readyState !== OPEN) return;
+    socket.send(JSON.stringify(event));
+  }
+  /** One input over SSE: a typed message or a card action; an answer cannot go, and is shown as not sent. */
+  overSse(event) {
+    const id = typeof event.client_event_id === "string" ? event.client_event_id : void 0;
+    const notSent = (error) => {
+      if (id !== void 0) this.engine.giveUp(id, error.code);
+      this.emitState();
+      this.emit("error", error);
+    };
+    if (id !== void 0 && this.inFlight(id)) return;
+    const controller = new AbortController();
+    const target = { ...this.sseTarget(), signal: controller.signal };
+    let frames;
+    if (event.type === "input.text") {
+      frames = turnSse(target, {
+        text: String(event.text),
+        ...id !== void 0 ? { client_event_id: id } : {}
+      });
+    } else if (event.type === "ui.action") {
+      frames = cardActionSse(target, String(event.turn_id), {
+        card_id: String(event.card_id),
+        action: String(event.action),
+        ...id !== void 0 ? { client_event_id: id } : {}
+      });
+    } else {
+      notSent(
+        new VinaverseClientError(
+          "needs_websocket",
+          "Question cards are answered over the WebSocket."
+        )
+      );
+      return;
+    }
+    const stream = { id };
+    this.streams.set(controller, stream);
+    void (async () => {
+      try {
+        for await (const frame of frames) {
+          if (controller.signal.aborted) break;
+          this.receive(frame);
+        }
+      } catch (error) {
+        if (!controller.signal.aborted) {
+          notSent(asClientError(error, "http_error"));
+          return;
+        }
+      } finally {
+        this.streams.delete(controller);
+      }
+      if (controller.signal.aborted) {
+        if (stream.stop === "cancel" && id !== void 0) {
+          this.engine.giveUp(id, "cancelled");
+          this.emitState();
+        }
+        return;
+      }
+      if (id !== void 0 && this.isUnacknowledged(id)) {
+        notSent(
+          new VinaverseClientError(
+            "http_error",
+            "The turn ended without taking the input."
+          )
+        );
+      }
+    })();
+  }
+  isUnacknowledged(id) {
+    return this.engine.state().unacknowledged.some((e) => e.client_event_id === id);
+  }
+  inFlight(id) {
+    for (const stream of this.streams.values())
+      if (stream.id === id) return true;
+    return false;
+  }
+  stopSse(why) {
+    for (const [controller, stream] of [...this.streams]) {
+      stream.stop = why;
+      controller.abort();
+    }
+  }
+  sseTarget() {
+    return {
+      turnsUrl: this.info.turns_url,
+      secret: this.secret,
+      ...this.options.fetch ? { fetch: this.options.fetch } : {}
+    };
+  }
+  newId() {
+    return (this.options.createId ?? randomId)();
+  }
+  // ------------------------------------------------------------ pings and listeners
+  startPing() {
+    this.stopPing();
+    this.pingTimer = setInterval(
+      () => this.transmit({ type: "ping" }),
+      this.options.pingInterval ?? 25e3
+    );
+  }
+  stopPing() {
+    if (this.pingTimer !== void 0) clearInterval(this.pingTimer);
+    this.pingTimer = void 0;
+  }
+  setStatus(status) {
+    if (this.current === status) return;
+    this.current = status;
+    if (status === "ended") this.holdRetries();
+    this.emit("status", status);
+  }
+  emitState() {
+    if (this.listeners.state.size) this.emit("state", this.engine.state());
+  }
+  emit(name, value) {
+    for (const listener of this.listeners[name]) listener(value);
+  }
+};
+function ended() {
+  return new VinaverseClientError(
+    "session_ended",
+    "The session has ended; resume it on a new session."
+  );
+}
+function asClientError(error, code) {
+  if (error instanceof VinaverseClientError) return error;
+  return new VinaverseClientError(
+    code,
+    error instanceof Error ? error.message : String(error)
+  );
+}
+function defaultWebSocket() {
+  const Ctor = globalThis.WebSocket;
+  if (!Ctor) return null;
+  const scope = globalThis;
+  const node = typeof scope.process?.versions?.node === "string" && scope.document === void 0;
+  return (url, protocols, headers) => {
+    if (!headers) return new Ctor(url, protocols);
+    return node ? new Ctor(url, { protocols, headers }) : new Ctor(url, protocols, { headers });
+  };
+}
+var ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+function randomId() {
+  const bytes = new Uint8Array(22);
+  const crypto = globalThis.crypto;
+  if (crypto?.getRandomValues) crypto.getRandomValues(bytes);
+  else
+    for (let i = 0; i < bytes.length; i++)
+      bytes[i] = Math.floor(Math.random() * 256);
+  let id = "ce_";
+  for (const byte of bytes) id += ALPHABET[byte % ALPHABET.length];
+  return id;
+}
+
+export { CONTRACT, ConversationEngine, VinaverseClientError, VinaverseSession, cardActionSse, clientSecret, isKnownCard, randomId, sseFrames, turnSse };
+//# sourceMappingURL=chunk-AWHPWRGT.js.map
+//# sourceMappingURL=chunk-AWHPWRGT.js.map