@ellipsis-dev/sdk 0.7.0 → 0.8.1

package/dist/index.js

@@ -1,97 +1,1227 @@
-// src/client.ts
-var EllipsisClient = class {
-  constructor(fetchJson) {
-    this.fetchJson = fetchJson;
-  }
-  fetchJson;
-  // The enriched public session (§4.1) — the same lean wire shape the
-  // stream's session frames carry.
-  async getSession(sessionId) {
-    return await this.fetchJson(
-      `/sessions/${encodeURIComponent(sessionId)}`
-    );
+// src/core/pagination.ts
+var Page = class {
+  constructor(response, itemsAttr, fetchNext) {
+    this.response = response;
+    this.itemsAttr = itemsAttr;
+    this.fetchNext = fetchNext;
   }
-  // The record log + inbox messages (§4.3). Bare call = the full transcript;
-  // pass afterSeq/limit to page (limit max 1000, `has_more` signals more).
-  async getSessionRecords(sessionId, options = {}) {
-    const params = new URLSearchParams();
-    if (options.afterSeq != null)
-      params.set("after_seq", String(options.afterSeq));
-    if (options.limit != null) params.set("limit", String(options.limit));
-    const query = params.toString();
-    return await this.fetchJson(
-      `/sessions/${encodeURIComponent(sessionId)}/records` + (query ? `?${query}` : "")
-    );
+  response;
+  itemsAttr;
+  fetchNext;
+  get items() {
+    return this.response[this.itemsAttr];
   }
-  // The session's turns — the structural conversation history (message ->
-  // response exchanges with status/cost).
-  async getSessionTurns(sessionId) {
-    return await this.fetchJson(
-      `/sessions/${encodeURIComponent(sessionId)}/turns`
-    );
+  get hasMore() {
+    return this.response.has_more;
   }
-  // The session's executions (initial start, cold wakes, infra retries) with
-  // their launch context: `system_prompt_append` is the text Ellipsis appends
-  // to Claude Code's default system prompt, alongside the initial query and
-  // model. Per execution because each cold wake persists its own launch
-  // config.
-  async getSessionExecutions(sessionId) {
-    return await this.fetchJson(
-      `/sessions/${encodeURIComponent(sessionId)}/executions`
-    );
+  get nextCursor() {
+    return this.response.next_cursor ?? null;
+  }
+  async *[Symbol.asyncIterator]() {
+    let page = this;
+    for (; ; ) {
+      yield* page.items;
+      const cursor = page.nextCursor;
+      if (!page.hasMore || cursor == null) return;
+      page = await this.fetchNext(cursor);
+    }
+  }
+};
+
+// src/core/sessionHandle.ts
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "completed",
+  "error",
+  "cancelled",
+  "stopped"
+]);
+var DEFAULT_POLL_INTERVAL_MS = 3e3;
+function isSettled(session) {
+  if (TERMINAL_STATUSES.has(session.status)) return true;
+  return session.session_state === "idle" || session.session_state === "closed";
+}
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var SessionHandle = class {
+  constructor(sessions, session) {
+    this.sessions = sessions;
+    this.id = session.id;
+    this.session = session;
+  }
+  sessions;
+  id;
+  // The latest session snapshot this handle saw.
+  session;
+  async refresh() {
+    this.session = (await this.sessions.get(this.id)).session;
+    return this.session;
+  }
+  // Poll until the session settles (terminal status, or a parked
+  // conversation: state idle/closed).
+  async wait(options = {}) {
+    const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    const deadline = options.timeoutMs == null ? null : Date.now() + options.timeoutMs;
+    for (; ; ) {
+      const session = await this.refresh();
+      if (isSettled(session)) return session;
+      if (deadline != null && Date.now() >= deadline) {
+        throw new Error(
+          `session ${this.id} not terminal after ${options.timeoutMs}ms`
+        );
+      }
+      await sleep(pollIntervalMs);
+    }
+  }
+  // Post into the session's inbox (delivered at the next turn boundary;
+  // wakes a parked session).
+  async send(message, options = {}) {
+    const response = await this.sessions.sendMessage(this.id, {
+      message,
+      idempotency_key: options.idempotencyKey
+    });
+    return response.message;
+  }
+  async stop() {
+    this.session = (await this.sessions.stop(this.id)).session;
+    return this.session;
+  }
+};
+
+// src/core/errors.ts
+var EllipsisError = class extends Error {
+};
+var TransportError = class extends EllipsisError {
+};
+var APIError = class extends EllipsisError {
+  status;
+  code;
+  requestId;
+  body;
+  constructor(args) {
+    super(`${args.status} ${args.code ?? "error"}: ${args.message}`);
+    this.status = args.status;
+    this.code = args.code;
+    this.requestId = args.requestId;
+    this.body = args.body;
   }
-  // Send a message into the session's inbox (§4.2). Returns the created (or,
-  // on an idempotent retry, the original) inbox row — clients key optimistic
-  // echo chips on its id. `idempotencyKey` makes retries safe per
-  // (session, key); a closed or non-interactive session rejects with a 409
-  // (surface the server's curated copy).
-  async sendSessionMessage(sessionId, message, options = {}) {
-    return await this.fetchJson(
-      `/sessions/${encodeURIComponent(sessionId)}/messages`,
-      {
-        method: "POST",
-        body: {
-          message,
-          ...options.idempotencyKey != null ? { idempotency_key: options.idempotencyKey } : {}
+};
+var AuthenticationError = class extends APIError {
+};
+var ForbiddenError = class extends APIError {
+};
+var NotFoundError = class extends APIError {
+};
+var ConflictError = class extends APIError {
+};
+var UnprocessableError = class extends APIError {
+};
+var RateLimitError = class extends APIError {
+};
+var ServerError = class extends APIError {
+};
+var STATUS_CLASSES = {
+  401: AuthenticationError,
+  403: ForbiddenError,
+  404: NotFoundError,
+  409: ConflictError,
+  422: UnprocessableError,
+  429: RateLimitError
+};
+function apiErrorFor(status, body) {
+  let code = null;
+  let message = "";
+  let requestId = null;
+  if (body !== null && typeof body === "object") {
+    const error = body.error;
+    if (error !== null && typeof error === "object") {
+      const info = error;
+      if (typeof info.code === "string") code = info.code;
+      if (typeof info.message === "string") message = info.message;
+      if (typeof info.request_id === "string") requestId = info.request_id;
+    } else if ("detail" in body) {
+      message = String(body.detail);
+    }
+  }
+  if (!message) {
+    message = body == null ? "no response body" : String(body).slice(0, 500);
+  }
+  const cls = STATUS_CLASSES[status] ?? (status >= 500 ? ServerError : APIError);
+  return new cls({ status, code, message, requestId, body });
+}
+
+// src/core/transport.ts
+var DEFAULT_BASE_URL = "https://api.ellipsis.dev";
+var DEFAULT_TIMEOUT_MS = 6e4;
+var RETRY_STATUSES = /* @__PURE__ */ new Set([429, 502, 503, 504]);
+var MAX_RETRIES = 2;
+function queryScalar(value) {
+  if (value instanceof Date) return value.toISOString();
+  return String(value);
+}
+function buildQuery(params) {
+  const search = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value == null) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) search.append(key, queryScalar(item));
+    } else {
+      search.append(key, queryScalar(value));
+    }
+  }
+  const rendered = search.toString();
+  return rendered ? `?${rendered}` : "";
+}
+function buildBody(body) {
+  const out = {};
+  for (const [key, value] of Object.entries(body)) {
+    if (value == null) continue;
+    out[key] = value instanceof Date ? value.toISOString() : value;
+  }
+  return out;
+}
+function backoffMs(attempt, retryAfter) {
+  if (retryAfter != null) {
+    const seconds = Number(retryAfter);
+    if (!Number.isNaN(seconds)) return Math.max(0, seconds * 1e3);
+  }
+  return 2 ** attempt * 500 + Math.random() * 250;
+}
+var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var Transport = class {
+  baseUrl;
+  headers;
+  timeoutMs;
+  maxRetries;
+  fetchImpl;
+  constructor(options) {
+    this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.headers = { Authorization: `Bearer ${options.apiKey}` };
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.maxRetries = options.maxRetries ?? MAX_RETRIES;
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+  }
+  async request(method, path, options = {}) {
+    const url = this.baseUrl + path + (options.query ?? "");
+    const init = { method, headers: { ...this.headers } };
+    if (options.body !== void 0) {
+      init.headers["Content-Type"] = "application/json";
+      init.body = JSON.stringify(options.body);
+    }
+    for (let attempt = 0; ; attempt++) {
+      let response;
+      try {
+        response = await this.fetchImpl(url, {
+          ...init,
+          signal: AbortSignal.timeout(this.timeoutMs)
+        });
+      } catch (error) {
+        if (attempt < this.maxRetries) {
+          await sleep2(backoffMs(attempt, null));
+          continue;
         }
+        throw new TransportError(String(error));
       }
+      if (RETRY_STATUSES.has(response.status) && attempt < this.maxRetries) {
+        await sleep2(backoffMs(attempt, response.headers.get("retry-after")));
+        continue;
+      }
+      if (response.status >= 400) {
+        let body = null;
+        try {
+          body = await response.json();
+        } catch {
+          body = await response.text().catch(() => null);
+        }
+        throw apiErrorFor(response.status, body);
+      }
+      if (response.status === 204) return void 0;
+      return await response.json();
+    }
+  }
+};
+
+// src/core/client.ts
+var enc = encodeURIComponent;
+var EllipsisAgentsConfigs = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /**
+   * Create Agent Config
+   *
+   * Create an agent config via pull request.
+   *
+   * The PR adds the config file to agents/ on the target
+   * repository.
+   *
+   * Accepts an inline config or a gallery template slug.
+   */
+  async create(options) {
+    const path = "/agents/configs";
+    const body = buildBody({ config: options.config, path: options.path, repository: options.repository, template_id: options.template_id });
+    return await this.transport.request("POST", path, { body });
+  }
+  /**
+   * Get Agent Config
+   *
+   * Return one saved agent config by id.
+   */
+  async get(config_id) {
+    const path = `/agents/configs/${enc(config_id)}`;
+    return await this.transport.request("GET", path);
+  }
+  /**
+   * List Agent Configs
+   *
+   * List saved agent configs.
+   */
+  async list() {
+    const path = "/agents/configs";
+    return await this.transport.request("GET", path);
+  }
+};
+var EllipsisAgentsDefaults = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /**
+   * Delete Agent Default
+   *
+   * Clear a default agent config.
+   *
+   * Addressed by rung: the account rung (repository omitted) or a
+   * repository rung.
+   *
+   * Refused for sandbox tokens.
+   */
+  async delete(options = {}) {
+    const path = "/agents/defaults";
+    const query = buildQuery({ repository: options.repository });
+    await this.transport.request("DELETE", path, { query });
+  }
+  /**
+   * List Agent Defaults
+   *
+   * List default agent configs.
+   *
+   * The account default and any per-repository defaults.
+   *
+   * Defaults are addressed by rung: the account rung is repository
+   * omitted, a repo rung is "owner/name" — never by row id.
+   */
+  async list() {
+    const path = "/agents/defaults";
+    return await this.transport.request("GET", path);
+  }
+  /**
+   * Put Agent Default
+   *
+   * Set a default agent config.
+   *
+   * Addressed by rung: the account rung (repository omitted) or a
+   * repository rung ("owner/name").
+   *
+   * Refused for sandbox tokens (potentially prompt-injected code
+   * must not repoint the account's ambient default); an unknown or
+   * foreign repository is a 404.
+   */
+  async set(options) {
+    const path = "/agents/defaults";
+    const body = buildBody({ config_id: options.config_id, repository: options.repository });
+    return await this.transport.request("PUT", path, { body });
+  }
+};
+var EllipsisAgentsTemplates = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /**
+   * Get Agent Template
+   *
+   * Return one built-in agent template by slug.
+   */
+  async get(template_id) {
+    const path = `/agents/templates/${enc(template_id)}`;
+    return await this.transport.request("GET", path);
+  }
+  /**
+   * List Agent Templates
+   *
+   * List the built-in starter agent templates.
+   *
+   * Behind auth but not account-scoped — the data is static
+   * product content shared by the dashboard, landing site, and CLI.
+   */
+  async list() {
+    const path = "/agents/templates";
+    return await this.transport.request("GET", path);
+  }
+};
+var EllipsisAgents = class {
+  constructor(transport) {
+    this.transport = transport;
+    this.configs = new EllipsisAgentsConfigs(transport);
+    this.defaults = new EllipsisAgentsDefaults(transport);
+    this.templates = new EllipsisAgentsTemplates(transport);
+  }
+  transport;
+  configs;
+  defaults;
+  templates;
+};
+var EllipsisAlerts = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /**
+   * Dismiss Alert
+   *
+   * Dismiss an open alert and return it.
+   *
+   * 409 when the alert is not open; 404 when it doesn't exist.
+   */
+  async dismiss(alert_id) {
+    const path = `/alerts/${enc(alert_id)}/dismiss`;
+    return await this.transport.request("POST", path);
+  }
+  /**
+   * Get Alert
+   *
+   * Return one alert by id.
+   *
+   * 404 if it doesn't exist or belongs to another organization.
+   */
+  async get(alert_id) {
+    const path = `/alerts/${enc(alert_id)}`;
+    return await this.transport.request("GET", path);
+  }
+  /**
+   * List Alerts
+   *
+   * List budget alerts for the organization, newest first.
+   *
+   * Optionally filtered by status and source.
+   *
+   * Available to all credential types, so an agent can check "is
+   * this org near budget?" mid-task.
+   */
+  async list(options = {}) {
+    const path = "/alerts";
+    const query = buildQuery({ status: options.status, source: options.source, limit: options.limit, cursor: options.cursor });
+    const response = await this.transport.request("GET", path, { query });
+    return new Page(
+      response,
+      "alerts",
+      (cursor) => this.list({ ...options, cursor })
     );
   }
-  // Trigger a code review on a pull request, or on a pushed branch (the
-  // platform finds-or-creates a draft PR for it). A review's `id` IS a session
-  // id, so callers stream it with the stream client and then re-read it below
-  // for the findings — which only exist once the review finalizes. A review
-  // with nothing new to look at comes back with `status: 'skipped'`, not an
-  // error.
-  async createReview(request) {
-    return await this.fetchJson("/reviews", {
-      method: "POST",
-      body: request
-    });
+};
+var EllipsisAnalytics = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /**
+   * Get Analytics Metrics
+   *
+   * Return PR and review analytics metrics.
+   *
+   * The same data as the analytics dashboard.
+   *
+   * Windowing: pass explicit start/end, or days (default: the last
+   * 30 days). account_type in all|user|bot scopes the authors (bot =
+   * the apps/agents). Available to all credential types: the
+   * responses expose the organization's own GitHub PR/review activity,
+   * no secrets.
+   */
+  async metrics(options = {}) {
+    const path = "/analytics/metrics";
+    const query = buildQuery({ days: options.days, start: options.start, end: options.end, repo: options.repo, author: options.author, account_type: options.account_type, status: options.status });
+    return await this.transport.request("GET", path, { query });
+  }
+  /**
+   * Get Analytics Pull Requests
+   *
+   * Return pull-request analytics.
+   *
+   * Windowing: pass explicit start/end, or days (default: the last
+   * 30 days).
+   */
+  async pullRequests(options = {}) {
+    const path = "/analytics/pull-requests";
+    const query = buildQuery({ days: options.days, start: options.start, end: options.end, account_type: options.account_type, repository_id: options.repository_id, author_id: options.author_id, status: options.status });
+    return await this.transport.request("GET", path, { query });
+  }
+  /**
+   * Get Analytics Reviews
+   *
+   * Return code-review analytics.
+   *
+   * account_type scopes reviewers (bot|user|all) — e.g. "what apps
+   * review the most PRs?" is the reviewer facets here with
+   * account_type=bot. Windowing: pass explicit start/end, or days
+   * (default: the last 30 days).
+   */
+  async reviews(options = {}) {
+    const path = "/analytics/reviews";
+    const query = buildQuery({ days: options.days, start: options.start, end: options.end, repo: options.repo, author: options.author, account_type: options.account_type, review_state: options.review_state });
+    return await this.transport.request("GET", path, { query });
+  }
+};
+var EllipsisAuthCli = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /**
+   * Cli Auth Poll
+   *
+   * Poll a device-code auth flow for its token.
+   *
+   * Unauthenticated; the device code identifies the flow.
+   */
+  async poll(options) {
+    const path = "/auth/cli/poll";
+    const body = buildBody({ device_code: options.device_code });
+    return await this.transport.request("POST", path, { body });
+  }
+  /**
+   * Cli Auth Start
+   *
+   * Start a device-code auth flow for the CLI.
+   *
+   * Unauthenticated: the CLI has no credential yet — that's what
+   * it's obtaining. The human authorizes out-of-band in the
+   * dashboard.
+   */
+  async start() {
+    const path = "/auth/cli/start";
+    return await this.transport.request("POST", path);
+  }
+};
+var EllipsisAuth = class {
+  constructor(transport) {
+    this.transport = transport;
+    this.cli = new EllipsisAuthCli(transport);
   }
-  // One review: scope, findings, parser counters, and the posting outcome.
-  async getReview(reviewId) {
-    return await this.fetchJson(
-      `/reviews/${encodeURIComponent(reviewId)}`
+  transport;
+  cli;
+};
+var EllipsisFiles = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /**
+   * Create File
+   *
+   * Upload a file that outlives the sandbox.
+   *
+   * v1: PNG images only, base64 in the JSON body, 10 MiB cap. The
+   * primary caller is the in-sandbox `agent file upload` CLI (an
+   * agent persisting a screenshot to link on a PR), but all
+   * credential types work. Returns the org-membership-gated
+   * dashboard URL so callers never hard-code URL shapes.
+   */
+  async create(options) {
+    const path = "/files";
+    const body = buildBody({ content_type: options.content_type, data_b64: options.data_b64, filename: options.filename });
+    return await this.transport.request("POST", path, { body });
+  }
+  /**
+   * Delete File
+   *
+   * Delete a file.
+   *
+   * A foreign, missing, or already-deleted id is an
+   * indistinguishable 404, so ids can't be enumerated. Sandbox
+   * tokens get a 403 (a sandbox token sits next to
+   * potentially-untrusted code and must not be able to destroy the
+   * account's files — uploading is fine, destruction is not); API
+   * keys and user tokens may delete.
+   */
+  async delete(file_id) {
+    const path = `/files/${enc(file_id)}`;
+    await this.transport.request("DELETE", path);
+  }
+  /**
+   * Get File
+   *
+   * Return one file's metadata and download link.
+   *
+   * Includes the gated dashboard URL and a short-lived presigned
+   * `download_url`.
+   *
+   * To fetch the bytes locally, call this and then GET download_url
+   * immediately — the JSON API never carries the file. The CLI's
+   * `agent file get` wraps exactly that two-step.
+   */
+  async get(file_id) {
+    const path = `/files/${enc(file_id)}`;
+    return await this.transport.request("GET", path);
+  }
+  /**
+   * List Files
+   *
+   * List uploaded files, newest first.
+   *
+   * Metadata only — download URLs are minted per explicit GET, not
+   * per row. session_id scopes the list to one run's uploads.
+   */
+  async list(options = {}) {
+    const path = "/files";
+    const query = buildQuery({ session_id: options.session_id, limit: options.limit, cursor: options.cursor });
+    const response = await this.transport.request("GET", path, { query });
+    return new Page(
+      response,
+      "files",
+      (cursor) => this.list({ ...options, cursor })
+    );
+  }
+};
+var EllipsisIntegrationsGithub = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /**
+   * List Github Members
+   *
+   * List the GitHub organization roster.
+   *
+   * (Or the account itself for a personal workspace) — the universe of author_id values for
+   * /sessions and /sessions/search.
+   *
+   * Members carry their linked Slack identity when a Slack-GitHub
+   * link exists, and /slack/members carries the reverse link.
+   */
+  async members() {
+    const path = "/integrations/github/members";
+    return await this.transport.request("GET", path);
+  }
+  /**
+   * List Github Repositories
+   *
+   * List GitHub repositories connected to the installation.
+   */
+  async repos() {
+    const path = "/integrations/github/repos";
+    return await this.transport.request("GET", path);
+  }
+};
+var EllipsisIntegrationsLinear = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /**
+   * List Linear Teams
+   *
+   * List the teams of the connected Linear workspace.
+   */
+  async teams() {
+    const path = "/integrations/linear/teams";
+    return await this.transport.request("GET", path);
+  }
+};
+var EllipsisIntegrationsSentry = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /**
+   * List Sentry Organizations
+   *
+   * List the connected Sentry organizations.
+   */
+  async organizations() {
+    const path = "/integrations/sentry/organizations";
+    return await this.transport.request("GET", path);
+  }
+};
+var EllipsisIntegrationsSlack = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /**
+   * List Slack Channels
+   *
+   * List the channels of the connected Slack workspace, fetched
+   * live from the Slack API.
+   */
+  async channels() {
+    const path = "/integrations/slack/channels";
+    return await this.transport.request("GET", path);
+  }
+  /**
+   * List Slack Members
+   *
+   * List the members of the connected Slack workspace, fetched
+   * live from the Slack API.
+   */
+  async members() {
+    const path = "/integrations/slack/members";
+    return await this.transport.request("GET", path);
+  }
+};
+var EllipsisIntegrations = class {
+  constructor(transport) {
+    this.transport = transport;
+    this.github = new EllipsisIntegrationsGithub(transport);
+    this.linear = new EllipsisIntegrationsLinear(transport);
+    this.sentry = new EllipsisIntegrationsSentry(transport);
+    this.slack = new EllipsisIntegrationsSlack(transport);
+  }
+  transport;
+  github;
+  linear;
+  sentry;
+  slack;
+  /**
+   * Get Integrations
+   *
+   * List connected integrations.
+   *
+   * A read-only view, so an agent authoring another agent's
+   * config can learn which repositories, channels, teams, and
+   * organizations it may name before POST /agents/configs.
+   *
+   * Available to all credential types including sandbox tokens: the
+   * responses never include OAuth tokens or any other secret.
+   */
+  async list() {
+    const path = "/integrations";
+    return await this.transport.request("GET", path);
+  }
+};
+var EllipsisMemories = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /**
+   * Create Memory
+   *
+   * Save a memory for future agent sessions.
+   *
+   * Memories are durable lessons shared across the whole
+   * organization — conventions, past decisions, known gotchas that an
+   * agent cannot derive from the repository itself. One concise fact
+   * per memory; the description is what a reader sees in the index.
+   *
+   * Creating never overwrites: a path that already exists is a 409, so
+   * correcting an existing memory is an explicit edit.
+   */
+  async create(options) {
+    const path = "/memories";
+    const body = buildBody({ content: options.content, description: options.description, path: options.path });
+    return await this.transport.request("POST", path, { body });
+  }
+  /**
+   * Delete Memory
+   *
+   * Delete a memory that is no longer true.
+   *
+   * Available to every credential type, agents included — a wrong
+   * memory is worse than a missing one. The deleted content is kept in
+   * the memory's history for forensics, not for an undo API.
+   */
+  async delete(memory_id, options = {}) {
+    const path = `/memories/${enc(memory_id)}`;
+    const query = buildQuery({ if_sha256: options.if_sha256 });
+    await this.transport.request("DELETE", path, { query });
+  }
+  /**
+   * Edit Memory
+   *
+   * Correct an existing memory in place.
+   *
+   * Pass description, content, or both. This never creates a memory (an
+   * unknown id is a 404) and never moves one — the path is immutable, so
+   * relocating a memory is a delete plus a create.
+   *
+   * Pass `if_sha256` (from a previous read) to make a concurrent write
+   * a 409 instead of silently overwriting it.
+   */
+  async edit(memory_id, options = {}) {
+    const path = `/memories/${enc(memory_id)}`;
+    const body = buildBody({ content: options.content, description: options.description, if_sha256: options.if_sha256 });
+    return await this.transport.request("PUT", path, { body });
+  }
+  /**
+   * Get Memory
+   *
+   * Read one memory's full content.
+   *
+   * The id comes from the index returned by listing memories.
+   */
+  async get(memory_id) {
+    const path = `/memories/${enc(memory_id)}`;
+    return await this.transport.request("GET", path);
+  }
+  /**
+   * List Memories
+   *
+   * List the organization's memories as a readable index.
+   *
+   * Returns the memories rendered as a markdown index (one line per
+   * memory, carrying its id, path, and description) plus the same
+   * entries structured, each with every field except `content`. Read
+   * the index, then fetch the ids whose content you want.
+   */
+  async list(options = {}) {
+    const path = "/memories";
+    const query = buildQuery({ prefix: options.prefix });
+    return await this.transport.request("GET", path, { query });
+  }
+};
+var EllipsisModels = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /**
+   * List Supported Models
+   *
+   * List selectable agent models.
+   *
+   * Most expensive first, with the platform default flagged.
+   *
+   * Reads the same registry as the dashboard's rate table, so a
+   * client's model picker can never drift from what's offered.
+   * Behind auth but not account-scoped — the selectable set is
+   * global.
+   */
+  async list() {
+    const path = "/models";
+    return await this.transport.request("GET", path);
+  }
+};
+var EllipsisReviews = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /**
+   * Create Review
+   *
+   * Run a code review on demand.
+   *
+   * Reviews an existing PR or a pushed branch (for a branch, the
+   * platform finds or creates a draft PR for it, since a code
+   * review is structurally about a PR).
+   *
+   * A review is one pipeline run over one commit range, with one
+   * agent session per stage: `review.id` is the run id, and
+   * `stages[].session_id` is where a client streams
+   * (/sessions/{id}/stream on a stage session), since the review
+   * itself is a pipeline rather than one process.
+   */
+  async create(options) {
+    const path = "/reviews";
+    const body = buildBody({ owner: options.owner, post: options.post, pull_request_number: options.pull_request_number, repo: options.repo, scope: options.scope });
+    return await this.transport.request("POST", path, { body });
+  }
+  /**
+   * Get Review
+   *
+   * Return one review with findings and outcome.
+   *
+   * Includes its scope, the per-stage sessions, the parsed findings,
+   * the finding counters, and the posting outcome.
+   *
+   * Findings only exist after a stage session finalizes — a running
+   * review honestly reports [] / null, which is why a client
+   * streams a stage session and then re-fetches the review.
+   */
+  async get(review_id) {
+    const path = `/reviews/${enc(review_id)}`;
+    return await this.transport.request("GET", path);
+  }
+  /**
+   * List Reviews
+   *
+   * List code reviews, newest first.
+   *
+   * `findings` is omitted (counters only).
+   *
+   * Webhook-created reviews appear here too, so this answers "show
+   * me every review on this PR".
+   */
+  async list(options = {}) {
+    const path = "/reviews";
+    const query = buildQuery({ owner: options.owner, repo: options.repo, pull_request_number: options.pull_request_number, status: options.status, limit: options.limit, cursor: options.cursor });
+    const response = await this.transport.request("GET", path, { query });
+    return new Page(
+      response,
+      "reviews",
+      (cursor) => this.list({ ...options, cursor })
     );
   }
-  // Reviews newest first, `findings` omitted (counters only). Includes
-  // webhook-triggered reviews, so this is the full review history of a PR —
-  // the chain the incremental watermark walks.
-  async listReviews(options = {}) {
-    const params = new URLSearchParams();
-    if (options.owner != null) params.set("owner", options.owner);
-    if (options.repo != null) params.set("repo", options.repo);
-    if (options.pullRequestNumber != null)
-      params.set("pull_request_number", String(options.pullRequestNumber));
-    if (options.status != null) params.set("status", options.status);
-    if (options.limit != null) params.set("limit", String(options.limit));
-    const query = params.toString();
-    return await this.fetchJson(
-      "/reviews" + (query ? `?${query}` : "")
+};
+var EllipsisSecrets = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /**
+   * Delete Secret
+   *
+   * Delete a secret by name.
+   *
+   * Refused for sandbox tokens; mutations require an API key or
+   * user token.
+   */
+  async delete(name) {
+    const path = `/secrets/${enc(name)}`;
+    await this.transport.request("DELETE", path);
+  }
+  /**
+   * List Secrets
+   *
+   * List secrets.
+   *
+   * Values are write-only: the response carries only names and
+   * timestamps, never the stored value.
+   */
+  async list() {
+    const path = "/secrets";
+    return await this.transport.request("GET", path);
+  }
+  /**
+   * Put Secrets
+   *
+   * Upsert secrets.
+   *
+   * Returns only the secrets this call wrote, names and timestamps
+   * only — values are write-only. Refused for sandbox tokens (held by
+   * potentially-untrusted in-sandbox code); mutations require an
+   * API key or user token.
+   */
+  async set(options) {
+    const path = "/secrets";
+    const body = buildBody({ secrets: options.secrets });
+    return await this.transport.request("PUT", path, { body });
+  }
+};
+var EllipsisSessions = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /**
+   * Get Agent Session Executions
+   *
+   * Return the session's executions and launch context.
+   *
+   * Most notably system_prompt_append, the text Ellipsis appends to
+   * Claude Code's default system prompt (platform section + response
+   * instructions + the config's own instructions).
+   *
+   * Per execution because each cold wake persists its own launch
+   * config (a config edit or replay override between wakes changes
+   * it).
+   */
+  async executions(session_id) {
+    const path = `/sessions/${enc(session_id)}/executions`;
+    return await this.transport.request("GET", path);
+  }
+  /**
+   * Get Agent Session
+   *
+   * Return one session.
+   *
+   * The public wire shape — the same shape the stream's session
+   * frames carry, with attributed_user and stopped_by_user resolved
+   * at read time.
+   *
+   * The heavy near-static blobs (config snapshot, input/output)
+   * live on the detail endpoints, not here.
+   */
+  async get(session_id) {
+    const path = `/sessions/${enc(session_id)}`;
+    return await this.transport.request("GET", path);
+  }
+  /**
+   * Get Agent Session Ide
+   *
+   * Return the IDE link for the session's sandbox.
+   *
+   * The membership-gated dashboard page, which performs the sandbox
+   * proxy handoff itself.
+   *
+   * No credential is minted here — the URL grants nothing by
+   * possession. 409 when the sandbox isn't running (send the
+   * session a message to wake it first). Backs the `agent session
+   * ide` CLI verb.
+   */
+  async ide(session_id) {
+    const path = `/sessions/${enc(session_id)}/ide`;
+    return await this.transport.request("GET", path);
+  }
+  /**
+   * Ingest Agent Session Transcript
+   *
+   * Append transcript lines to a session's record.
+   *
+   * The in-sandbox tailer for interactive sessions.
+   *
+   * A sandbox token may only push its own session's transcript.
+   * Idempotent by transcript line uuid; tolerant of malformed lines.
+   */
+  async ingestTranscript(session_id, options) {
+    const path = `/sessions/${enc(session_id)}/transcript`;
+    const body = buildBody({ lines: options.lines, offset: options.offset });
+    return await this.transport.request("POST", path, { body });
+  }
+  /**
+   * List Agent Sessions
+   *
+   * List cloud agent sessions, newest first.
+   *
+   * Optionally filtered by config, source, time window, attributed
+   * author, repository, and whether the session is still going.
+   */
+  async list(options = {}) {
+    const path = "/sessions";
+    const query = buildQuery({ config_id: options.config_id, source: options.source, days: options.days, start: options.start, end: options.end, limit: options.limit, cursor: options.cursor, author_id: options.author_id, repo: options.repo, unfinished: options.unfinished });
+    const response = await this.transport.request("GET", path, { query });
+    return new Page(
+      response,
+      "sessions",
+      (cursor) => this.list({ ...options, cursor })
     );
   }
+  /**
+   * Get Agent Session Log
+   *
+   * Download the complete session log.
+   *
+   * The complete, ordered history of the session (agent output, tool calls, thinking,
+   * lifecycle events, sandbox output, message events) as an ordered
+   * manifest of presigned segment URLs.
+   *
+   * Segments are gzip members: download in order and concatenate
+   * for one file. The JSON API never carries the bytes (same
+   * two-step as files). /records is the paged live view of the
+   * same data.
+   */
+  async log(session_id) {
+    const path = `/sessions/${enc(session_id)}/log`;
+    return await this.transport.request("GET", path);
+  }
+  /**
+   * Get Agent Session Port
+   *
+   * Return a preview link for a sandbox port.
+   *
+   * For a dev server running in the session's live sandbox: the
+   * same dashboard page as the IDE, deep-linked to the port.
+   *
+   * Backs `agent session port`.
+   */
+  async port(session_id, port) {
+    const path = `/sessions/${enc(session_id)}/ports/${enc(String(port))}`;
+    return await this.transport.request("GET", path);
+  }
+  /**
+   * Get Agent Session Records
+   *
+   * Return the session's stored transcript records, oldest first.
+   *
+   * Pagination is opt-in (cursor/limit); a bare call returns the
+   * full retained transcript. Available to sandbox tokens too: an
+   * agent answering "did X look into Y?" needs to read the session
+   * it found via /sessions/search, and any org member sees the same
+   * transcript in the dashboard (laptop transcripts are redacted
+   * client-side before they are ever uploaded).
+   */
+  async records(session_id, options = {}) {
+    const path = `/sessions/${enc(session_id)}/records`;
+    const query = buildQuery({ cursor: options.cursor, limit: options.limit });
+    const response = await this.transport.request("GET", path, { query });
+    return new Page(
+      response,
+      "records",
+      (cursor) => this.records(session_id, { ...options, cursor })
+    );
+  }
+  /**
+   * Replay Agent Session
+   *
+   * Replay a session as a new session.
+   *
+   * Reuses the original config snapshot unless config_id is given,
+   * and accepts the same config_override as session start — e.g.
+   * {"claude": {"model": ...}} to replay the same input on a
+   * different model.
+   */
+  async replay(session_id, options = {}) {
+    const path = `/sessions/${enc(session_id)}/replay`;
+    const body = buildBody({ config_id: options.config_id, config_override: options.config_override, config_override_yaml: options.config_override_yaml, prompt: options.prompt });
+    return await this.transport.request("POST", path, { body });
+  }
+  /**
+   * Search Sessions
+   *
+   * Search sessions over steps, recaps, and pull requests.
+   *
+   * Grouped by session, over everything a session left behind: step text, recap text, created
+   * PRs, and recap-embedding similarity.
+   *
+   * This is how an agent answers "did Tony look into X?": resolve
+   * the author via /github/members, search, then read the winning
+   * session via /sessions/{id} (recap) and /sessions/{id}/records
+   * (transcript).
+   */
+  async search(options = {}) {
+    const path = "/sessions/search";
+    const query = buildQuery({ q: options.q, scope: options.scope, source: options.source, author_id: options.author_id, config_id: options.config_id, session_ids: options.session_ids, repo: options.repo, status: options.status, start: options.start, end: options.end, limit: options.limit });
+    return await this.transport.request("GET", path, { query });
+  }
+  /**
+   * Send Agent Session Message
+   *
+   * Send a message to a session.
+   *
+   * 409 for react/cron, non-interactive, and closed sessions.
+   * Returns the created message so the caller can track it by id; a
+   * retried send with the same idempotency_key returns the original
+   * message.
+   */
+  async sendMessage(session_id, options) {
+    const path = `/sessions/${enc(session_id)}/messages`;
+    const body = buildBody({ idempotency_key: options.idempotency_key, message: options.message });
+    return await this.transport.request("POST", path, { body });
+  }
+  /**
+   * Start Agent Session
+   *
+   * Start a cloud agent session.
+   *
+   * Provide at most one of config_id, config, or template_id; with
+   * none, the account's default-config ladder resolves the config.
+   * 400 when idle_start is combined with prompt or handoff, or when
+   * a handoff is combined with any config source or override.
+   */
+  async start(options = {}) {
+    const path = "/sessions";
+    const body = buildBody({ config: options.config, config_id: options.config_id, config_override: options.config_override, config_override_yaml: options.config_override_yaml, force_rebuild: options.force_rebuild, handoff: options.handoff, idle_start: options.idle_start, metadata: options.metadata, prompt: options.prompt, repository: options.repository, template_id: options.template_id });
+    return await this.transport.request("POST", path, { body });
+  }
+  /**
+   * Stop Agent Session
+   *
+   * Stop an in-flight session and return it.
+   *
+   * stopped_by is recorded only when the caller's credential maps
+   * to a GitHub account.
+   */
+  async stop(session_id) {
+    const path = `/sessions/${enc(session_id)}/stop`;
+    return await this.transport.request("POST", path);
+  }
+  /**
+   * Sync Agent Session
+   *
+   * Sync a local Claude Code session to Ellipsis.
+   *
+   * Requires a user token (device-flow `agent login`): the user is
+   * part of the sync's idempotency key, so API keys and sandbox
+   * tokens are rejected with a 403 rather than silently attributed.
+   */
+  async sync(options) {
+    const path = "/sessions/sync";
+    const body = buildBody({ cc_session_id: options.cc_session_id, cwd: options.cwd, git_branch: options.git_branch, reason: options.reason, repo: options.repo, transcript_gzip_b64: options.transcript_gzip_b64 });
+    return await this.transport.request("POST", path, { body });
+  }
+  // ---- lifecycle sugar (hand-written layer over the generated core) ----
+  /** Start a session and return a handle over it. */
+  async run(options) {
+    const response = await this.start(options);
+    return new SessionHandle(this, response.session);
+  }
+  /** A handle over an existing session. */
+  async handle(sessionId) {
+    const response = await this.get(sessionId);
+    return new SessionHandle(this, response.session);
+  }
+};
+var Ellipsis = class {
+  transport;
+  agents;
+  alerts;
+  analytics;
+  auth;
+  files;
+  integrations;
+  memories;
+  models;
+  reviews;
+  secrets;
+  sessions;
+  constructor(options) {
+    this.transport = new Transport(options);
+    this.agents = new EllipsisAgents(this.transport);
+    this.alerts = new EllipsisAlerts(this.transport);
+    this.analytics = new EllipsisAnalytics(this.transport);
+    this.auth = new EllipsisAuth(this.transport);
+    this.files = new EllipsisFiles(this.transport);
+    this.integrations = new EllipsisIntegrations(this.transport);
+    this.memories = new EllipsisMemories(this.transport);
+    this.models = new EllipsisModels(this.transport);
+    this.reviews = new EllipsisReviews(this.transport);
+    this.secrets = new EllipsisSecrets(this.transport);
+    this.sessions = new EllipsisSessions(this.transport);
+  }
+  /**
+   * Get Budget
+   *
+   * Return the caller's current budget summary.
+   */
+  async budget() {
+    const path = "/budget";
+    return await this.transport.request("GET", path);
+  }
+  /**
+   * Whoami
+   *
+   * Return the identity behind the caller's credential.
+   */
+  async me() {
+    const path = "/me";
+    return await this.transport.request("GET", path);
+  }
+  /**
+   * Get Usage Endpoint
+   *
+   * Return the caller's usage dashboard data.
+   */
+  async usage() {
+    const path = "/usage";
+    return await this.transport.request("GET", path);
+  }
 };
 export {
-  EllipsisClient
+  APIError,
+  AuthenticationError,
+  ConflictError,
+  DEFAULT_BASE_URL,
+  Ellipsis,
+  EllipsisError,
+  ForbiddenError,
+  NotFoundError,
+  Page,
+  RateLimitError,
+  ServerError,
+  SessionHandle,
+  TERMINAL_STATUSES,
+  Transport,
+  TransportError,
+  UnprocessableError,
+  isSettled
 };