@ellipsis-dev/sdk 0.8.0 → 0.9.0

package/dist/index.d.ts

@@ -1,32 +1,937 @@
-import { A as AgentSessionWire, L as ListSessionRecordsResponse, a as ListSessionTurnsResponse, b as ListSessionExecutionsResponse, S as SessionMessageWire, C as CreateReviewRequest, R as Review, c as ListReviewsResponse } from './types-rf-NzI8E.js';
-export { d as AgentSessionExitStatus, e as AgentSessionPr, f as AgentSessionSource, g as AgentSessionStatus, h as AgentTurn, i as AgentTurnStatus, j as AttributionType, B as BudgetSource, D as DefaultResolution, k as DeltaFrame, l as DoneFrame, E as ErrorFrame, F as Finding, G as GithubAccountSnippet, m as GithubAccountType, H as Harness, n as HeartbeatFrame, P as ParentKind, o as PromptBlockedReason, p as RecordsAppendFrame, q as ResolvedReviewScope, r as ReviewConfiguration, s as ReviewCounters, t as ReviewFinding, u as ReviewRequester, v as ReviewScope, w as ReviewScopeKind, x as ReviewStage, y as ReviewedCommit, z as SendSessionMessageRequest, I as SessionExecutionWire, J as SessionFrame, K as SessionLiveness, M as SessionMessageStatus, N as SessionPrompting, O as SessionRecordWire, Q as SessionState, T as SessionStreamFrame, U as SessionSurface, V as SnapshotFrame, W as StreamFrame, X as TokensInfo, Y as components, Z as paths } from './types-rf-NzI8E.js';
+import { c as components } from './types-CStmnKVu.js';
+export { A as AttributionType, B as BudgetSource, C as CreateReviewRequest, D as DefaultResolution, a as DeltaFrame, b as DoneFrame, E as ErrorFrame, F as Finding, G as GithubAccountSnippet, d as GithubAccountType, H as Harness, e as HeartbeatFrame, P as ParentKind, f as PromptBlockedReason, R as RecordsAppendFrame, g as ResolvedReviewScope, h as Review, i as ReviewConfiguration, j as ReviewCounters, k as ReviewFinding, l as ReviewRequester, m as ReviewScope, n as ReviewScopeKind, o as ReviewStage, p as ReviewedCommit, q as ReviewsListResponse, S as SendSessionMessageRequest, r as Session, s as SessionExecution, t as SessionExecutionsListResponse, u as SessionExitStatus, v as SessionFrame, w as SessionLiveness, x as SessionMessage, y as SessionMessageResponse, z as SessionMessageStatus, I as SessionPr, J as SessionPrompting, K as SessionRecord, L as SessionRecordsListResponse, M as SessionResponse, N as SessionSource, O as SessionState, Q as SessionStatus, T as SessionStreamFrame, U as SessionSurface, V as SessionsListResponse, W as SnapshotFrame, X as StreamFrame, Y as TokensInfo, Z as paths } from './types-CStmnKVu.js';
 
-type FetchJson = (path: string, init?: {
-    method?: string;
-    body?: unknown;
-}) => Promise<unknown>;
-declare class EllipsisClient {
-    private readonly fetchJson;
-    constructor(fetchJson: FetchJson);
-    getSession(sessionId: string): Promise<AgentSessionWire>;
-    getSessionRecords(sessionId: string, options?: {
-        afterSeq?: number;
+interface CursorResponse {
+    has_more: boolean;
+    next_cursor?: string | null;
+}
+declare class Page<ItemT, ResponseT extends CursorResponse> implements AsyncIterable<ItemT> {
+    readonly response: ResponseT;
+    private readonly itemsAttr;
+    private readonly fetchNext;
+    constructor(response: ResponseT, itemsAttr: keyof ResponseT, fetchNext: (cursor: string) => Promise<Page<ItemT, ResponseT>>);
+    get items(): ItemT[];
+    get hasMore(): boolean;
+    get nextCursor(): string | null;
+    [Symbol.asyncIterator](): AsyncIterator<ItemT>;
+}
+
+type S$1 = components['schemas'];
+declare const TERMINAL_STATUSES: ReadonlySet<string>;
+interface SessionsApi {
+    get(sessionId: string): Promise<S$1['SessionResponse']>;
+    stop(sessionId: string): Promise<S$1['SessionResponse']>;
+    sendMessage(sessionId: string, options: {
+        message: string;
+        idempotency_key?: string | null;
+    }): Promise<S$1['SessionMessageResponse']>;
+    records(sessionId: string, options?: {
+        cursor?: string;
         limit?: number;
-    }): Promise<ListSessionRecordsResponse>;
-    getSessionTurns(sessionId: string): Promise<ListSessionTurnsResponse>;
-    getSessionExecutions(sessionId: string): Promise<ListSessionExecutionsResponse>;
-    sendSessionMessage(sessionId: string, message: string, options?: {
+    }): Promise<unknown>;
+}
+declare function isSettled(session: S$1['Session']): boolean;
+declare class SessionHandle {
+    private readonly sessions;
+    readonly id: string;
+    session: S$1['Session'];
+    constructor(sessions: SessionsApi, session: S$1['Session']);
+    refresh(): Promise<S$1['Session']>;
+    wait(options?: {
+        timeoutMs?: number;
+        pollIntervalMs?: number;
+    }): Promise<S$1['Session']>;
+    send(message: string, options?: {
         idempotencyKey?: string;
-    }): Promise<SessionMessageWire>;
-    createReview(request: CreateReviewRequest): Promise<Review>;
-    getReview(reviewId: string): Promise<Review>;
-    listReviews(options?: {
-        owner?: string;
-        repo?: string;
-        pullRequestNumber?: number;
-        status?: string;
+    }): Promise<S$1['SessionMessage']>;
+    stop(): Promise<S$1['Session']>;
+}
+
+declare const DEFAULT_BASE_URL = "https://api.ellipsis.dev";
+interface TransportOptions {
+    apiKey: string;
+    baseUrl?: string;
+    timeoutMs?: number;
+    maxRetries?: number;
+    fetch?: typeof globalThis.fetch;
+}
+declare class Transport {
+    private readonly baseUrl;
+    private readonly headers;
+    private readonly timeoutMs;
+    private readonly maxRetries;
+    private readonly fetchImpl;
+    constructor(options: TransportOptions);
+    request<T>(method: string, path: string, options?: {
+        query?: string;
+        body?: unknown;
+    }): Promise<T>;
+}
+
+type S = components['schemas'];
+declare class EllipsisAgentsConfigs {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * Create Agent Config
+     *
+     * Create an agent config via pull request.
+     *
+     * The PR adds the config file to agents/ on the target
+     * repository; the agent goes live when it merges.
+     *
+     * Accepts an inline config or a gallery template slug. 409 when
+     * another live agent already holds the name.
+     */
+    create(options: {
+        config?: S['AgentConfig'] | null;
+        path?: string | null;
+        repository: string;
+        template_id?: string | null;
+    }): Promise<S['CreateAgentConfigResponse']>;
+    /**
+     * Get Agent Config
+     *
+     * Return one saved agent config, by id or by the agent's name.
+     */
+    get(config_id: string): Promise<S['AgentConfigResponse']>;
+    /**
+     * List Agent Configs
+     *
+     * List saved agent configs.
+     */
+    list(): Promise<S['AgentConfigsListResponse']>;
+}
+declare class EllipsisAgentsDefaults {
+    private readonly transport;
+    constructor(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.
+     */
+    delete(options?: {
+        repository?: string | null;
+    }): Promise<void>;
+    /**
+     * 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.
+     */
+    list(): Promise<S['AgentDefaultsListResponse']>;
+    /**
+     * Put Agent Default
+     *
+     * Set a default agent config.
+     *
+     * Addressed by rung: the account rung (repository omitted) or a
+     * repository rung ("owner/name"); the config by id or by the
+     * agent's 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.
+     */
+    set(options: {
+        config_id: string;
+        repository?: string | null;
+    }): Promise<S['AgentDefaultResponse']>;
+}
+declare class EllipsisAgentsTemplates {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * Get Agent Template
+     *
+     * Return one built-in agent template by slug.
+     */
+    get(template_id: string): Promise<S['AgentTemplate']>;
+    /**
+     * 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.
+     */
+    list(): Promise<S['AgentTemplatesListResponse']>;
+}
+declare class EllipsisAgents {
+    private readonly transport;
+    readonly configs: EllipsisAgentsConfigs;
+    readonly defaults: EllipsisAgentsDefaults;
+    readonly templates: EllipsisAgentsTemplates;
+    constructor(transport: Transport);
+}
+declare class EllipsisAlerts {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * Dismiss Alert
+     *
+     * Dismiss an open alert and return it.
+     *
+     * 409 when the alert is not open; 404 when it doesn't exist.
+     */
+    dismiss(alert_id: string): Promise<S['AlertResponse']>;
+    /**
+     * Get Alert
+     *
+     * Return one alert by id.
+     *
+     * 404 if it doesn't exist or belongs to another organization.
+     */
+    get(alert_id: string): Promise<S['AlertResponse']>;
+    /**
+     * 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.
+     */
+    list(options?: {
+        status?: S['AlertStatus'] | null;
+        source?: S['AlertSource'] | null;
         limit?: number;
-    }): Promise<ListReviewsResponse>;
+        cursor?: string | null;
+    }): Promise<Page<S['Alert'], S['AlertsListResponse']>>;
+}
+declare class EllipsisAnalytics {
+    private readonly transport;
+    constructor(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.
+     */
+    metrics(options?: {
+        days?: number | null;
+        start?: string | null;
+        end?: string | null;
+        repo?: (string)[] | null;
+        author?: (string)[] | null;
+        account_type?: string;
+        status?: (string)[] | null;
+    }): Promise<S['GetAnalyticsMetricsResponse']>;
+    /**
+     * Get Analytics Pull Requests
+     *
+     * Return pull-request analytics.
+     *
+     * Windowing: pass explicit start/end, or days (default: the last
+     * 30 days).
+     */
+    pullRequests(options?: {
+        days?: number | null;
+        start?: string | null;
+        end?: string | null;
+        account_type?: (string)[] | null;
+        repository_id?: (number)[] | null;
+        author_id?: (number)[] | null;
+        status?: (string)[] | null;
+    }): Promise<S['GetAnalyticsPullRequestsResponse']>;
+    /**
+     * 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).
+     */
+    reviews(options?: {
+        days?: number | null;
+        start?: string | null;
+        end?: string | null;
+        repo?: (string)[] | null;
+        author?: (string)[] | null;
+        account_type?: string;
+        review_state?: (string)[] | null;
+    }): Promise<S['GetAnalyticsReviewsResponse']>;
+}
+declare class EllipsisAuthCli {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * Cli Auth Poll
+     *
+     * Poll a device-code auth flow for its token.
+     *
+     * Unauthenticated; the device code identifies the flow.
+     */
+    poll(options: {
+        device_code: string;
+    }): Promise<S['PollCliAuthResponse']>;
+    /**
+     * 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.
+     */
+    start(): Promise<S['StartCliAuthResponse']>;
+}
+declare class EllipsisAuth {
+    private readonly transport;
+    readonly cli: EllipsisAuthCli;
+    constructor(transport: Transport);
+}
+declare class EllipsisFiles {
+    private readonly transport;
+    constructor(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.
+     */
+    create(options: {
+        content_type: string;
+        data_b64: string;
+        filename: string;
+    }): Promise<S['CreateFileResponse']>;
+    /**
+     * 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.
+     */
+    delete(file_id: string): Promise<void>;
+    /**
+     * 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.
+     */
+    get(file_id: string): Promise<S['GetFileResponse']>;
+    /**
+     * 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.
+     */
+    list(options?: {
+        session_id?: string | null;
+        limit?: number;
+        cursor?: string | null;
+    }): Promise<Page<S['File'], S['FilesListResponse']>>;
+}
+declare class EllipsisIntegrationsGithub {
+    private readonly transport;
+    constructor(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.
+     */
+    members(): Promise<S['GithubMembersListResponse']>;
+    /**
+     * List Github Repositories
+     *
+     * List GitHub repositories connected to the installation.
+     */
+    repos(): Promise<S['GithubRepositoriesListResponse']>;
+}
+declare class EllipsisIntegrationsLinear {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * List Linear Teams
+     *
+     * List the teams of the connected Linear workspace.
+     */
+    teams(): Promise<S['LinearTeamsListResponse']>;
+}
+declare class EllipsisIntegrationsSentry {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * List Sentry Organizations
+     *
+     * List the connected Sentry organizations.
+     */
+    organizations(): Promise<S['SentryOrganizationsListResponse']>;
+}
+declare class EllipsisIntegrationsSlack {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * List Slack Channels
+     *
+     * List the channels of the connected Slack workspace, fetched
+     * live from the Slack API.
+     */
+    channels(): Promise<S['SlackChannelsListResponse']>;
+    /**
+     * List Slack Members
+     *
+     * List the members of the connected Slack workspace, fetched
+     * live from the Slack API.
+     */
+    members(): Promise<S['SlackMembersListResponse']>;
+}
+declare class EllipsisIntegrations {
+    private readonly transport;
+    readonly github: EllipsisIntegrationsGithub;
+    readonly linear: EllipsisIntegrationsLinear;
+    readonly sentry: EllipsisIntegrationsSentry;
+    readonly slack: EllipsisIntegrationsSlack;
+    constructor(transport: Transport);
+    /**
+     * 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.
+     */
+    list(): Promise<S['GetIntegrationsResponse']>;
+}
+declare class EllipsisMemories {
+    private readonly transport;
+    constructor(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.
+     */
+    create(options: {
+        content: string;
+        description: string;
+        path: string;
+    }): Promise<S['MemoryResponse']>;
+    /**
+     * 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.
+     */
+    delete(memory_id: string, options?: {
+        if_sha256?: string | null;
+    }): Promise<void>;
+    /**
+     * 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.
+     */
+    edit(memory_id: string, options?: {
+        content?: string | null;
+        description?: string | null;
+        if_sha256?: string | null;
+    }): Promise<S['MemoryResponse']>;
+    /**
+     * Get Memory
+     *
+     * Read one memory's full content.
+     *
+     * The id comes from the index returned by listing memories.
+     */
+    get(memory_id: string): Promise<S['MemoryResponse']>;
+    /**
+     * 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.
+     */
+    list(options?: {
+        prefix?: string | null;
+    }): Promise<S['MemoriesListResponse']>;
+}
+declare class EllipsisModels {
+    private readonly transport;
+    constructor(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.
+     */
+    list(): Promise<S['ModelsListResponse']>;
+}
+declare class EllipsisReviews {
+    private readonly transport;
+    constructor(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.
+     */
+    create(options: {
+        owner: string;
+        post?: boolean;
+        pull_request_number: number;
+        repo: string;
+        scope?: S['ReviewScope'];
+    }): Promise<S['Review']>;
+    /**
+     * 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.
+     */
+    get(review_id: string): Promise<S['Review']>;
+    /**
+     * 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".
+     */
+    list(options?: {
+        owner?: string | null;
+        repo?: string | null;
+        pull_request_number?: number | null;
+        status?: S['CodeReviewRunStatus'] | null;
+        limit?: number;
+        cursor?: string | null;
+    }): Promise<Page<S['Review'], S['ReviewsListResponse']>>;
+}
+declare class EllipsisSecrets {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * Delete Secret
+     *
+     * Delete a secret by name.
+     *
+     * Refused for sandbox tokens; mutations require an API key or
+     * user token.
+     */
+    delete(name: string): Promise<void>;
+    /**
+     * List Secrets
+     *
+     * List secrets.
+     *
+     * Values are write-only: the response carries only names and
+     * timestamps, never the stored value.
+     */
+    list(): Promise<S['SecretsListResponse']>;
+    /**
+     * 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.
+     */
+    set(options: {
+        secrets: (S['SecretInput'])[];
+    }): Promise<S['SecretsListResponse']>;
+}
+declare class EllipsisSessions {
+    private readonly transport;
+    constructor(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).
+     */
+    executions(session_id: string): Promise<S['SessionExecutionsListResponse']>;
+    /**
+     * Export Agent Session
+     *
+     * Export the complete session history.
+     *
+     * 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.
+     */
+    export(session_id: string): Promise<S['GetSessionLogResponse']>;
+    /**
+     * 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.
+     */
+    get(session_id: string): Promise<S['SessionResponse']>;
+    /**
+     * 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.
+     */
+    ide(session_id: string): Promise<S['GetSessionIdeResponse']>;
+    /**
+     * 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.
+     */
+    ingestTranscript(session_id: string, options: {
+        lines: (string)[];
+        offset?: number;
+    }): Promise<S['TranscriptIngestResult']>;
+    /**
+     * List Agent Sessions
+     *
+     * List cloud agent sessions, newest first.
+     *
+     * Optionally filtered by config (id or `ellipsis.name`), source, time
+     * window, attributed author, repository, and whether the session is
+     * still going.
+     */
+    list(options?: {
+        config_id?: string | null;
+        source?: (S['SessionSource'])[] | null;
+        days?: number | null;
+        start?: string | null;
+        end?: string | null;
+        limit?: number;
+        cursor?: string | null;
+        author_id?: number | null;
+        repo?: string | null;
+        unfinished?: boolean;
+    }): Promise<Page<S['Session'], S['SessionsListResponse']>>;
+    /**
+     * Get Agent Session Output
+     *
+     * Return the session's typed output.
+     *
+     * The payload the agent submitted through its config-declared
+     * output.json_schema, as the raw JSON body with no envelope. 404
+     * while the session is still running (poll GET /sessions/{id}),
+     * when the agent declares no output block, or when no execution
+     * produced output.
+     */
+    output(session_id: string): Promise<void>;
+    /**
+     * 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`.
+     */
+    port(session_id: string, port: number): Promise<S['GetSessionPortResponse']>;
+    /**
+     * 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).
+     */
+    records(session_id: string, options?: {
+        cursor?: string | null;
+        limit?: number | null;
+    }): Promise<Page<S['SessionRecord'], S['SessionRecordsListResponse']>>;
+    /**
+     * 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.
+     */
+    replay(session_id: string, options?: {
+        config_id?: string | null;
+        config_override?: Record<string, unknown> | null;
+        config_override_yaml?: string | null;
+        prompt?: string | null;
+    }): Promise<S['SessionResponse']>;
+    /**
+     * 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).
+     */
+    search(options?: {
+        q?: string;
+        scope?: S['SessionSearchScope'];
+        source?: (S['SessionSource'])[] | null;
+        author_id?: (number)[] | null;
+        config_id?: (string)[] | null;
+        session_ids?: (string)[] | null;
+        repo?: string | null;
+        status?: (S['SessionStatus'])[] | null;
+        start?: string | null;
+        end?: string | null;
+        limit?: number;
+    }): Promise<S['SessionSearchResponse']>;
+    /**
+     * 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.
+     */
+    sendMessage(session_id: string, options: {
+        idempotency_key?: string | null;
+        message: string;
+    }): Promise<S['SessionMessageResponse']>;
+    /**
+     * Start Agent Session
+     *
+     * Start a cloud agent session.
+     *
+     * Provide at most one of config_id (an id or an agent name),
+     * config, or
+     * template_id; with none, the account's default-config ladder
+     * resolves the config. 400 when idle_start is combined with
+     * prompt, input, or handoff, or when a handoff is combined with
+     * any config source or override. 422 when the agent declares an
+     * input schema and the request's input is absent or invalid.
+     */
+    start(options?: {
+        config?: S['AgentConfig'] | null;
+        config_id?: string | null;
+        config_override?: Record<string, unknown> | null;
+        config_override_yaml?: string | null;
+        force_rebuild?: boolean;
+        handoff?: S['HandoffAgentSessionParams'] | null;
+        idle_start?: boolean;
+        input?: Record<string, unknown> | null;
+        metadata?: Record<string, string>;
+        prompt?: string | null;
+        repository?: string | null;
+        template_id?: string | null;
+    }): Promise<S['StartAgentSessionResponse']>;
+    /**
+     * 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.
+     */
+    stop(session_id: string): Promise<S['SessionResponse']>;
+    /**
+     * 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.
+     */
+    sync(options: {
+        cc_session_id: string;
+        cwd?: string | null;
+        git_branch?: string | null;
+        reason?: "stop" | "session_end";
+        repo?: string | null;
+        transcript_gzip_b64: string;
+    }): Promise<S['SyncAgentSessionResponse']>;
+    /** Start a session and return a handle over it. */
+    run(options: Parameters<EllipsisSessions['start']>[0]): Promise<SessionHandle>;
+    /** A handle over an existing session. */
+    handle(sessionId: string): Promise<SessionHandle>;
+}
+declare class Ellipsis {
+    private readonly transport;
+    readonly agents: EllipsisAgents;
+    readonly alerts: EllipsisAlerts;
+    readonly analytics: EllipsisAnalytics;
+    readonly auth: EllipsisAuth;
+    readonly files: EllipsisFiles;
+    readonly integrations: EllipsisIntegrations;
+    readonly memories: EllipsisMemories;
+    readonly models: EllipsisModels;
+    readonly reviews: EllipsisReviews;
+    readonly secrets: EllipsisSecrets;
+    readonly sessions: EllipsisSessions;
+    constructor(options: TransportOptions);
+    /**
+     * Get Budget
+     *
+     * Return the caller's current budget summary.
+     */
+    budget(): Promise<S['BudgetSummary']>;
+    /**
+     * Whoami
+     *
+     * Return the identity behind the caller's credential.
+     */
+    me(): Promise<S['WhoAmIResponse']>;
+    /**
+     * Get Usage Endpoint
+     *
+     * Return the caller's usage dashboard data.
+     */
+    usage(): Promise<S['GetUsageDashboardResponse']>;
+}
+
+declare class EllipsisError extends Error {
+}
+declare class TransportError extends EllipsisError {
+}
+declare class APIError extends EllipsisError {
+    readonly status: number;
+    readonly code: string | null;
+    readonly requestId: string | null;
+    readonly body: unknown;
+    constructor(args: {
+        status: number;
+        code: string | null;
+        message: string;
+        requestId: string | null;
+        body?: unknown;
+    });
+}
+declare class AuthenticationError extends APIError {
+}
+declare class ForbiddenError extends APIError {
+}
+declare class NotFoundError extends APIError {
+}
+declare class ConflictError extends APIError {
+}
+declare class UnprocessableError extends APIError {
+}
+declare class RateLimitError extends APIError {
+}
+declare class ServerError extends APIError {
 }
 
-export { AgentSessionWire, CreateReviewRequest, EllipsisClient, type FetchJson, ListReviewsResponse, ListSessionExecutionsResponse, ListSessionRecordsResponse, ListSessionTurnsResponse, Review, SessionMessageWire };
+export { APIError, AuthenticationError, ConflictError, DEFAULT_BASE_URL, Ellipsis, EllipsisError, ForbiddenError, NotFoundError, Page, RateLimitError, ServerError, SessionHandle, TERMINAL_STATUSES, Transport, TransportError, type TransportOptions, UnprocessableError, components, isSettled };