@opengeni/sdk 3.1.0 → 3.1.2

package/dist/chat/types.d.ts

@@ -0,0 +1,207 @@
+import type { FetchLike } from "../client.js";
+import type { Chats } from "../chats.js";
+import type { WorkspaceIdResolverOptions } from "../tenant-workspaces.js";
+import type { CreateSessionRequest, AgentConfigRequest, HumanInputAnswer, LatencyMode, ReasoningEffort, SessionEvent, Session, SessionSkill, ToolRef } from "../types.js";
+/** Which other sessions the agent may reach from this one. */
+export type ChatAgentAccess = "session" | "user" | "workspace";
+/**
+ * Compatibility option for personal or workspace Knowledge. `false` initializes
+ * Knowledge authoring to Off; authorized retrieval remains available. Omitted
+ * follows `chats`: private with a user, or legacy reach-based defaults without one.
+ * Task notes cover temporary session-tree data.
+ */
+export type ChatMemory = "user" | "workspace" | false;
+export type OpenGeniOptions = {
+    /** Organization API key. Keep it on the server. */
+    apiKey: string;
+    /**
+     * The organization (account) id that owns every workspace. Optional: when
+     * omitted it is read once from the API key.
+     */
+    organizationId?: string | undefined;
+    /** Defaults to `https://app.opengeni.ai`. */
+    baseUrl?: string | undefined;
+    /**
+     * The product identity used as the external-source label for tenant
+     * workspaces and end users. Defaults to `"app"`.
+     */
+    source?: string | undefined;
+    fetch?: FetchLike | undefined;
+    /** Display name for a tenant workspace created on first use. Defaults to the tenant id. */
+    workspaceName?: ((tenant: string) => string) | undefined;
+    /**
+     * Per-user workspaces only (`{ user }` alone, or `chats: "isolated"`):
+     * permissions for the one owner the SDK adds explicitly. Tenant workspaces
+     * rely on Opengeni, which adds a user on their first request. Both default
+     * to workspace read, session create/read/control (including sending
+     * messages), file upload/read, and per-session MCP attachment; no admin
+     * permissions. Never updates an existing membership: use
+     * `client.updateExternalWorkspaceMember` for that.
+     */
+    memberPermissions?: WorkspaceIdResolverOptions["memberPermissions"];
+};
+/**
+ * Which workspace, in your own ids: `tenant` (one workspace per tenant),
+ * neither (the `user`'s own workspace), or an explicit `workspaceId`.
+ */
+export type ChatTarget = {
+    tenant: string;
+    workspaceId?: undefined;
+} | {
+    workspaceId: string;
+    tenant?: undefined;
+} | {
+    user: string;
+    tenant?: undefined;
+    workspaceId?: undefined;
+};
+/**
+ * A workspace in your own ids, for `og.workspaceId(...)`: `{ tenant }` (one
+ * workspace per tenant), `{ user }` (one workspace per user), or
+ * `{ workspaceId }`. Precedence: workspaceId, then tenant, then user.
+ */
+export type WorkspaceTarget = {
+    tenant?: string | undefined;
+    user?: string | undefined;
+    workspaceId?: string | undefined;
+};
+export type ChatOptions = ChatTarget & {
+    /**
+     * Host-authenticated external user; resolved through server-side asUser().
+     * Without a tenant or workspaceId, the user gets one workspace of their own.
+     */
+    user?: string | undefined;
+    /** Stable conversation id; the session id is derived from it deterministically. */
+    conversation: string;
+    /** Prefer the actual Opengeni session ID for shared or existing conversations.
+     * The acting user is independent of the conversation's identity. */
+    sessionId?: string | undefined;
+    /**
+     * Private (default with a user) uses personal Knowledge and session-only reach;
+     * shared uses workspace Knowledge/reach, isolated adds a workspace per tenant/user.
+     * Without a user, omission keeps workspace visibility, session reach and Knowledge off.
+     */
+    chats?: Chats | undefined;
+    /** Agent identity, capabilities and instructions; implicit markdown falls back on older servers. */
+    agent?: AgentConfigRequest | undefined;
+    /** Explicit agent reach overrides the `chats` default. */
+    agentAccess?: ChatAgentAccess | undefined;
+    memory?: ChatMemory | undefined;
+    model?: string | undefined;
+    instructions?: string | undefined;
+    skills?: SessionSkill[] | undefined;
+    tools?: ToolRef[] | undefined;
+    /**
+     * Raw create-request passthrough (for example `sandboxBackend: "none"` for a
+     * pure chat). Explicit values win over facade-derived ones; the message and
+     * identity/idempotency fields always come from the facade.
+     */
+    create?: Partial<CreateSessionRequest> | undefined;
+};
+/** A turn stopped to wait for a human decision. */
+export type ChatPending = {
+    kind: "approval" | "human_input";
+    /** The id to pass back through `chat.respond`. */
+    requestId: string;
+    /** Tool name for an approval; null for structured human input. */
+    name: string | null;
+    /** The producer's exact payload (approval entry or human-input request). */
+    payload: unknown;
+};
+export type ChatReplyStatus = "completed" | "pending" | "cancelled";
+export type ChatReply = {
+    text: string;
+    sessionId: string;
+    workspaceId: string;
+    turnId: string | null;
+    /** `pending` waits on `chat.respond`; `cancelled` carries the text produced before the cancel. */
+    status: ChatReplyStatus;
+    /** Set when the turn is waiting on `chat.respond` instead of finished. */
+    pending: ChatPending | null;
+    /** A non-destructive completion without a model-authored final answer. */
+    emptyFinalReply?: true;
+    /** Display this informational notice when emptyFinalReply is present. */
+    notice?: string;
+    /** Every event consumed while folding this turn. */
+    events: SessionEvent[];
+    toString(): string;
+};
+export type ChatToolStatus = "started" | "completed" | "failed";
+export type ChatChunk = {
+    type: "text";
+    text: string;
+} | {
+    type: "tool";
+    name: string;
+    status: ChatToolStatus;
+    callId?: string | undefined;
+    input?: unknown;
+} | {
+    type: "pending";
+    pending: ChatPending;
+} | {
+    type: "done";
+    reply: ChatReply;
+};
+export type ChatMessage = {
+    role: "user" | "assistant";
+    text: string;
+    sequence: number;
+};
+/** Durable text and unresolved decisions restored when a chat is reopened. */
+export type ChatSnapshot = {
+    messages: ChatMessage[];
+    pending: ChatPending[];
+    status: Session["status"] | null;
+};
+export type ChatRespondInput = {
+    requestId: string;
+    decision: "approve" | "reject";
+    message?: string | undefined;
+} | {
+    requestId: string;
+    answers: HumanInputAnswer[];
+} | {
+    requestId: string;
+    skip: true;
+};
+/** One earlier message from the product's own history, imported as context on the first send. */
+export type ChatImportedMessage = {
+    role: "user" | "assistant" | "system";
+    text: string;
+};
+export type ChatSendOptions = {
+    signal?: AbortSignal | undefined;
+    /** Supersede the current inference instead of queueing behind it. */
+    steer?: boolean | undefined;
+    /**
+     * Earlier messages the product already holds, oldest first. Used only when
+     * this send creates the session: they become the first message's
+     * `modelContext` (skipped when `create.modelContext` was supplied), trimmed
+     * from the oldest end to 30,000 characters. Never resent on later turns:
+     * after the first message Opengeni owns the history.
+     */
+    importedHistory?: ChatImportedMessage[] | undefined;
+    /** Model for this message's turn; omitted keeps the session's current policy. */
+    model?: string | undefined;
+    reasoningEffort?: ReasoningEffort | undefined;
+    latencyMode?: LatencyMode | undefined;
+    /**
+     * Model-visible application context for this one message (for example the
+     * page or record the user is looking at). Not shown in the transcript and not
+     * secret. On the creating message it is combined with imported history.
+     */
+    modelContext?: string | undefined;
+};
+export type ChatSessionListOptions = ChatTarget & {
+    user?: string | undefined;
+    /** Match the chat's mode; isolated lists that user's separate workspace. */
+    chats?: Chats | undefined;
+    limit?: number | undefined;
+};
+/** A turn ended without a usable reply, or the facade was misused. */
+export declare class OpenGeniChatError extends Error {
+    readonly code: string;
+    readonly event: SessionEvent | null;
+    constructor(code: string, message: string, event?: SessionEvent | null);
+}

package/dist/chat/vercel.d.ts

@@ -0,0 +1,49 @@
+import { type ChatResolve } from "./http.js";
+import type { Opengeni } from "./opengeni.js";
+import type { ChatChunk } from "./types.js";
+/**
+ * Vercel AI SDK UI message stream (protocol v1, as consumed by `useChat` with
+ * the default transport in AI SDK 5, 6, and 7; approval requests need 6+).
+ * Parts are `data: <json>` SSE
+ * lines terminated by `data: [DONE]`, under the
+ * `x-vercel-ai-ui-message-stream: v1` header.
+ */
+export declare const UI_MESSAGE_STREAM_HEADER = "x-vercel-ai-ui-message-stream";
+export declare const UI_MESSAGE_STREAM_VERSION = "v1";
+export type UIMessageStreamOptions = {
+    /** Assistant message id announced in the `start` part. Defaults to a random UUID. */
+    messageId?: string | undefined;
+    /**
+     * Emit Opengeni's own tool activity as tool parts. Off by default: those
+     * tools are not in the app's typed tool set. When on, parts are marked
+     * `dynamic` and `providerExecuted`, so `useChat` renders them as
+     * `dynamic-tool` parts and never tries to execute them. Approval requests
+     * are always emitted (as dynamic tool parts) because answering them is part
+     * of the conversation.
+     */
+    toolParts?: boolean | undefined;
+    /**
+     * Emit the `start` / `start-step` / `finish-step` / `finish` framing. Set to
+     * false when writing into an existing AI SDK stream that owns its framing
+     * (for example `createUIMessageStream({ execute: ({ writer }) => ... })`).
+     * Defaults to true.
+     */
+    framing?: boolean | undefined;
+};
+/** Protocol parts for one reply, in order. */
+export declare function uiMessageStreamParts(chunks: AsyncIterable<ChatChunk>, options?: UIMessageStreamOptions): AsyncGenerator<Record<string, unknown>, void, void>;
+export declare function uiMessageStreamBlocks(chunks: AsyncIterable<ChatChunk>, options?: UIMessageStreamOptions): AsyncGenerator<string, void, void>;
+export declare function chatChunksToUIMessageStream(chunks: AsyncIterable<ChatChunk>, options?: UIMessageStreamOptions & {
+    onCancel?: (() => void) | undefined;
+}): ReadableStream<Uint8Array>;
+export declare function uiMessageStreamResponse(chunks: AsyncIterable<ChatChunk>, options?: UIMessageStreamOptions): Response;
+/** Text of the last user `UIMessage` (`parts` of type `text`, joined). */
+export declare function lastUIMessageText(messages: unknown): string | null;
+/**
+ * `useChat` request handler: body `{ id, messages, trigger, messageId }`.
+ * Conversation: the host's `resolve`, else the `x-opengeni-conversation`
+ * header, else the chat `id`. Only the last user message is sent; the
+ * messages before it are imported once as context when this request creates
+ * the session. `regenerate-message` steers instead of queueing.
+ */
+export declare function handleVercelChatRequest(og: Opengeni, request: Request, resolve: ChatResolve, options?: Pick<UIMessageStreamOptions, "toolParts">): Promise<Response>;

package/dist/chats.d.ts

@@ -0,0 +1,8 @@
+import type { CreateSessionRequest } from "./types.js";
+/**
+ * Private chats use personal Knowledge and session-only agent reach; shared chats
+ * use workspace Knowledge and reach. Isolated adds a separate workspace per user.
+ */
+export type Chats = "private" | "shared" | "isolated";
+/** SDK defaults only: the API still authorizes visibility, agent reach and Knowledge separately. */
+export declare function chatDefaults(chats: Chats): Required<Pick<CreateSessionRequest, "visibility" | "agentAccess" | "memoryScope">>;

package/dist/chunk-4AHR4KGA.js

@@ -0,0 +1,301 @@
+import {
+  OpenGeniStreamError,
+  isAbortError,
+  isRetryableStreamError
+} from "./chunk-7EWT3PV6.js";
+
+// src/sse.ts
+async function* parseSseStream(stream) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let id;
+  let event;
+  let dataLines = null;
+  const dispatch = () => {
+    const message = dataLines === null ? null : {
+      ...id !== void 0 ? { id } : {},
+      ...event !== void 0 ? { event } : {},
+      data: dataLines.join("\n")
+    };
+    id = void 0;
+    event = void 0;
+    dataLines = null;
+    return message;
+  };
+  const handleLine = (line) => {
+    if (line === "") {
+      return dispatch();
+    }
+    if (line.startsWith(":")) {
+      return null;
+    }
+    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 === "data") {
+      (dataLines ??= []).push(value);
+    } else if (field === "event") {
+      event = value;
+    } else if (field === "id") {
+      id = value;
+    }
+    return null;
+  };
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      let newline = buffer.indexOf("\n");
+      while (newline !== -1) {
+        let line = buffer.slice(0, newline);
+        buffer = buffer.slice(newline + 1);
+        if (line.endsWith("\r")) {
+          line = line.slice(0, -1);
+        }
+        const message = handleLine(line);
+        if (message) {
+          yield message;
+        }
+        newline = buffer.indexOf("\n");
+      }
+    }
+  } finally {
+    void reader.cancel().catch(() => {
+    });
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+
+// src/stream.ts
+var SESSION_EVENT_STREAM_COVERAGE = Symbol.for(
+  "@opengeni/sdk/session-event-stream-covered-through"
+);
+async function* streamSessionEvents(transport, options = {}) {
+  const signal = options.signal;
+  const reconnect = options.reconnect ?? true;
+  const baseDelayMs = options.reconnectDelayMs ?? 500;
+  const maxDelayMs = options.maxReconnectDelayMs ?? 1e4;
+  const jitterRatio = options.reconnectJitterRatio ?? 0.2;
+  const beforeLiveTimeoutMs = options.beforeLiveTimeoutMs ?? 15e3;
+  const heartbeatTimeoutMs = options.heartbeatTimeoutMs ?? 45e3;
+  const maxAttempts = options.maxReconnectAttempts ?? Number.POSITIVE_INFINITY;
+  let cursor = options.after ?? 0;
+  let failedAttempts = 0;
+  let delayMs = baseDelayMs;
+  let everConnected = false;
+  while (true) {
+    if (signal?.aborted) break;
+    options.onStateChange?.(everConnected || failedAttempts > 0 ? "reconnecting" : "connecting");
+    const cursorAtOpen = cursor;
+    try {
+      const body = await transport.openStream(cursor, signal);
+      everConnected = true;
+      failedAttempts = 0;
+      delayMs = baseDelayMs;
+      try {
+        options.onOpen?.();
+      } catch {
+      }
+      await runBeforeLive(options.beforeLive, beforeLiveTimeoutMs, signal);
+      options.onStateChange?.("live");
+      for await (const message of parseSseStream(
+        withStreamInactivityTimeout(body, heartbeatTimeoutMs, signal)
+      )) {
+        if (signal?.aborted) {
+          return;
+        }
+        const event = parseSessionEvent(message.data);
+        if (!event) {
+          continue;
+        }
+        const coveredSequence = trustedSseSequence(message.id, event.sequence);
+        markSessionEventStreamCoverage(event, coveredSequence);
+        if (coveredSequence <= cursor) continue;
+        if (event.sequence > cursor + 1) {
+          for await (const missed of backfillEvents(transport, cursor, event.sequence - 1)) {
+            cursor = missed.sequence;
+            yield missed;
+            if (signal?.aborted) {
+              return;
+            }
+          }
+        }
+        cursor = coveredSequence;
+        yield event;
+      }
+      if (!reconnect) {
+        return;
+      }
+      if (cursor === cursorAtOpen) {
+        await sleep(jitteredDelay(baseDelayMs, jitterRatio), signal);
+      }
+      continue;
+    } catch (error) {
+      if (signal?.aborted || isAbortError(error)) {
+        return;
+      }
+      if (!reconnect || !isRetryableStreamError(error)) {
+        throw error;
+      }
+      failedAttempts += 1;
+      if (failedAttempts > maxAttempts) {
+        throw new OpenGeniStreamError(
+          `event stream gave up after ${maxAttempts} consecutive failed reconnect attempts: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    await sleep(jitteredDelay(delayMs, jitterRatio), signal);
+    delayMs = Math.min(Math.max(delayMs * 2, baseDelayMs), maxDelayMs);
+  }
+}
+async function runBeforeLive(beforeLive, timeoutMs, signal) {
+  if (!beforeLive) return;
+  let timer;
+  let abortListener;
+  const timeout = new Promise((_resolve, reject) => {
+    timer = setTimeout(
+      () => reject(new TypeError(`stream reconciliation timed out after ${timeoutMs}ms`)),
+      timeoutMs
+    );
+    if (signal) {
+      abortListener = () => reject(new DOMException("Aborted", "AbortError"));
+      signal.addEventListener("abort", abortListener, { once: true });
+    }
+  });
+  try {
+    await Promise.race([Promise.resolve().then(beforeLive), timeout]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+    if (signal && abortListener) signal.removeEventListener("abort", abortListener);
+  }
+}
+function jitteredDelay(delayMs, ratio) {
+  if (delayMs <= 0 || ratio <= 0) return delayMs;
+  const boundedRatio = Math.min(ratio, 1);
+  const spread = delayMs * boundedRatio;
+  return Math.max(0, delayMs - spread + Math.random() * spread * 2);
+}
+function withStreamInactivityTimeout(stream, timeoutMs, signal) {
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0) {
+    throw new RangeError("stream heartbeat timeout must be a positive safe integer");
+  }
+  const reader = stream.getReader();
+  return new ReadableStream({
+    pull: async (controller) => {
+      let timer;
+      let abortListener;
+      try {
+        const result = await Promise.race([
+          reader.read(),
+          new Promise((_resolve, reject) => {
+            timer = setTimeout(
+              () => reject(new TypeError(`event stream heartbeat timed out after ${timeoutMs}ms`)),
+              timeoutMs
+            );
+            if (signal) {
+              abortListener = () => reject(new DOMException("Aborted", "AbortError"));
+              signal.addEventListener("abort", abortListener, { once: true });
+            }
+          })
+        ]);
+        if (result.done) controller.close();
+        else controller.enqueue(result.value);
+      } catch (error) {
+        void reader.cancel(error).catch(() => {
+        });
+        controller.error(error);
+      } finally {
+        if (timer !== void 0) clearTimeout(timer);
+        if (signal && abortListener) signal.removeEventListener("abort", abortListener);
+      }
+    },
+    cancel: (reason) => {
+      void reader.cancel(reason).catch(() => {
+      });
+    }
+  });
+}
+async function* backfillEvents(transport, fromExclusive, toInclusive) {
+  let cursor = fromExclusive;
+  while (cursor < toInclusive) {
+    const page = await transport.listEvents(cursor, Math.min(500, toInclusive - cursor));
+    const advancing = page.filter((event) => event.sequence > cursor && event.sequence <= toInclusive).sort((a, b) => a.sequence - b.sequence);
+    if (advancing.length === 0) {
+      throw new OpenGeniStreamError(
+        `event replay backfill stalled: expected sequences ${cursor + 1}..${toInclusive} but the replay endpoint returned none of them`
+      );
+    }
+    for (const event of advancing) {
+      if (event.sequence !== cursor + 1) {
+        throw new OpenGeniStreamError(
+          `event replay backfill is missing sequence ${cursor + 1} (replay endpoint skipped to ${event.sequence}); refusing to deliver with a gap`
+        );
+      }
+      cursor = event.sequence;
+      yield event;
+    }
+  }
+}
+function parseSessionEvent(data) {
+  let parsed;
+  try {
+    parsed = JSON.parse(data);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || typeof parsed.sequence !== "number" || typeof parsed.type !== "string" || typeof parsed.id !== "string") {
+    return null;
+  }
+  return parsed;
+}
+function sessionEventStreamCoveredThrough(event) {
+  const covered = event[SESSION_EVENT_STREAM_COVERAGE];
+  return typeof covered === "number" && Number.isSafeInteger(covered) && covered >= event.sequence ? covered : null;
+}
+function trustedSseSequence(id, sequence) {
+  if (id === void 0 || !/^\d+$/.test(id)) return sequence;
+  const covered = Number(id);
+  return Number.isSafeInteger(covered) && covered >= sequence ? covered : sequence;
+}
+function markSessionEventStreamCoverage(event, covered) {
+  Object.defineProperty(event, SESSION_EVENT_STREAM_COVERAGE, {
+    value: covered,
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+}
+async function sleep(delayMs, signal) {
+  if (signal?.aborted || delayMs <= 0) {
+    return;
+  }
+  await new Promise((resolve) => {
+    const timer = setTimeout(done, delayMs);
+    function done() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      resolve();
+    }
+    signal?.addEventListener("abort", done, { once: true });
+  });
+}
+
+export {
+  parseSseStream,
+  streamSessionEvents,
+  runBeforeLive,
+  jitteredDelay,
+  withStreamInactivityTimeout,
+  sessionEventStreamCoveredThrough
+};
+//# sourceMappingURL=chunk-4AHR4KGA.js.map

package/dist/chunk-4AHR4KGA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/sse.ts","../src/stream.ts"],"sourcesContent":["/**\n * Minimal incremental Server-Sent Events parser over a byte stream.\n *\n * Implements the parts of the SSE wire format Opengeni uses: `id`, `event`,\n * and `data` fields, multi-line data, comment lines, and both LF and CRLF\n * line endings. Messages without any `data` (comments, id-only blocks) are\n * not emitted.\n */\nexport type SseMessage = {\n  id?: string;\n  event?: string;\n  data: string;\n};\n\nexport async function* parseSseStream(\n  stream: ReadableStream<Uint8Array>,\n): AsyncGenerator<SseMessage, void, void> {\n  const reader = stream.getReader();\n  const decoder = new TextDecoder();\n  let buffer = \"\";\n  let id: string | undefined;\n  let event: string | undefined;\n  let dataLines: string[] | null = null;\n\n  const dispatch = (): SseMessage | null => {\n    const message =\n      dataLines === null\n        ? null\n        : {\n            ...(id !== undefined ? { id } : {}),\n            ...(event !== undefined ? { event } : {}),\n            data: dataLines.join(\"\\n\"),\n          };\n    id = undefined;\n    event = undefined;\n    dataLines = null;\n    return message;\n  };\n\n  const handleLine = (line: string): SseMessage | null => {\n    if (line === \"\") {\n      return dispatch();\n    }\n    if (line.startsWith(\":\")) {\n      return null;\n    }\n    const colon = line.indexOf(\":\");\n    const field = colon === -1 ? line : line.slice(0, colon);\n    let value = colon === -1 ? \"\" : line.slice(colon + 1);\n    if (value.startsWith(\" \")) {\n      value = value.slice(1);\n    }\n    if (field === \"data\") {\n      (dataLines ??= []).push(value);\n    } else if (field === \"event\") {\n      event = value;\n    } else if (field === \"id\") {\n      id = value;\n    }\n    // Other fields (e.g. `retry`) are ignored; reconnect pacing is the\n    // streaming layer's concern.\n    return null;\n  };\n\n  try {\n    while (true) {\n      const { done, value } = await reader.read();\n      if (done) {\n        break;\n      }\n      buffer += decoder.decode(value, { stream: true });\n      let newline = buffer.indexOf(\"\\n\");\n      while (newline !== -1) {\n        let line = buffer.slice(0, newline);\n        buffer = buffer.slice(newline + 1);\n        if (line.endsWith(\"\\r\")) {\n          line = line.slice(0, -1);\n        }\n        const message = handleLine(line);\n        if (message) {\n          yield message;\n        }\n        newline = buffer.indexOf(\"\\n\");\n      }\n    }\n    // Per the SSE spec, a block is only dispatched on a blank line. Anything\n    // still pending at end-of-stream came from a truncated connection and is\n    // discarded — the streaming layer replays from its cursor on reconnect.\n  } finally {\n    // Never await cancel(): some fetch bodies settle it only once their request\n    // aborts, which would deadlock the consumer's unwinding.\n    void reader.cancel().catch(() => {});\n    try {\n      reader.releaseLock();\n    } catch {\n      // A pending read (older stream implementations) keeps the lock; cancel releases it.\n    }\n  }\n}\n","import { isAbortError, isRetryableStreamError, OpenGeniStreamError } from \"./errors\";\nimport { parseSseStream } from \"./sse\";\nimport type { SessionEvent } from \"./types\";\n\nconst SESSION_EVENT_STREAM_COVERAGE = Symbol.for(\n  \"@opengeni/sdk/session-event-stream-covered-through\",\n);\n\n/**\n * Transport boundary for the streaming core. The client implements it with\n * `fetch`; unit tests script it directly.\n */\nexport type SessionEventStreamTransport = {\n  /** Open the SSE stream, replaying durable events after `after` first. */\n  openStream: (\n    after: number,\n    signal: AbortSignal | undefined,\n  ) => Promise<ReadableStream<Uint8Array>>;\n  /** Replay durable events by sequence (`GET .../events?after=&limit=`). */\n  listEvents: (after: number, limit: number) => Promise<SessionEvent[]>;\n};\n\nexport type StreamConnectionState = \"connecting\" | \"live\" | \"reconnecting\";\n\nexport type StreamSessionEventsOptions = {\n  /** Resume after this sequence number (exclusive). Defaults to 0 (full replay). */\n  after?: number;\n  /** Aborting ends the stream gracefully (the generator returns). */\n  signal?: AbortSignal;\n  /** Reconnect on transient drops. Defaults to true. */\n  reconnect?: boolean;\n  /** Initial reconnect backoff. Defaults to 500ms. */\n  reconnectDelayMs?: number;\n  /** Backoff ceiling. Defaults to 10s. */\n  maxReconnectDelayMs?: number;\n  /** Random backoff spread as a fraction of the delay. Defaults to 0.2. */\n  reconnectJitterRatio?: number;\n  /**\n   * Give up after this many consecutive failed reconnect attempts (i.e. N\n   * reconnects = N+1 total open-stream calls). Defaults to unlimited.\n   */\n  maxReconnectAttempts?: number;\n  /**\n   * Notify the consumer as soon as the SSE response body is open. This callback\n   * is deliberately synchronous and non-blocking: use it to start projection\n   * reconciliation without delaying consumption of live event bytes.\n   */\n  onOpen?: (() => void) | undefined;\n  /** Await authoritative client reconciliation before exposing `live`. */\n  beforeLive?: (() => void | Promise<void>) | undefined;\n  /** Maximum reconciliation time before reconnecting. Defaults to 15s. */\n  beforeLiveTimeoutMs?: number;\n  /** Maximum time without any SSE bytes before reconnecting. Defaults to 45s. */\n  heartbeatTimeoutMs?: number;\n  onStateChange?: (state: StreamConnectionState) => void;\n};\n\n/**\n * Stream a session's events with exactly-once, in-order delivery.\n *\n * Guarantees, anchored on the per-session contiguous `sequence`:\n * - **No duplicates**: events at or below the cursor are dropped, so server\n *   replay overlap and reconnect overlap never re-yield.\n * - **No gaps**: each reconnect resumes from the last seen sequence, and a\n *   gap observed inside one connection is backfilled from the durable replay\n *   endpoint before the newer event is yielded (events are durable before\n *   they are published live, so the backfill always finds them).\n * - **Ordered**: sequences are yielded strictly ascending.\n *\n * The generator ends when `signal` aborts, when the server closes and\n * `reconnect` is false, or with an error for non-retryable failures.\n */\nexport async function* streamSessionEvents(\n  transport: SessionEventStreamTransport,\n  options: StreamSessionEventsOptions = {},\n): AsyncGenerator<SessionEvent, void, void> {\n  const signal = options.signal;\n  const reconnect = options.reconnect ?? true;\n  const baseDelayMs = options.reconnectDelayMs ?? 500;\n  const maxDelayMs = options.maxReconnectDelayMs ?? 10_000;\n  const jitterRatio = options.reconnectJitterRatio ?? 0.2;\n  const beforeLiveTimeoutMs = options.beforeLiveTimeoutMs ?? 15_000;\n  const heartbeatTimeoutMs = options.heartbeatTimeoutMs ?? 45_000;\n  const maxAttempts = options.maxReconnectAttempts ?? Number.POSITIVE_INFINITY;\n  let cursor = options.after ?? 0;\n  let failedAttempts = 0;\n  let delayMs = baseDelayMs;\n  let everConnected = false;\n\n  while (true) {\n    if (signal?.aborted) break;\n    options.onStateChange?.(everConnected || failedAttempts > 0 ? \"reconnecting\" : \"connecting\");\n    const cursorAtOpen = cursor;\n    try {\n      const body = await transport.openStream(cursor, signal);\n      everConnected = true;\n      failedAttempts = 0;\n      delayMs = baseDelayMs;\n      try {\n        options.onOpen?.();\n      } catch {\n        // A notification observer cannot own or interrupt the event transport.\n      }\n      await runBeforeLive(options.beforeLive, beforeLiveTimeoutMs, signal);\n      options.onStateChange?.(\"live\");\n      for await (const message of parseSseStream(\n        withStreamInactivityTimeout(body, heartbeatTimeoutMs, signal),\n      )) {\n        // Re-check after every yield resumption: an abort from the consumer\n        // must not let already-buffered events keep flowing.\n        if (signal?.aborted) {\n          return;\n        }\n        const event = parseSessionEvent(message.data);\n        if (!event) {\n          continue;\n        }\n        const coveredSequence = trustedSseSequence(message.id, event.sequence);\n        markSessionEventStreamCoverage(event, coveredSequence);\n        if (coveredSequence <= cursor) continue;\n        if (event.sequence > cursor + 1) {\n          for await (const missed of backfillEvents(transport, cursor, event.sequence - 1)) {\n            cursor = missed.sequence;\n            yield missed;\n            if (signal?.aborted) {\n              return;\n            }\n          }\n        }\n        cursor = coveredSequence;\n        yield event;\n      }\n      if (!reconnect) {\n        return;\n      }\n      // Clean server close: reconnect immediately when the connection made\n      // progress (servers legitimately cycle long SSE connections); pace\n      // empty closes so a misbehaving server is not hammered in a hot loop.\n      if (cursor === cursorAtOpen) {\n        await sleep(jitteredDelay(baseDelayMs, jitterRatio), signal);\n      }\n      continue;\n    } catch (error) {\n      if (signal?.aborted || isAbortError(error)) {\n        return;\n      }\n      if (!reconnect || !isRetryableStreamError(error)) {\n        throw error;\n      }\n      failedAttempts += 1;\n      if (failedAttempts > maxAttempts) {\n        throw new OpenGeniStreamError(\n          `event stream gave up after ${maxAttempts} consecutive failed reconnect attempts: ${error instanceof Error ? error.message : String(error)}`,\n        );\n      }\n    }\n    await sleep(jitteredDelay(delayMs, jitterRatio), signal);\n    delayMs = Math.min(Math.max(delayMs * 2, baseDelayMs), maxDelayMs);\n  }\n}\n\nexport async function runBeforeLive(\n  beforeLive: (() => void | Promise<void>) | undefined,\n  timeoutMs: number,\n  signal: AbortSignal | undefined,\n): Promise<void> {\n  if (!beforeLive) return;\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  let abortListener: (() => void) | undefined;\n  const timeout = new Promise<never>((_resolve, reject) => {\n    timer = setTimeout(\n      () => reject(new TypeError(`stream reconciliation timed out after ${timeoutMs}ms`)),\n      timeoutMs,\n    );\n    if (signal) {\n      abortListener = () => reject(new DOMException(\"Aborted\", \"AbortError\"));\n      signal.addEventListener(\"abort\", abortListener, { once: true });\n    }\n  });\n  try {\n    await Promise.race([Promise.resolve().then(beforeLive), timeout]);\n  } finally {\n    if (timer !== undefined) clearTimeout(timer);\n    if (signal && abortListener) signal.removeEventListener(\"abort\", abortListener);\n  }\n}\n\nexport function jitteredDelay(delayMs: number, ratio: number): number {\n  if (delayMs <= 0 || ratio <= 0) return delayMs;\n  const boundedRatio = Math.min(ratio, 1);\n  const spread = delayMs * boundedRatio;\n  return Math.max(0, delayMs - spread + Math.random() * spread * 2);\n}\n\nexport function withStreamInactivityTimeout(\n  stream: ReadableStream<Uint8Array>,\n  timeoutMs: number,\n  signal: AbortSignal | undefined,\n): ReadableStream<Uint8Array> {\n  if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0) {\n    throw new RangeError(\"stream heartbeat timeout must be a positive safe integer\");\n  }\n  const reader = stream.getReader();\n  return new ReadableStream<Uint8Array>({\n    pull: async (controller) => {\n      let timer: ReturnType<typeof setTimeout> | undefined;\n      let abortListener: (() => void) | undefined;\n      try {\n        const result = await Promise.race([\n          reader.read(),\n          new Promise<never>((_resolve, reject) => {\n            timer = setTimeout(\n              () => reject(new TypeError(`event stream heartbeat timed out after ${timeoutMs}ms`)),\n              timeoutMs,\n            );\n            if (signal) {\n              abortListener = () => reject(new DOMException(\"Aborted\", \"AbortError\"));\n              signal.addEventListener(\"abort\", abortListener, { once: true });\n            }\n          }),\n        ]);\n        if (result.done) controller.close();\n        else controller.enqueue(result.value);\n      } catch (error) {\n        void reader.cancel(error).catch(() => {});\n        controller.error(error);\n      } finally {\n        if (timer !== undefined) clearTimeout(timer);\n        if (signal && abortListener) signal.removeEventListener(\"abort\", abortListener);\n      }\n    },\n    cancel: (reason) => {\n      // Do not wait for the underlying body: it may settle cancel() only after\n      // its request aborts (see parseSseStream).\n      void reader.cancel(reason).catch(() => {});\n    },\n  });\n}\n\n/**\n * Yield the durable events with `fromExclusive < sequence <= toInclusive`,\n * in order. Sequences are contiguous, so every one of them must exist in the\n * replay endpoint; if any is missing the function throws instead of skipping\n * it — continuing would silently break the gap-free delivery guarantee.\n */\nasync function* backfillEvents(\n  transport: SessionEventStreamTransport,\n  fromExclusive: number,\n  toInclusive: number,\n): AsyncGenerator<SessionEvent, void, void> {\n  let cursor = fromExclusive;\n  while (cursor < toInclusive) {\n    const page = await transport.listEvents(cursor, Math.min(500, toInclusive - cursor));\n    const advancing = page\n      .filter((event) => event.sequence > cursor && event.sequence <= toInclusive)\n      .sort((a, b) => a.sequence - b.sequence);\n    if (advancing.length === 0) {\n      throw new OpenGeniStreamError(\n        `event replay backfill stalled: expected sequences ${cursor + 1}..${toInclusive} but the replay endpoint returned none of them`,\n      );\n    }\n    for (const event of advancing) {\n      if (event.sequence !== cursor + 1) {\n        throw new OpenGeniStreamError(\n          `event replay backfill is missing sequence ${cursor + 1} (replay endpoint skipped to ${event.sequence}); refusing to deliver with a gap`,\n        );\n      }\n      cursor = event.sequence;\n      yield event;\n    }\n  }\n}\n\nfunction parseSessionEvent(data: string): SessionEvent | null {\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(data);\n  } catch {\n    return null;\n  }\n  if (\n    typeof parsed !== \"object\" ||\n    parsed === null ||\n    typeof (parsed as { sequence?: unknown }).sequence !== \"number\" ||\n    typeof (parsed as { type?: unknown }).type !== \"string\" ||\n    typeof (parsed as { id?: unknown }).id !== \"string\"\n  ) {\n    return null;\n  }\n  return parsed as SessionEvent;\n}\n\n/** Trusted SSE coverage attached non-enumerably to a streamed event. */\nexport function sessionEventStreamCoveredThrough(event: SessionEvent): number | null {\n  const covered = (event as SessionEvent & { [SESSION_EVENT_STREAM_COVERAGE]?: unknown })[\n    SESSION_EVENT_STREAM_COVERAGE\n  ];\n  return typeof covered === \"number\" && Number.isSafeInteger(covered) && covered >= event.sequence\n    ? covered\n    : null;\n}\n\nfunction trustedSseSequence(id: string | undefined, sequence: number): number {\n  if (id === undefined || !/^\\d+$/.test(id)) return sequence;\n  const covered = Number(id);\n  return Number.isSafeInteger(covered) && covered >= sequence ? covered : sequence;\n}\n\nfunction markSessionEventStreamCoverage(event: SessionEvent, covered: number): void {\n  Object.defineProperty(event, SESSION_EVENT_STREAM_COVERAGE, {\n    value: covered,\n    enumerable: false,\n    configurable: false,\n    writable: false,\n  });\n}\n\nasync function sleep(delayMs: number, signal: AbortSignal | undefined): Promise<void> {\n  if (signal?.aborted || delayMs <= 0) {\n    return;\n  }\n  await new Promise<void>((resolve) => {\n    const timer = setTimeout(done, delayMs);\n    function done(): void {\n      clearTimeout(timer);\n      signal?.removeEventListener(\"abort\", done);\n      resolve();\n    }\n    signal?.addEventListener(\"abort\", done, { once: true });\n  });\n}\n"],"mappings":"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","names":[]}