@opengeni/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,955 @@
+// src/errors.ts
+var OpenGeniApiError = class extends Error {
+  status;
+  body;
+  constructor(status, body) {
+    super(`OpenGeni API ${status}: ${body || "(empty body)"}`);
+    this.name = "OpenGeniApiError";
+    this.status = status;
+    this.body = body;
+  }
+};
+var OpenGeniStreamError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OpenGeniStreamError";
+  }
+};
+function isAbortError(error) {
+  return error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError";
+}
+function isRetryableStreamError(error) {
+  if (error instanceof OpenGeniApiError) {
+    return error.status === 408 || error.status === 409 || error.status === 425 || error.status === 429 || error.status >= 500;
+  }
+  return error instanceof TypeError;
+}
+
+// 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 {
+    await reader.cancel().catch(() => {
+    });
+    reader.releaseLock();
+  }
+}
+
+// src/stream.ts
+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 maxAttempts = options.maxReconnectAttempts ?? Number.POSITIVE_INFINITY;
+  let cursor = options.after ?? 0;
+  let failedAttempts = 0;
+  let delayMs = baseDelayMs;
+  let everConnected = false;
+  while (!signal?.aborted) {
+    options.onStateChange?.(everConnected || failedAttempts > 0 ? "reconnecting" : "connecting");
+    const cursorAtOpen = cursor;
+    try {
+      const body = await transport.openStream(cursor, signal);
+      everConnected = true;
+      failedAttempts = 0;
+      delayMs = baseDelayMs;
+      options.onStateChange?.("live");
+      for await (const message of parseSseStream(body)) {
+        if (signal?.aborted) {
+          return;
+        }
+        const event = parseSessionEvent(message.data);
+        if (!event || event.sequence <= 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 = event.sequence;
+        yield event;
+      }
+      if (!reconnect) {
+        return;
+      }
+      if (cursor === cursorAtOpen) {
+        await sleep(baseDelayMs, 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(delayMs, signal);
+    delayMs = Math.min(Math.max(delayMs * 2, baseDelayMs), maxDelayMs);
+  }
+}
+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;
+}
+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 });
+  });
+}
+
+// src/client.ts
+var OpenGeniClient = class {
+  baseUrl;
+  options;
+  fetchImpl;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.options = options;
+    this.fetchImpl = options.fetch ?? ((input, init) => fetch(input, init));
+  }
+  // --- Session lifecycle ---------------------------------------------------
+  async createSession(workspaceId, request) {
+    return await this.requestJson("POST", `/v1/workspaces/${workspaceId}/sessions`, request);
+  }
+  async getSession(workspaceId, sessionId) {
+    return await this.requestJson("GET", `/v1/workspaces/${workspaceId}/sessions/${sessionId}`);
+  }
+  async listSessions(workspaceId, options = {}) {
+    return await this.requestJson("GET", `/v1/workspaces/${workspaceId}/sessions`, void 0, {
+      ...options.limit !== void 0 ? { limit: String(options.limit) } : {}
+    });
+  }
+  async listTurns(workspaceId, sessionId, options = {}) {
+    return await this.requestJson("GET", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/turns`, void 0, {
+      ...options.limit !== void 0 ? { limit: String(options.limit) } : {}
+    });
+  }
+  // --- Scheduled tasks -------------------------------------------------------
+  async listScheduledTasks(workspaceId, options = {}) {
+    return await this.requestJson("GET", `/v1/workspaces/${workspaceId}/scheduled-tasks`, void 0, {
+      ...options.limit !== void 0 ? { limit: String(options.limit) } : {}
+    });
+  }
+  async getScheduledTask(workspaceId, taskId) {
+    return await this.requestJson("GET", `/v1/workspaces/${workspaceId}/scheduled-tasks/${taskId}`);
+  }
+  // --- Events: replay, send, stream ----------------------------------------
+  /** Replay durable events by sequence: events with `sequence > after`, ascending. */
+  async listEvents(workspaceId, sessionId, options = {}) {
+    return await this.requestJson("GET", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/events`, void 0, {
+      ...options.after !== void 0 ? { after: String(options.after) } : {},
+      ...options.limit !== void 0 ? { limit: String(options.limit) } : {}
+    });
+  }
+  /** POST a user/control event to the session. Returns the accepted event. */
+  async sendEvent(workspaceId, sessionId, event) {
+    return await this.requestJson("POST", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/events`, event);
+  }
+  async sendMessage(workspaceId, sessionId, message) {
+    const input = typeof message === "string" ? { text: message } : message;
+    const { clientEventId, ...payload } = input;
+    return await this.sendEvent(workspaceId, sessionId, {
+      type: "user.message",
+      ...clientEventId !== void 0 ? { clientEventId } : {},
+      payload
+    });
+  }
+  async interrupt(workspaceId, sessionId, options = {}) {
+    return await this.sendEvent(workspaceId, sessionId, {
+      type: "user.interrupt",
+      ...options.clientEventId !== void 0 ? { clientEventId: options.clientEventId } : {},
+      payload: options.reason !== void 0 ? { reason: options.reason } : {}
+    });
+  }
+  async sendApprovalDecision(workspaceId, sessionId, decision) {
+    const { clientEventId, ...payload } = decision;
+    return await this.sendEvent(workspaceId, sessionId, {
+      type: "user.approvalDecision",
+      ...clientEventId !== void 0 ? { clientEventId } : {},
+      payload
+    });
+  }
+  /**
+   * Live-stream a session's events with automatic reconnect, resume from the
+   * last seen sequence, gap backfill, and duplicate suppression. See
+   * {@link streamSessionEvents} for the delivery guarantees.
+   */
+  streamEvents(workspaceId, sessionId, options = {}) {
+    return streamSessionEvents(this.eventStreamTransport(workspaceId, sessionId), options);
+  }
+  /** The transport `streamEvents` runs on; useful for custom streaming layers. */
+  eventStreamTransport(workspaceId, sessionId) {
+    return {
+      openStream: async (after, signal) => await this.openEventStream(workspaceId, sessionId, { after, ...signal ? { signal } : {} }),
+      listEvents: async (after, limit) => await this.listEvents(workspaceId, sessionId, { after, limit })
+    };
+  }
+  /** Open one raw SSE connection (no reconnect). Most callers want `streamEvents`. */
+  async openEventStream(workspaceId, sessionId, options = {}) {
+    const url = this.url(`/v1/workspaces/${workspaceId}/sessions/${sessionId}/events/stream`, {
+      after: String(options.after ?? 0)
+    });
+    const response = await this.fetchImpl(url, {
+      method: "GET",
+      headers: { ...this.headers(), Accept: "text/event-stream" },
+      ...options.signal ? { signal: options.signal } : {}
+    });
+    if (!response.ok) {
+      throw new OpenGeniApiError(response.status, await safeText(response));
+    }
+    if (!response.body) {
+      throw new OpenGeniApiError(response.status, "SSE response did not include a readable body");
+    }
+    return response.body;
+  }
+  // --- Turn queue ------------------------------------------------------------
+  /** Edit a still-queued turn (prompt, model, resources, tools, ...). */
+  async updateQueuedTurn(workspaceId, sessionId, turnId, update) {
+    return await this.requestJson(
+      "PATCH",
+      `/v1/workspaces/${workspaceId}/sessions/${sessionId}/turns/${turnId}`,
+      update
+    );
+  }
+  /**
+   * Reorder the queued turns. `turnIds` must all reference queued turns; the
+   * server assigns positions in the given order and returns the queue.
+   */
+  async reorderQueuedTurns(workspaceId, sessionId, turnIds) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/sessions/${sessionId}/turns/reorder`,
+      { turnIds }
+    );
+  }
+  /** Cancel a queued turn before it is claimed. Returns the cancelled turn. */
+  async deleteQueuedTurn(workspaceId, sessionId, turnId) {
+    return await this.requestJson(
+      "DELETE",
+      `/v1/workspaces/${workspaceId}/sessions/${sessionId}/turns/${turnId}`
+    );
+  }
+  /**
+   * Steer: deliver a message *now* instead of behind the queue. Sends the
+   * message, promotes its queued turn to the front, and interrupts the
+   * running turn so the session picks the steer turn up next. On a session
+   * that is not running this degrades gracefully to a plain queued message.
+   *
+   * The steer turn is located by `triggerEventId` across ALL turns (retried
+   * briefly in case the server is still materializing it) — not just the
+   * queued ones, because the worker can claim the steer turn before it is
+   * ever observed queued, and a claimed steer turn means the message is
+   * already being delivered: interrupting then would cancel the very message
+   * being steered. If the turn cannot be found while other turns are queued,
+   * the interrupt is also skipped — stopping the running turn would otherwise
+   * promote someone else's queued work over this message — and the call
+   * degrades to a plain queued send (`interrupted: false`).
+   */
+  async steerMessage(workspaceId, sessionId, message) {
+    const accepted = await this.sendMessage(workspaceId, sessionId, message);
+    let steerTurn = null;
+    let queued = [];
+    for (let attempt = 0; attempt < 4; attempt += 1) {
+      if (attempt > 0) {
+        await delay(150 * attempt);
+      }
+      const turns = await this.listTurns(workspaceId, sessionId);
+      queued = turns.filter((turn) => turn.status === "queued").sort((a, b) => a.position - b.position || a.createdAt.localeCompare(b.createdAt));
+      steerTurn = turns.find((turn) => turn.triggerEventId === accepted.id) ?? null;
+      if (steerTurn) {
+        break;
+      }
+    }
+    const steerTurnQueued = steerTurn?.status === "queued";
+    if (steerTurn && steerTurnQueued && queued.length > 1) {
+      const front = steerTurn;
+      await this.reorderQueuedTurns(workspaceId, sessionId, [
+        front.id,
+        ...queued.filter((turn) => turn.id !== front.id).map((turn) => turn.id)
+      ]);
+    }
+    const canDeliverNext = steerTurnQueued || steerTurn === null && queued.length === 0;
+    const session = await this.getSession(workspaceId, sessionId);
+    const steerTurnAlreadyActive = steerTurn !== null && session.activeTurnId === steerTurn.id;
+    const interrupted = canDeliverNext && !steerTurnAlreadyActive && (session.status === "running" || session.status === "requires_action");
+    if (interrupted) {
+      await this.interrupt(workspaceId, sessionId, { reason: "steer" });
+    }
+    return { accepted, turn: steerTurn, interrupted };
+  }
+  // --- Goals -------------------------------------------------------------------
+  /** The session's goal. 404s when the session never had one. */
+  async getGoal(workspaceId, sessionId) {
+    return await this.requestJson("GET", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/goal`);
+  }
+  async updateGoal(workspaceId, sessionId, request) {
+    return await this.requestJson("PATCH", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/goal`, request);
+  }
+  /** Pause the goal loop: the session stops self-continuing until resumed. */
+  async pauseGoal(workspaceId, sessionId, options = {}) {
+    return await this.updateGoal(workspaceId, sessionId, {
+      status: "paused",
+      ...options.rationale !== void 0 ? { rationale: options.rationale } : {}
+    });
+  }
+  /** Resume a paused goal: resets counters and re-arms the continuation loop. */
+  async resumeGoal(workspaceId, sessionId) {
+    return await this.updateGoal(workspaceId, sessionId, { status: "active" });
+  }
+  // --- Operator context controls (/clear, /compact) ---------------------------
+  /**
+   * Clear the session's conversation context. Destructive and audit-preserving:
+   * the server supersedes (never deletes) the live history and emits a
+   * `session.context.cleared` event. Refused (409) while a turn is in flight or
+   * awaiting action. `confirm:true` is sent so an accidental call cannot wipe
+   * context — the destructive intent is explicit on the wire.
+   */
+  async clearSessionContext(workspaceId, sessionId) {
+    await this.requestVoid("POST", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/context/clear`, { confirm: true });
+  }
+  /**
+   * Trigger conversation compaction now. On the client-managed (Azure) path this
+   * queues a forced compaction the worker honors before the next turn
+   * (`status:"queued"`); on a server-managed provider or when compaction is off
+   * it is a no-op (`status:"noop"`) with an explanatory message.
+   */
+  async compactSessionContext(workspaceId, sessionId) {
+    return await this.requestJson("POST", `/v1/workspaces/${workspaceId}/sessions/${sessionId}/context/compact`, {});
+  }
+  // --- Access + workspaces -----------------------------------------------------
+  /** The caller's access context: subject, account + workspace grants, defaults. */
+  async getAccessContext() {
+    return await this.requestJson("GET", "/v1/access/me");
+  }
+  async listWorkspaces() {
+    return await this.requestJson("GET", "/v1/workspaces");
+  }
+  async createWorkspace(request) {
+    return await this.requestJson("POST", "/v1/workspaces", request);
+  }
+  async getWorkspace(workspaceId) {
+    return await this.requestJson("GET", `/v1/workspaces/${workspaceId}`);
+  }
+  async updateWorkspace(workspaceId, request) {
+    return await this.requestJson("PATCH", `/v1/workspaces/${workspaceId}`, request);
+  }
+  // --- Scheduled tasks (write + runs) -------------------------------------------
+  async createScheduledTask(workspaceId, request) {
+    return await this.requestJson("POST", `/v1/workspaces/${workspaceId}/scheduled-tasks`, request);
+  }
+  async updateScheduledTask(workspaceId, taskId, request) {
+    return await this.requestJson("PATCH", `/v1/workspaces/${workspaceId}/scheduled-tasks/${taskId}`, request);
+  }
+  async pauseScheduledTask(workspaceId, taskId) {
+    return await this.requestJson("POST", `/v1/workspaces/${workspaceId}/scheduled-tasks/${taskId}/pause`);
+  }
+  async resumeScheduledTask(workspaceId, taskId) {
+    return await this.requestJson("POST", `/v1/workspaces/${workspaceId}/scheduled-tasks/${taskId}/resume`);
+  }
+  /**
+   * Fire the task immediately (manual trigger), independent of its schedule.
+   * Pass a stable `triggerId` to make a retried trigger idempotent — the same
+   * token charges once and starts one run. Omit it and each call is distinct.
+   */
+  async triggerScheduledTask(workspaceId, taskId, options = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/scheduled-tasks/${taskId}/trigger`,
+      options.triggerId ? { triggerId: options.triggerId } : void 0
+    );
+  }
+  async deleteScheduledTask(workspaceId, taskId) {
+    await this.requestJson("DELETE", `/v1/workspaces/${workspaceId}/scheduled-tasks/${taskId}`);
+  }
+  async listScheduledTaskRuns(workspaceId, taskId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/scheduled-tasks/${taskId}/runs`,
+      void 0,
+      { ...options.limit !== void 0 ? { limit: String(options.limit) } : {} }
+    );
+  }
+  // --- Environments --------------------------------------------------------------
+  // Variable values are write-only: reads return name/version metadata only.
+  async listEnvironments(workspaceId) {
+    return await this.requestJson("GET", `/v1/workspaces/${workspaceId}/environments`);
+  }
+  async createEnvironment(workspaceId, request) {
+    return await this.requestJson("POST", `/v1/workspaces/${workspaceId}/environments`, request);
+  }
+  async getEnvironment(workspaceId, environmentId) {
+    return await this.requestJson("GET", `/v1/workspaces/${workspaceId}/environments/${environmentId}`);
+  }
+  async updateEnvironment(workspaceId, environmentId, request) {
+    return await this.requestJson(
+      "PATCH",
+      `/v1/workspaces/${workspaceId}/environments/${environmentId}`,
+      request
+    );
+  }
+  async deleteEnvironment(workspaceId, environmentId) {
+    await this.requestJson("DELETE", `/v1/workspaces/${workspaceId}/environments/${environmentId}`);
+  }
+  /** Create or rotate a variable. The value never comes back on any read. */
+  async setEnvironmentVariable(workspaceId, environmentId, name, value) {
+    return await this.requestJson(
+      "PUT",
+      `/v1/workspaces/${workspaceId}/environments/${environmentId}/variables/${encodeURIComponent(name)}`,
+      { value }
+    );
+  }
+  async deleteEnvironmentVariable(workspaceId, environmentId, name) {
+    await this.requestJson(
+      "DELETE",
+      `/v1/workspaces/${workspaceId}/environments/${environmentId}/variables/${encodeURIComponent(name)}`
+    );
+  }
+  // --- Files -----------------------------------------------------------------------
+  /** Step 1 of the upload flow: returns the pre-signed PUT target. */
+  async beginFileUpload(workspaceId, request) {
+    return await this.requestJson("POST", `/v1/workspaces/${workspaceId}/files/uploads`, request);
+  }
+  /** Step 3 of the upload flow: server verifies the object and marks it ready. */
+  async completeFileUpload(workspaceId, uploadId) {
+    const response = await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/files/uploads/${uploadId}/complete`
+    );
+    return response.file;
+  }
+  /**
+   * The whole upload flow as one call: begin -> PUT the bytes to the signed
+   * URL (with its required headers; no API auth is sent to object storage)
+   * -> complete. Returns the ready `FileAsset`.
+   */
+  async uploadFile(workspaceId, input) {
+    const body = input.data instanceof Uint8Array ? new Blob([input.data.slice()]) : input.data;
+    const sizeBytes = typeof body === "string" ? new TextEncoder().encode(body).byteLength : body instanceof Blob ? body.size : body.byteLength;
+    const upload = await this.beginFileUpload(workspaceId, {
+      filename: input.filename,
+      contentType: input.contentType,
+      sizeBytes,
+      ...input.sha256 !== void 0 ? { sha256: input.sha256 } : {}
+    });
+    const putResponse = await this.fetchImpl(upload.putUrl, {
+      method: "PUT",
+      // The backend's requiredHeaders already carry the canonical lowercase
+      // `content-type` for every storage backend (Azure/S3/GCS). Do NOT also set
+      // a `Content-Type` key here: WHATWG Headers treats the two casings as the
+      // same header and comma-joins their values (e.g. "text/plain, text/plain"),
+      // which the object store persists verbatim and COMPLETE then rejects (422),
+      // and which breaks S3's presigned-URL signature.
+      headers: { ...upload.requiredHeaders },
+      body
+    });
+    if (!putResponse.ok) {
+      throw new OpenGeniApiError(putResponse.status, await safeText(putResponse));
+    }
+    return await this.completeFileUpload(workspaceId, upload.uploadId);
+  }
+  async getFile(workspaceId, fileId) {
+    return await this.requestJson("GET", `/v1/workspaces/${workspaceId}/files/${fileId}`);
+  }
+  /** Mint a short-lived signed download URL for a ready file. */
+  async createFileDownloadUrl(workspaceId, fileId) {
+    return await this.requestJson("POST", `/v1/workspaces/${workspaceId}/files/${fileId}/download-url`);
+  }
+  // --- Documents ----------------------------------------------------------------------
+  async createDocumentBase(workspaceId, request) {
+    return await this.requestJson("POST", `/v1/workspaces/${workspaceId}/document-bases`, request);
+  }
+  async listDocumentBases(workspaceId) {
+    return await this.requestJson("GET", `/v1/workspaces/${workspaceId}/document-bases`);
+  }
+  async getDocumentBase(workspaceId, baseId) {
+    return await this.requestJson("GET", `/v1/workspaces/${workspaceId}/document-bases/${baseId}`);
+  }
+  /** Index an uploaded file into the base. The file must be `ready`. */
+  async addDocument(workspaceId, baseId, request) {
+    return await this.requestJson("POST", `/v1/workspaces/${workspaceId}/document-bases/${baseId}/documents`, request);
+  }
+  async listDocuments(workspaceId, baseId) {
+    return await this.requestJson("GET", `/v1/workspaces/${workspaceId}/document-bases/${baseId}/documents`);
+  }
+  /** Retry indexing for a failed document. */
+  async reindexDocument(workspaceId, baseId, documentId) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/document-bases/${baseId}/documents/${documentId}/reindex`
+    );
+  }
+  async searchDocuments(workspaceId, baseId, request) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/document-bases/${baseId}/search`,
+      request
+    );
+  }
+  // --- Capability packs ------------------------------------------------------------------
+  /** Built-in + registered packs, with the workspace's installations. */
+  async listPacks(workspaceId) {
+    return await this.requestJson("GET", `/v1/workspaces/${workspaceId}/packs`);
+  }
+  /** Register (or replace) a workspace-scoped pack from a manifest. */
+  async registerPack(workspaceId, manifest) {
+    return await this.requestJson("POST", `/v1/workspaces/${workspaceId}/packs`, manifest);
+  }
+  async getPack(workspaceId, packId) {
+    return await this.requestJson("GET", `/v1/workspaces/${workspaceId}/packs/${encodeURIComponent(packId)}`);
+  }
+  async enablePack(workspaceId, packId, request = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/packs/${encodeURIComponent(packId)}/enable`,
+      request
+    );
+  }
+  /** Unregister a workspace-scoped pack (built-in packs cannot be deleted). */
+  async deletePack(workspaceId, packId) {
+    await this.requestVoid("DELETE", `/v1/workspaces/${workspaceId}/packs/${encodeURIComponent(packId)}`);
+  }
+  async listPackInstallations(workspaceId) {
+    return await this.requestJson("GET", `/v1/workspaces/${workspaceId}/packs/installations`);
+  }
+  // --- Capabilities -------------------------------------------------------------------------
+  async listCapabilities(workspaceId) {
+    return await this.requestJson("GET", `/v1/workspaces/${workspaceId}/capabilities`);
+  }
+  /** Add a manual capability catalog item (e.g. a remote MCP server). */
+  async createCapability(workspaceId, request) {
+    return await this.requestJson("POST", `/v1/workspaces/${workspaceId}/capabilities`, request);
+  }
+  async enableCapability(workspaceId, capabilityId, request = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/capabilities/${encodeURIComponent(capabilityId)}/enable`,
+      request
+    );
+  }
+  async disableCapability(workspaceId, capabilityId) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/capabilities/${encodeURIComponent(capabilityId)}/disable`
+    );
+  }
+  /** Search the official MCP registry for installable capabilities. */
+  async discoverMcpCapabilities(workspaceId, options = {}) {
+    return await this.requestJson(
+      "GET",
+      `/v1/workspaces/${workspaceId}/capabilities/discovery/mcp-registry`,
+      void 0,
+      {
+        ...options.query !== void 0 ? { query: options.query } : {},
+        ...options.limit !== void 0 ? { limit: String(options.limit) } : {}
+      }
+    );
+  }
+  // --- GitHub ----------------------------------------------------------------------------------
+  /** GitHub App configuration status + a signed install URL when configured. */
+  async getGitHubApp(workspaceId) {
+    return await this.requestJson("GET", `/v1/workspaces/${workspaceId}/github/app`);
+  }
+  /**
+   * Browser entry point that plants the CSRF cookie and forwards to GitHub's
+   * install page. Open this in a browser (it redirects); `state` comes from
+   * `getGitHubApp().installUrl` or a github_connect_link tool.
+   */
+  githubConnectUrl(workspaceId, state) {
+    return this.url(`/v1/workspaces/${workspaceId}/github/connect`, { state });
+  }
+  async listGitHubRepositories(workspaceId) {
+    return await this.requestJson("GET", `/v1/workspaces/${workspaceId}/github/repositories`);
+  }
+  /** Re-sync the installation's repository list from GitHub. */
+  async syncGitHubRepositories(workspaceId) {
+    return await this.requestJson("POST", `/v1/workspaces/${workspaceId}/github/repositories/sync`);
+  }
+  /** Build a GitHub App manifest + the GitHub URL to submit it to. */
+  async createGitHubAppManifest(workspaceId, request = {}) {
+    return await this.requestJson(
+      "POST",
+      `/v1/workspaces/${workspaceId}/github/app-manifest`,
+      request
+    );
+  }
+  // --- API keys ----------------------------------------------------------------------------------
+  async listApiKeys(workspaceId) {
+    const response = await this.requestJson("GET", `/v1/workspaces/${workspaceId}/api-keys`);
+    return response.apiKeys;
+  }
+  /** The returned `token` is shown once; only its prefix is stored. */
+  async createApiKey(workspaceId, request) {
+    return await this.requestJson("POST", `/v1/workspaces/${workspaceId}/api-keys`, request);
+  }
+  /** Revoke an API key. Returns the revoked key. */
+  async deleteApiKey(workspaceId, apiKeyId) {
+    return await this.requestJson("DELETE", `/v1/workspaces/${workspaceId}/api-keys/${apiKeyId}`);
+  }
+  // --- Billing (account-scoped) --------------------------------------------------------------------
+  async getBilling(options = {}) {
+    return await this.requestJson("GET", "/v1/billing", void 0, {
+      ...options.accountId !== void 0 ? { accountId: options.accountId } : {}
+    });
+  }
+  async getBillingUsage(options = {}) {
+    return await this.requestJson("GET", "/v1/billing/usage", void 0, {
+      ...options.accountId !== void 0 ? { accountId: options.accountId } : {},
+      ...options.workspaceId !== void 0 ? { workspaceId: options.workspaceId } : {}
+    });
+  }
+  async getBillingEntitlements(options = {}) {
+    return await this.requestJson("GET", "/v1/billing/entitlements", void 0, {
+      ...options.accountId !== void 0 ? { accountId: options.accountId } : {}
+    });
+  }
+  /** Start a Stripe checkout for prepaid credits. */
+  async createBillingCheckout(request) {
+    return await this.requestJson("POST", "/v1/billing/checkout", request);
+  }
+  // --- Internals -------------------------------------------------------------
+  headers() {
+    const extra = typeof this.options.headers === "function" ? this.options.headers() : this.options.headers;
+    return {
+      ...this.options.apiKey ? { Authorization: `Bearer ${this.options.apiKey}` } : {},
+      ...extra
+    };
+  }
+  url(path, query = {}) {
+    const params = new URLSearchParams(query).toString();
+    return `${this.baseUrl}${path}${params ? `?${params}` : ""}`;
+  }
+  async requestJson(method, path, body, query = {}) {
+    const response = await this.fetchImpl(this.url(path, query), {
+      method,
+      headers: {
+        ...this.headers(),
+        Accept: "application/json",
+        ...body !== void 0 ? { "Content-Type": "application/json" } : {}
+      },
+      ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+    });
+    if (!response.ok) {
+      throw new OpenGeniApiError(response.status, await safeText(response));
+    }
+    return await response.json();
+  }
+  /** Like `requestJson` for endpoints that respond with no body (204). */
+  async requestVoid(method, path, body) {
+    const response = await this.fetchImpl(this.url(path), {
+      method,
+      headers: {
+        ...this.headers(),
+        Accept: "application/json",
+        ...body !== void 0 ? { "Content-Type": "application/json" } : {}
+      },
+      ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+    });
+    if (!response.ok) {
+      throw new OpenGeniApiError(response.status, await safeText(response));
+    }
+  }
+};
+async function safeText(response) {
+  try {
+    return await response.text();
+  } catch {
+    return "";
+  }
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/proxy.ts
+function formatSseEvent(event) {
+  return `id: ${event.sequence}
+event: ${event.type}
+data: ${JSON.stringify(event)}
+
+`;
+}
+function sessionEventsToSseStream(events, options = {}) {
+  const encoder = new TextEncoder();
+  const iterator = events[Symbol.asyncIterator]();
+  let heartbeat;
+  let cancelled = false;
+  const stopHeartbeat = () => {
+    if (heartbeat !== void 0) {
+      clearInterval(heartbeat);
+      heartbeat = void 0;
+    }
+  };
+  return new ReadableStream({
+    start: (controller) => {
+      if (options.heartbeatMs !== void 0) {
+        heartbeat = setInterval(() => {
+          try {
+            controller.enqueue(encoder.encode(": ping\n\n"));
+          } catch {
+            stopHeartbeat();
+          }
+        }, options.heartbeatMs);
+      }
+    },
+    pull: async (controller) => {
+      let result;
+      try {
+        result = await iterator.next();
+      } catch (error) {
+        stopHeartbeat();
+        throw error;
+      }
+      if (cancelled) {
+        return;
+      }
+      if (result.done) {
+        stopHeartbeat();
+        controller.close();
+        return;
+      }
+      controller.enqueue(encoder.encode(formatSseEvent(result.value)));
+    },
+    cancel: () => {
+      cancelled = true;
+      stopHeartbeat();
+      options.onCancel?.();
+      void Promise.resolve(iterator.return?.(void 0)).then(
+        () => void 0,
+        () => void 0
+      );
+    }
+  });
+}
+function sessionEventsToSseResponse(events, options = {}) {
+  return new Response(sessionEventsToSseStream(events, options), {
+    headers: {
+      "Content-Type": "text/event-stream; charset=utf-8",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive"
+    }
+  });
+}
+function resumeSequenceFromRequest(request) {
+  const url = new URL(request.url);
+  const raw = url.searchParams.get("after") ?? request.headers.get("Last-Event-ID");
+  const parsed = raw === null ? 0 : Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : 0;
+}
+function proxySessionEventStream(client, workspaceId, sessionId, options = {}) {
+  const { after, heartbeatMs, signal, ...streamOptions } = options;
+  const upstream = new AbortController();
+  if (signal?.aborted) {
+    upstream.abort();
+  } else {
+    signal?.addEventListener("abort", () => upstream.abort(), { once: true });
+  }
+  const resolvedAfter = after instanceof Request ? resumeSequenceFromRequest(after) : after ?? 0;
+  const events = client.streamEvents(workspaceId, sessionId, {
+    ...streamOptions,
+    after: resolvedAfter,
+    signal: upstream.signal
+  });
+  return sessionEventsToSseResponse(events, {
+    ...heartbeatMs !== void 0 ? { heartbeatMs } : {},
+    onCancel: () => upstream.abort()
+  });
+}
+
+// src/types.ts
+var SESSION_EVENT_TYPES = [
+  "session.created",
+  "session.status.changed",
+  "session.requiresAction",
+  "session.context.compacted",
+  "session.context.cleared",
+  "user.message",
+  "user.interrupt",
+  "user.approvalDecision",
+  "turn.queued",
+  "turn.updated",
+  "turn.started",
+  "turn.completed",
+  "turn.failed",
+  "turn.cancelled",
+  "turn.preempted",
+  "agent.message.delta",
+  "agent.message.completed",
+  "agent.reasoning.delta",
+  "agent.toolCall.created",
+  "agent.toolCall.output",
+  "agent.updated",
+  "sandbox.operation.started",
+  "sandbox.operation.completed",
+  "sandbox.operation.failed",
+  "sandbox.command.output.delta",
+  "artifact.created",
+  "goal.set",
+  "goal.updated",
+  "goal.completed",
+  "goal.paused",
+  "goal.resumed",
+  "goal.continuation"
+];
+var KNOWN_PERMISSIONS = [
+  "account:read",
+  "account:admin",
+  "members:manage",
+  "workspace:create",
+  "billing:read",
+  "billing:manage",
+  "workspace:read",
+  "workspace:admin",
+  "sessions:create",
+  "sessions:read",
+  "sessions:control",
+  "files:upload",
+  "files:read",
+  "documents:manage",
+  "documents:search",
+  "scheduled_tasks:manage",
+  "scheduled_tasks:run",
+  "github:manage",
+  "github:use",
+  "api_keys:manage",
+  "environments:manage",
+  "environments:use",
+  "goals:manage"
+];
+var KNOWN_USAGE_EVENT_TYPES = [
+  "agent_run.created",
+  "agent_run.completed",
+  "model.tokens",
+  "model.cost",
+  "file.uploaded",
+  "file.deleted",
+  "document.indexed",
+  "scheduled_task.fired",
+  "api_key.request"
+];
+export {
+  KNOWN_PERMISSIONS,
+  KNOWN_USAGE_EVENT_TYPES,
+  OpenGeniApiError,
+  OpenGeniClient,
+  OpenGeniStreamError,
+  SESSION_EVENT_TYPES,
+  formatSseEvent,
+  isRetryableStreamError,
+  parseSseStream,
+  proxySessionEventStream,
+  resumeSequenceFromRequest,
+  sessionEventsToSseResponse,
+  sessionEventsToSseStream,
+  streamSessionEvents
+};
+//# sourceMappingURL=index.js.map