@ellipsis-dev/sdk 0.25.0 → 0.28.0

package/dist/index.d.ts

@@ -1,5 +1,1063 @@
-import { c as components } from './types-DJzmFABi.js';
-export { A as AttributionType, B as BudgetSource, C as ClaudeSessionRecord, a as CodexEvent, b as CodexItem, d as CodexSessionRecord, e as CreateReviewRequest, D as DeltaFrame, f as DoneFrame, E as ErrorFrame, F as Finding, G as GithubAccountSnippet, g as GithubAccountType, H as Harness, h as HeartbeatFrame, L as LifecycleSessionRecord, P as ParentKind, i as PromptBlockedReason, R as RecordsAppendFrame, j as ResolvedReviewScope, k as Review, l as ReviewConfiguration, m as ReviewCounters, n as ReviewFinding, o as ReviewRequester, p as ReviewScope, q as ReviewScopeKind, r as ReviewStage, s as ReviewedCommit, t as ReviewsListResponse, S as SdkAssistantRecord, u as SdkContentBlock, v as SdkRateLimitRecord, w as SdkRecord, x as SdkResultRecord, y as SdkSystemRecord, z as SdkUserRecord, I as SendSessionMessageRequest, J as Session, K as SessionExitStatus, M as SessionFrame, N as SessionGit, O as SessionLiveness, Q as SessionMessage, T as SessionMessageResponse, U as SessionMessageStatus, V as SessionPrompting, W as SessionRecord, X as SessionRecordsListResponse, Y as SessionResponse, Z as SessionSource, _ as SessionState, $ as SessionStatus, a0 as SessionStreamFrame, a1 as SessionSurface, a2 as SessionsListResponse, a3 as SnapshotFrame, a4 as StreamFrame, a5 as TokensInfo, a6 as paths } from './types-DJzmFABi.js';
+import { c as components } from './types-B-jIFh4_.js';
+export { A as AttributionType, a as AutomationConfig, b as AutomationIdentity, B as BudgetConfig, d as BudgetSource, C as ClaudeAssistantEvent, e as ClaudeAssistantMessage, f as ClaudeConfig, g as ClaudeConversationResetEvent, h as ClaudeNativeEvent, i as ClaudeNativeSessionRecord, j as ClaudeNativeUsage, k as ClaudeRateLimitEvent, l as ClaudeRateLimitInfo, m as ClaudeResultEvent, n as ClaudeSessionRecord, o as ClaudeSystemEvent, p as ClaudeUserEvent, q as ClaudeUserMessage, r as CodexAgentMessage, s as CodexAgentMessageItem, t as CodexAppServerError, u as CodexAppServerEvent, v as CodexAppServerItem, w as CodexAppServerNotification, x as CodexAppServerSessionRecord, y as CodexCommandExecution, z as CodexCommandExecutionItem, D as CodexConfig, E as CodexContextCompaction, F as CodexEffortLevel, G as CodexErrorEvent, H as CodexErrorItem, I as CodexErrorParams, J as CodexEvent, K as CodexFileChange, L as CodexFileChangeItem, M as CodexFileUpdate, N as CodexItem, O as CodexItemCompleted, P as CodexItemCompletedEvent, Q as CodexItemParams, R as CodexItemStarted, S as CodexItemStartedEvent, T as CodexItemUpdatedEvent, U as CodexLocalImageInput, V as CodexMcpToolCall, W as CodexMcpToolCallAppContext, X as CodexMcpToolCallError, Y as CodexMcpToolCallItem, Z as CodexMcpToolCallResult, _ as CodexPlan, $ as CodexReasoning, a0 as CodexReasoningItem, a1 as CodexSessionRecord, a2 as CodexTextInput, a3 as CodexThread, a4 as CodexThreadStarted, a5 as CodexThreadStartedEvent, a6 as CodexThreadStartedParams, a7 as CodexThreadTokenUsage, a8 as CodexTodoListItem, a9 as CodexTokenUsageBreakdown, aa as CodexTokenUsageParams, ab as CodexTokenUsageUpdated, ac as CodexTurn, ad as CodexTurnCompleted, ae as CodexTurnCompletedEvent, af as CodexTurnError, ag as CodexTurnFailedEvent, ah as CodexTurnParams, ai as CodexTurnStarted, aj as CodexTurnStartedEvent, ak as CodexUsage, al as CodexUserInput, am as CodexUserMessage, an as CodexWebSearch, ao as CodexWebSearchItem, ap as ComputeConfig, aq as ConfigMetadata, ar as CreateReviewRequest, as as CronTrigger, at as DeltaFrame, au as DoneFrame, av as Duration, aw as EffortLevel, ax as EllipsisGrant, ay as EllipsisPermissions, az as EnvironmentConfig, aA as EnvironmentHooks, aB as EnvironmentImage, aC as EnvironmentSource, aD as EnvironmentVariable, aE as ErrorFrame, aF as ExecutionResult, aG as Finding, aH as GithubAccountFilter, aI as GithubAccountSelector, aJ as GithubAccountSnippet, aK as GithubAccountType, aL as GithubPermissions, aM as Harness, aN as HeartbeatFrame, aO as InputContract, aP as IssueAction, aQ as LegacyAssistantPayload, aR as LegacyNativeUsage, aS as LegacyResultPayload, aT as Level, aU as LifecycleSessionRecord, aV as LinearIssueAction, aW as McpRemoteServer, aX as McpServerRef, aY as McpStdioServer, aZ as MemorySize, a_ as MessageDeliveredPayload, a$ as MessageDeliveredRecord, b0 as MessageReceivedPayload, b1 as MessageReceivedRecord, b2 as MessageRequeuedPayload, b3 as MessageRequeuedRecord, b4 as OutboxCollectedPayload, b5 as OutboxCollectedRecord, b6 as OutputConfig, b7 as ParentKind, b8 as PermissionsConfig, b9 as PlatformSessionRecord, ba as PromptBlockedReason, bb as PullRequestAction, bc as ReactIssue, bd as ReactLinearIssue, be as ReactPullRequest, bf as ReactPush, bg as ReactSentry, bh as ReactSlackChannel, bi as ReactTrigger, bj as RecordsAppendFrame, bk as RepositoryFilter, bl as RepositoryRef, bm as ResolvedReviewScope, bn as Review, bo as ReviewConfiguration, bp as ReviewCounters, bq as ReviewFinding, br as ReviewRequester, bs as ReviewScope, bt as ReviewScopeKind, bu as ReviewStage, bv as ReviewedCommit, bw as ReviewsListResponse, bx as RunStatus, by as SandboxOutputPayload, bz as SandboxOutputRecord, bA as SandboxPhasePayload, bB as SandboxPhaseRecord, bC as SandboxReadyPayload, bD as SandboxReadyRecord, bE as SandboxStartingPayload, bF as SandboxStartingRecord, bG as SdkAssistantRecord, bH as SdkCacheCreation, bI as SdkContentBlock, bJ as SdkRateLimitRecord, bK as SdkRecord, bL as SdkResultRecord, bM as SdkServerToolResultBlock, bN as SdkServerToolUseBlock, bO as SdkSystemRecord, bP as SdkTextBlock, bQ as SdkThinkingBlock, bR as SdkToolResultBlock, bS as SdkToolUseBlock, bT as SdkUserRecord, bU as SendSessionMessageRequest, bV as SentryAction, bW as Session, bX as Session1, bY as SessionAttribution, bZ as SessionAutomation, b_ as SessionBudget, b$ as SessionCancelledPayload, c0 as SessionCancelledRecord, c1 as SessionClosedPayload, c2 as SessionClosedRecord, c3 as SessionConfig, c4 as SessionConfig1, c5 as SessionCost, c6 as SessionEnvironment, c7 as SessionExecution, c8 as SessionExecutionsListResponse, c9 as SessionExitStatus, ca as SessionFrame, cb as SessionGit, cc as SessionGitCommit, cd as SessionGitFile, ce as SessionGitPr, cf as SessionGitRepo, cg as SessionIdlePayload, ch as SessionIdleRecord, ci as SessionLiveness, cj as SessionMessage, ck as SessionMessageImage, cl as SessionMessageResponse, cm as SessionMessageStatus, cn as SessionParent, co as SessionPrompting, cp as SessionRecord, cq as SessionRecordsListResponse, cr as SessionResponse, cs as SessionResumedPayload, ct as SessionResumedRecord, cu as SessionRetryingPayload, cv as SessionRetryingRecord, cw as SessionScheduledPayload, cx as SessionScheduledRecord, cy as SessionSource, cz as SessionStartingPayload, cA as SessionStartingRecord, cB as SessionState, cC as SessionStatus, cD as SessionStopped, cE as SessionStreamFrame, cF as SessionSummary, cG as SessionSurface, cH as SessionTokens, cI as SessionTrigger, cJ as SessionTriggerActor, cK as SessionsListResponse, cL as SettingsRef, cM as SkillRef, cN as SnapshotFrame, cO as StreamFrame, cP as SystemFileRef, cQ as TokensInfo, cR as TurnCompletedPayload, cS as TurnCompletedRecord, cT as TurnFailedPayload, cU as TurnFailedRecord, cV as TurnStartedPayload, cW as TurnStartedRecord, cX as UnknownSessionRecord, cY as paths } from './types-B-jIFh4_.js';
+
+/**
+ * Frames on /v1/sessions/stream, /v1/automations/stream and /v1/sandboxes/{id}/stream. Ignore unknown frame types.
+ */
+type CollectionStreamFrame = SessionListStreamMessage | AutomationListStreamMessage | CollectionStreamHeartbeat | SandboxSnapshotFrame | SandboxUpdateFrame;
+type AttributionType = 'github_user' | 'linear_user' | 'slack_user' | 'api_key';
+type GithubAccountType = 'User' | 'Organization' | 'Bot' | 'Mannequin';
+type EffortLevel = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+type CodexEffortLevel = 'none' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+/**
+ * What may be done to a resource. Strictly ordered: a grant at one level
+ * includes every level below it (write-only would be a phantom capability —
+ * no real client can create what it cannot read back).
+ */
+type Level = 'read' | 'write' | 'delete';
+type GithubAccountFilter = {
+    exclude?: string[];
+    include?: string[] | boolean;
+} | boolean | string[];
+type IssueAction = 'opened' | 'closed' | 'commented';
+type RepositoryFilter = {
+    exclude?: string[];
+    include?: string[];
+} | string[];
+type LinearIssueAction = 'opened';
+type PullRequestAction = 'opened' | 'pushed' | 'merged' | 'closed' | 'review_submitted' | 'commented';
+type SentryAction = 'issue_alert' | 'metric_alert';
+/**
+ * Where the resolved budget came from.
+ */
+type BudgetSource = 'system' | 'account' | 'config' | 'run';
+/**
+ * How a session's environment was chosen. None (the field is nullable)
+ * when the config carried an inline environment block and no resolution ran —
+ * an inline environment is not a reference, so there is nothing to record.
+ *
+ * Not derivable from the row: `environment_id` says WHICH environment, not
+ * how it was chosen, and is null for the built-in basic sandbox.
+ */
+type EnvironmentSource = 'request' | 'automation' | 'repo_default' | 'account_default' | 'platform_default';
+/**
+ * Why a terminal agent session ended — a finer-grained reason than `status`.
+ *
+ * `status` (SessionStatus) is the lifecycle state: COMPLETED / ERROR /
+ * CANCELLED. `exit_status` explains *why* a run reached that terminal state, so
+ * the UI and metrics can tell a budget cutoff apart from a crashed tool call or
+ * a deliberate cancellation. It is None until the run reaches a terminal state.
+ */
+type SessionExitStatus = 'completed' | 'budget_hit' | 'payment_required' | 'tool_call_failed' | 'lifecycle_hook_failed' | 'missing_repo_access' | 'missing_token_permissions' | 'missing_sandbox_variables' | 'blocked' | 'contact_email_required' | 'cancelled' | 'interrupted' | 'error' | 'stopped';
+/**
+ * The coding-agent harness the session runs on.
+ */
+type Harness = 'claude_code' | 'codex';
+/**
+ * How a session relates to its predecessor (parent_agent_session_id) —
+ * the ONE "preceded-by" chain for every predecessor relationship. Routing
+ * reads this when the distinction matters.
+ *
+ * CONTINUATION — a follow-up in the same conversation surface (e.g. a Slack
+ * thread reply spawning a fresh session on the same thread).
+ * RESUME — a conversation re-hosted on a new box after its sandbox was torn
+ * down (interactive platform; later phase).
+ */
+type ParentKind = 'continuation' | 'resume';
+/**
+ * Why direct prompting is refused. Absent when prompting is allowed.
+ */
+type PromptBlockedReason = 'mention_surface' | 'ephemeral_trigger' | 'non_interactive' | 'harness_single_turn' | 'closed';
+/**
+ * Lifecycle of a keyed (multi-turn) session — the durable conversation.
+ * Distinct from SessionStatus, which is per-execution (one turn's run) and
+ * moves to agent_turns in a later slice. IDLE: alive, waiting for the next
+ * message. RUNNING: a turn is executing. CLOSED: the conversation is done and
+ * its sandbox/snapshots are torn down.
+ */
+type SessionState = 'idle' | 'running' | 'closed';
+/**
+ * Where the session came from (e.g. react, web, api, cli, mention, cron).
+ */
+type SessionSource = 'react' | 'web' | 'api' | 'cli' | 'mention' | 'cron';
+/**
+ * Execution status of the session.
+ */
+type SessionStatus = 'scheduled' | 'creating_sandbox' | 'running' | 'retrying' | 'completed' | 'error' | 'cancelled' | 'stopped';
+/**
+ * What the current (or most recent) execution is doing (backs `run`).
+ */
+type RunStatus = 'scheduled' | 'starting' | 'working' | 'waiting' | 'done' | 'failed' | 'stopped' | 'cancelled' | 'retrying';
+/**
+ * The durable conversation axis (backs the surfaced `session` field).
+ */
+type SessionLiveness = 'alive' | 'idle' | 'closed';
+/**
+ * Which writer owns this automation. "github" automations are defined by a file in a repository and are changed by editing that file; "api" automations have no file and are changed through this API.
+ */
+type ConfigManagedBy = 'github' | 'api';
+/**
+ * Which image-cache tier a sandbox creation took — the customer-facing
+ * names for `create_sandbox_from_default`'s exact / latest / default tiers.
+ * Rides on `Sandbox.cache_tier` and the sandbox_ready lifecycle record.
+ */
+type SandboxCacheTier = 'exact' | 'incremental' | 'full';
+type SandboxSource = 'cli' | 'web_ui' | 'ingest_pull_request_job_run' | 'agent_session' | 'image_refresh' | 'test' | 'script';
+type SandboxStatus = 'scheduled' | 'building' | 'running' | 'released' | 'terminating' | 'terminated' | 'failed';
+type SandboxType = 'claude_code';
+interface SessionListStreamMessage {
+    session: Session;
+    type: 'session';
+}
+/**
+ * An agent session: one conversation with an agent, from trigger to
+ * terminal state. Returned by `GET /v1/sessions/{id}` and carried by the
+ * session stream's `session`/`snapshot` frames — REST and stream never
+ * disagree about what a session looks like.
+ */
+interface Session {
+    attribution: SessionAttribution;
+    /**
+     * The automation the session was started from, or null for a raw session started with POST /v1/sessions.
+     */
+    automation: SessionAutomation | null;
+    budget: SessionBudget;
+    config: SessionConfig1;
+    /**
+     * The "owner/name" repository context the session was started in, if any.
+     */
+    context_repository: string | null;
+    cost: SessionCost;
+    /**
+     * When the session was created.
+     */
+    created_at: string;
+    environment: SessionEnvironment;
+    /**
+     * How the session ended; null until it is terminal.
+     */
+    exit_status: SessionExitStatus | null;
+    /**
+     * What the session did to git, one entry per repository in its workspace: the commit and branch it sits on, per-file line counts for its uncommitted changes, and the pull requests it opened. Null if nothing was ever captured.
+     */
+    git: SessionGit | null;
+    harness: Harness;
+    /**
+     * Unique identifier of the session.
+     */
+    id: string;
+    /**
+     * When the session last showed activity.
+     */
+    last_activity_at: string | null;
+    /**
+     * When the session last received a message.
+     */
+    last_message_at: string | null;
+    /**
+     * Caller-supplied metadata key-value pairs.
+     */
+    metadata: {
+        [k: string]: string;
+    };
+    parent: SessionParent;
+    /**
+     * The per-session prompt the session was started with.
+     */
+    prompt: string | null;
+    prompting: SessionPrompting;
+    /**
+     * Lifecycle state of the durable conversation, or null for sessions without one.
+     */
+    session_state: SessionState | null;
+    source: SessionSource;
+    status: SessionStatus;
+    /**
+     * Human-readable reason for the current status, when there is one.
+     */
+    status_reason: string | null;
+    stopped: SessionStopped;
+    /**
+     * The latest live summary of the session's progress while it runs, and when it was generated.
+     */
+    summary: SessionSummary | null;
+    surface: SessionSurface;
+    tokens: SessionTokens;
+    /**
+     * The external event that started the session.
+     */
+    trigger: SessionTrigger | null;
+    /**
+     * When the session was last updated.
+     */
+    updated_at: string;
+}
+/**
+ * The principal this session is attributed to.
+ */
+interface SessionAttribution {
+    /**
+     * Identifier of the principal the session is attributed to.
+     */
+    id: string | null;
+    /**
+     * Kind of principal the session is attributed to (e.g. a GitHub user or an API key).
+     */
+    type: AttributionType | null;
+    /**
+     * The GitHub user the session is attributed to, resolved at read time. Null when the attribution is not a GitHub user.
+     */
+    user: GithubAccountSnippet | null;
+}
+/**
+ * Sometimes the GitHub API returns a user of github (can include bots)
+ * using this snippet instead of the full GithubAccount model. One example,
+ * is when the API returns a pull request.
+ *
+ * This is the least amount of info we need to represent a GitHub account.
+ */
+interface GithubAccountSnippet {
+    avatar_url: string;
+    id: number;
+    login: string;
+    type: GithubAccountType;
+}
+/**
+ * The automation this session was started from: the definition frozen
+ * when the session was created, and the saved automation it came from as it
+ * exists NOW. They diverge legitimately — a YAML edit after the session
+ * started leaves the pointer describing something the session never ran.
+ */
+interface SessionAutomation {
+    config: AutomationConfig;
+    /**
+     * Identifier of the saved automation this session's snapshot was taken from. Null for a routing-file agent, a code-review stage agent, or the built-in mention agent, which have no saved automation behind them. Points at the automation as it exists now, which may have changed since.
+     */
+    id: string | null;
+}
+/**
+ * The automation definition the session was started from, frozen when the session was created.
+ */
+interface AutomationConfig {
+    ellipsis: AutomationIdentity;
+    input: InputContract | null;
+    session: SessionConfig;
+    trigger: (CronTrigger | ReactTrigger) | null;
+}
+/**
+ * The Ellipsis product namespace for a config file: which schema this is
+ * (`version`), the human-facing identity (`name`/`description`), freeform
+ * organizational `metadata`, and whether the agent is `enabled`. The
+ * presence of a top-level `ellipsis:` mapping is what marks a YAML file as
+ * an Ellipsis automation (vs arbitrary YAML that merely lives under a
+ * config directory) — see `yaml_is_ellipsis_config`.
+ *
+ * `enabled` is agent behavior, not freeform metadata, so it stays inside
+ * the config `sha` (only `metadata` is sha-excluded). Whether a session
+ * accepts messages is a per-run choice (POST /v1/sessions `interactive`),
+ * not a config one.
+ */
+interface AutomationIdentity {
+    description: string | null;
+    enabled: boolean;
+    metadata: ConfigMetadata;
+    name: string | null;
+    version: string;
+}
+interface ConfigMetadata {
+    annotations: {
+        [k: string]: string;
+    };
+    labels: string[];
+}
+/**
+ * The typed input contract: what goes INTO a session (the trigger is
+ * when it happens; this is what goes in).
+ *
+ * `json_schema` types the payload a caller-started session takes
+ * (`POST /v1/sessions` `input`, validated at the door; required when
+ * declared). It is illegal on a react-triggered agent — react payloads are
+ * platform-shaped (the published surface field sets), not caller-shaped.
+ *
+ * `message` is the initial-message template: exact `{{path}}` substitution
+ * over the caller payload (or, on a react agent, over the surface's
+ * published fields), no conditionals/loops/filters. Refs are validated at
+ * deploy time against the governing field set (see AutomationConfig's
+ * `_check_input`).
+ */
+interface InputContract {
+    json_schema: {
+        [k: string]: unknown;
+    } | null;
+    message: string | null;
+}
+/**
+ * What one session runs on: its selected harness, where it runs, what it
+ * may touch, its skills, its exit contract, and its spend cap. Every session
+ * freezes one of these (`agent_sessions.session_config`); an automation
+ * carries one under `session:` (`AutomationConfig.session`); and
+ * `POST /v1/sessions` is this shape flattened onto the request body, plus the
+ * run settings. Nothing in here is an automation's identity or trigger —
+ * those belong to `AutomationConfig`.
+ *
+ * Field order is the canonical key order for `session:` blocks and YAML
+ * exports: what runs (`harness`, `instructions`), where (`environment`), what it may
+ * touch (`permissions`), then the rest.
+ */
+interface SessionConfig {
+    budget: BudgetConfig;
+    environment: string | EnvironmentConfig;
+    /**
+     * The explicitly selected harness and its native options.
+     */
+    harness: ClaudeConfig | CodexConfig;
+    /**
+     * Instructions appended to the harness's own prompt. Text and repository file references are resolved in order.
+     */
+    instructions: string | SystemFileRef | (string | SystemFileRef)[];
+    output: OutputConfig | null;
+    permissions: PermissionsConfig;
+    skills: SkillRef[];
+}
+interface BudgetConfig {
+    day: number | null;
+    month: number | null;
+    session: number | null;
+    week: number | null;
+}
+/**
+ * Everything about the environment (the sandbox) the agent runs in: which
+ * `repositories` are cloned into it, which environment `variables` it gets,
+ * its `compute` sizing, how its `image` is customized, and lifecycle `hooks`.
+ * What the agent may *do* from that environment is the top-level
+ * `permissions:` block, not this one.
+ *
+ * Each `variables` entry names a variable to inject; with an inline `value` it
+ * is hardcoded, without one it is resolved from the account's sandbox-secrets
+ * store. Only the named variables reach this agent; the rest of the account's
+ * stored variables never do. This is how a config brings in the config and
+ * credentials a custom CLI needs.
+ */
+interface EnvironmentConfig {
+    compute: ComputeConfig;
+    hooks: EnvironmentHooks;
+    image: EnvironmentImage;
+    mcp_servers: (string | McpServerRef | McpStdioServer | McpRemoteServer)[];
+    repositories: RepositoryRef[];
+    variables: EnvironmentVariable[];
+}
+/**
+ * Sandbox compute sizing. Every field is optional; None inherits the
+ * platform default (2 vCPU / 4096 MiB / 3600s — see DEFAULT_SANDBOX_* in
+ * models/ellipsis/sandboxes/sandbox.py). A resolved value outside the platform
+ * bounds fails validation loudly (a sync error on the config) rather than
+ * being clamped silently.
+ *
+ * `memory` and `timeout` each accept a shorthand string ("8GB", "30m") or an
+ * explicit units object ({gb: 8}, {minutes: 30}); the `memory_mib` /
+ * `timeout_seconds` properties resolve either form to the canonical integer
+ * the sandbox driver consumes.
+ *
+ * `timeout` is the max wall-clock the agent may run before its execution is
+ * stopped, capped at 1h (MAX_SANDBOX_TIMEOUT_SECONDS — equal to the default, so
+ * today the knob only shortens a session; the cap matches the 1-hour validity
+ * of the sandbox's GitHub token). The worker's lease/visibility heartbeat
+ * ceiling is derived from that cap, so a run at the max stays owned by its
+ * worker for its whole life.
+ *
+ * Compute currently uses a temporary flat one-cent amount per allocated
+ * execution, subject to the account's existing free-compute exemptions.
+ */
+interface ComputeConfig {
+    cpu: number | null;
+    memory: string | MemorySize | null;
+    timeout: string | Duration | null;
+}
+/**
+ * A memory size as explicit units, summed (binary: 1GB = 1024MB = 1024MiB).
+ * Set any of `gb`/`mb` (at least one). The alternative to the `8GB`-style
+ * shorthand string.
+ */
+interface MemorySize {
+    gb: number | null;
+    mb: number | null;
+}
+/**
+ * A duration as explicit units, summed. Set any of `hours`/`minutes`/
+ * `seconds` (at least one). The alternative to the `30m`-style shorthand
+ * string wherever a duration is accepted.
+ */
+interface Duration {
+    hours: number | null;
+    minutes: number | null;
+    seconds: number | null;
+}
+/**
+ * Shell scripts run at points in the sandbox lifecycle, each as the sandbox
+ * user with the sandbox's environment variables available. A non-zero exit
+ * fails the run (exit_status = LIFECYCLE_HOOK_FAILED) and is not retried.
+ *
+ * `post_start` runs after the container starts, before any repo is cloned —
+ * repo-independent setup (authenticate a CLI, e.g. `doppler setup`). On Freestyle
+ * the repo is baked into the image so it is incidentally present, but
+ * `post_start` must not depend on repo contents (that's `post_clone`).
+ *
+ * `post_clone` runs after all repos are cloned/checked out, before the agent —
+ * repo-dependent setup (`pip install -r requirements.txt`, codegen).
+ *
+ * Hooks run on every run and their output is never cached. A dependency
+ * install whose result should be reused across runs belongs in `image.setup`
+ * (baked into the cached image) instead; keep hooks for per-run work — e.g.
+ * anything that touches run-scoped credentials.
+ */
+interface EnvironmentHooks {
+    post_clone: string | null;
+    post_start: string | null;
+}
+/**
+ * How to customize the container image the agent runs in. You
+ * contribute appended layers (`dockerfile_append`) and a build-time script
+ * (`setup`) only — Ellipsis owns FROM / base tooling / entrypoint / user.
+ * Today only inline bodies are supported; a file reference (resolved at the
+ * run's SHA) will come later.
+ *
+ * The split: `dockerfile_append` runs when the image is assembled, before any
+ * repo exists — toolchain installs (a package manager binary, apt packages).
+ * `setup` runs at image-build time *after* the configured repositories are
+ * checked out, and its output is captured by the filesystem snapshot that
+ * becomes the cached image — dependency installs (`poetry install`,
+ * `npm install`), so later runs start with deps already on disk. Neither runs
+ * per run; that's `hooks.post_start` / `hooks.post_clone`.
+ */
+interface EnvironmentImage {
+    dockerfile_append: string | null;
+    setup: string | null;
+}
+/**
+ * One built-in MCP server this agent opts into by name (`linear`/`slack`).
+ * A name reference over the connected built-in set — the platform manages the
+ * server's transport and credentials. It only matters when the named
+ * integration is set to `opt_in` inclusion; an integration in the default
+ * `all_sessions` mode is added regardless. For a server the platform does not
+ * provide, define it instead (`McpStdioServer` /
+ * `McpRemoteServer`).
+ */
+interface McpServerRef {
+    name: string;
+}
+/**
+ * A bring-your-own stdio MCP server: the harness spawns `command` inside
+ * the sandbox and speaks JSON-RPC over its stdin/stdout. The command must be
+ * runnable in the sandbox image — install its runtime via `image.setup` /
+ * `image.dockerfile_append` if the base image lacks it.
+ *
+ * `env` values may embed `${NAME}` references, resolved at run time from the
+ * account's secrets store (see `mcp_secret_refs`); everything else is passed
+ * literally.
+ */
+interface McpStdioServer {
+    args: string[];
+    command: string;
+    env: {
+        [k: string]: string;
+    };
+    name: string;
+}
+/**
+ * A bring-your-own remote MCP server: the harness talks HTTP to `url`.
+ * Nothing runs in the sandbox image. `headers` carry static auth (e.g.
+ * `Authorization: Bearer ${TOKEN}`); values may embed `${NAME}` secret
+ * references, resolved at run time from the account's secrets store.
+ */
+interface McpRemoteServer {
+    headers: {
+        [k: string]: string;
+    };
+    name: string;
+    url: string;
+}
+interface RepositoryRef {
+    name: string;
+    owner: string | null;
+    ref: string | null;
+}
+/**
+ * One environment variable injected into the agent's sandbox.
+ *
+ * `value`, when set, is a literal injected as-is — use it for non-secret
+ * config (LOG_LEVEL, an API base URL). When `value` is omitted the value is
+ * resolved at run time from the account's sandbox-secrets store (dashboard
+ * / `PUT /v1/secrets`) by `name`, so a secret can be injected without
+ * ever putting it in the config file. Either way the variable only reaches
+ * agents that name it.
+ */
+interface EnvironmentVariable {
+    name: string;
+    value: string | null;
+}
+/**
+ * Native Claude Code options for an explicitly selected harness.
+ */
+interface ClaudeConfig {
+    effort: EffortLevel | null;
+    fallback_model: string | null;
+    max_turns: number | null;
+    model: string | null;
+    settings: SettingsRef | null;
+    type: 'claude_code';
+}
+/**
+ * A config-declared Claude Code settings.json, resolved at run start and
+ * passed to `claude --settings <path>`. That is the CLI settings tier — BELOW
+ * Ellipsis's managed-settings.json floor — so it customizes behavior (model
+ * permissions, includeCoAuthoredBy, statusLine, ...) but can never weaken a
+ * security setting. Lets a team point the cloud agent at the same settings file
+ * they already use with Claude Code locally instead of re-encoding it as YAML.
+ */
+interface SettingsRef {
+    path: string;
+    repository: RepositoryRef | null;
+}
+/**
+ * Native options supported by the current Codex adapter.
+ *
+ * Options and capabilities expand only when their runtime behavior is tested.
+ * Unknown options are rejected instead of silently ignored.
+ */
+interface CodexConfig {
+    /**
+     * Reasoning effort for every turn. Omit to use the model default.
+     */
+    effort: CodexEffortLevel | null;
+    model: string;
+    type: 'codex';
+}
+interface SystemFileRef {
+    file: string;
+    repository: RepositoryRef | null;
+}
+/**
+ * JSON Schema for the harness's structured result, when certified.
+ */
+interface OutputConfig {
+    json_schema: {
+        [k: string]: unknown;
+    };
+}
+/**
+ * What the agent is allowed to touch, per credential the platform mints
+ * into its sandbox. Distinct from `environment:`, which is where the agent
+ * runs; this is what it may do from there.
+ *
+ * `ellipsis` scopes the sandbox's Ellipsis API token
+ * (`ELLIPSIS_API_TOKEN`, what the in-sandbox `agent` CLI authenticates
+ * with). `true` / the string `all` (the default) grant the full sandbox
+ * ceiling — everything a sandbox token can ever do. A map narrows it per
+ * resource (see `EllipsisPermissions`); the minted token carries
+ * the intersection, so a config can only ever reduce access. `false` fails
+ * validation — an agent with no API token cannot report its own progress.
+ *
+ * `github` scopes the sandbox's GitHub installation token (`GH_TOKEN`) —
+ * see `GithubPermissions`. GitHub enforces it at mint time.
+ */
+interface PermissionsConfig {
+    ellipsis: (true | 'all') | EllipsisPermissions;
+    github: GithubPermissions;
+}
+/**
+ * `permissions.ellipsis` as a map: resource → level | grant | list of
+ * grants. Levels are hierarchical (read < write < delete), so `write`
+ * includes `read`. An unlisted resource is denied. The whole block is
+ * intersected with the platform's sandbox ceiling at token mint — it can
+ * narrow what a sandbox token may do, never exceed it.
+ */
+interface EllipsisPermissions {
+    [k: string]: Level | EllipsisGrant | (Level | EllipsisGrant)[];
+}
+/**
+ * One grant entry: a level, optionally narrowed to instances whose
+ * natural key (a file's name, a memory's path, a secret's name, a config's
+ * name, a session's id) matches any of the `match` globs.
+ */
+interface EllipsisGrant {
+    level: Level;
+    match: string[] | null;
+}
+/**
+ * The agent's GitHub access: the scope of the installation token minted for
+ * its sandbox — the credential `git`, `gh`, and the GitHub MCP server
+ * authenticate with.
+ *
+ * By default the token carries the installation's full permissions on all of
+ * the installation's repositories. `permissions` narrows what it may do:
+ * the string `read_only` grants read access to contents, issues, metadata and
+ * pull requests; a map requests explicit levels per GitHub App permission
+ * scope (e.g. `{contents: read, pull_requests: write}`) and may never exceed
+ * what the installation granted. `repositories` scopes the token to exactly
+ * the listed repos, by name (they must belong to the installation).
+ *
+ * Restriction is enforced by GitHub, not by Ellipsis: the token itself is
+ * minted with the reduced scope, so nothing running in the sandbox can
+ * exceed it.
+ */
+interface GithubPermissions {
+    permissions: 'read_only' | {
+        [k: string]: string;
+    } | null;
+    repositories: string[] | null;
+}
+/**
+ * A repository directory containing SKILL.md and supporting UTF-8 files.
+ * Resolved at run start and installed in the selected harness's skill directory.
+ * Explicit skill references require a model with the skills capability.
+ */
+interface SkillRef {
+    path: string;
+    repository: RepositoryRef | null;
+}
+interface CronTrigger {
+    schedule: string;
+    type: 'cron';
+}
+interface ReactTrigger {
+    issue: ReactIssue | null;
+    linear_issue: ReactLinearIssue | null;
+    pull_request: ReactPullRequest | null;
+    push: ReactPush | null;
+    sentry: ReactSentry | null;
+    slack_channel: ReactSlackChannel | null;
+    type: 'react';
+}
+interface ReactIssue {
+    for: GithubAccountSelector;
+    labels: string[];
+    on: IssueAction[];
+    repositories: RepositoryFilter;
+}
+/**
+ * A selector of GitHub accounts — the `for:` audience gate on react
+ * surfaces and code review pipelines, classified on the stable entity author
+ * (the pusher for `push`, the PR author for a review). `users` selects human
+ * accounts, `bots` selects bot accounts; each is a `GithubAccountFilter`
+ * (include minus exclude, with bare bool/list shorthand).
+ */
+interface GithubAccountSelector {
+    bots: GithubAccountFilter;
+    users: GithubAccountFilter;
+}
+interface ReactLinearIssue {
+    for: GithubAccountSelector;
+    on: LinearIssueAction[];
+}
+interface ReactPullRequest {
+    base: string[];
+    draft: boolean | null;
+    for: GithubAccountSelector;
+    head: string[];
+    labels: string[];
+    on: PullRequestAction[];
+    paths: string[];
+    repositories: RepositoryFilter;
+}
+interface ReactPush {
+    branch: string[];
+    for: GithubAccountSelector;
+    paths: string[];
+    repositories: RepositoryFilter;
+}
+interface ReactSentry {
+    on: SentryAction[];
+    projects: string[];
+}
+interface ReactSlackChannel {
+}
+/**
+ * The spend budget enforced for this session.
+ */
+interface SessionBudget {
+    /**
+     * The spend budget resolved for this session, in cents.
+     */
+    cents: number;
+    source: BudgetSource;
+}
+/**
+ * What one session runs on: its selected harness, where it runs, what it
+ * may touch, its skills, its exit contract, and its spend cap. Every session
+ * freezes one of these (`agent_sessions.session_config`); an automation
+ * carries one under `session:` (`AutomationConfig.session`); and
+ * `POST /v1/sessions` is this shape flattened onto the request body, plus the
+ * run settings. Nothing in here is an automation's identity or trigger —
+ * those belong to `AutomationConfig`.
+ *
+ * Field order is the canonical key order for `session:` blocks and YAML
+ * exports: what runs (`harness`, `instructions`), where (`environment`), what it may
+ * touch (`permissions`), then the rest.
+ */
+interface SessionConfig1 {
+    budget: BudgetConfig;
+    environment: string | EnvironmentConfig;
+    /**
+     * The explicitly selected harness and its native options.
+     */
+    harness: ClaudeConfig | CodexConfig;
+    /**
+     * Instructions appended to the harness's own prompt. Text and repository file references are resolved in order.
+     */
+    instructions: string | SystemFileRef | (string | SystemFileRef)[];
+    output: OutputConfig | null;
+    permissions: PermissionsConfig;
+    skills: SkillRef[];
+}
+/**
+ * What the session cost, in millicents, broken down by leg and carrying its own total.
+ */
+interface SessionCost {
+    /**
+     * Platform fee in millicents.
+     */
+    fee: number;
+    /**
+     * LLM spend in millicents.
+     */
+    llm: number;
+    /**
+     * Sandbox CPU spend in millicents.
+     */
+    sandbox_cpu: number;
+    /**
+     * Sandbox memory spend in millicents.
+     */
+    sandbox_memory: number;
+    /**
+     * The grand total in millicents: llm + sandbox_cpu + sandbox_memory + fee.
+     */
+    total: number;
+}
+/**
+ * The environment the session resolved: the saved environment's id and how it was chosen. The environment's frozen body is `config.environment`.
+ */
+interface SessionEnvironment {
+    /**
+     * Identifier of the saved environment the session's config resolved. Null for an inline environment block or the built-in basic sandbox.
+     */
+    environment_id: string | null;
+    /**
+     * How the environment was chosen (request, automation, platform_default; repo_default and account_default on sessions from before those ladders were removed). Null when the config carried its own inline environment.
+     */
+    source: EnvironmentSource | null;
+}
+/**
+ * Every repo the session touched. Small enough to ride on `agent_sessions`
+ * and be returned by every session read.
+ */
+interface SessionGit {
+    repos: SessionGitRepo[];
+}
+/**
+ * One checkout in the session's sandbox and everything the session did to
+ * it, split by whether it survived the sandbox.
+ */
+interface SessionGitRepo {
+    commits: SessionGitCommit[];
+    commits_total: number;
+    full_name: string;
+    local_commit: string | null;
+    local_uncommitted_files: SessionGitFile[];
+    prs: SessionGitPr[];
+    remote_branch: string | null;
+    remote_commit: string | null;
+}
+/**
+ * One commit the session created in this repo (everything past the
+ * provisioning checkout's sha), captured from the sandbox rather than the
+ * transcript so it stays correct through amends, rebases, and commits made by
+ * scripts. The repo is the parent object, so it is not repeated here.
+ */
+interface SessionGitCommit {
+    committed_at: string;
+    pushed: boolean;
+    sha: string;
+    subject: string;
+}
+/**
+ * One file's uncommitted change, as `git diff HEAD --numstat` reports it
+ * (with intent-to-add, so a brand-new file still counts).
+ */
+interface SessionGitFile {
+    additions: number;
+    deletions: number;
+    path: string;
+    status: string;
+}
+/**
+ * A pull request the session opened in this repo, written the moment the
+ * creating tool call's result lands (see extract_session_prs.PrCreateWatcher).
+ * Live PR state (open/merged/closed) is not stored — it lives on gh_prs,
+ * joined via `gh_pr_id` (GET /frontend/agents/sessions/{id}/git). The repo is
+ * the parent object, so it is not repeated here.
+ */
+interface SessionGitPr {
+    gh_pr_id: number | null;
+    number: number;
+    title: string | null;
+    url: string;
+}
+/**
+ * What preceded this session, if anything.
+ */
+interface SessionParent {
+    /**
+     * How this session relates to its parent session, if any.
+     */
+    kind: ParentKind | null;
+    /**
+     * Identifier of the original session this one was replayed from, if it was started via replay.
+     */
+    replayed_from_session_id: string | null;
+    /**
+     * Identifier of the parent session that spawned this one, if any.
+     */
+    session_id: string | null;
+}
+/**
+ * Whether a client may send this session a message and, when it may not, the reason to show instead of a composer.
+ */
+interface SessionPrompting {
+    blocked_reason: PromptBlockedReason | null;
+    detail: string | null;
+    enabled: boolean;
+    surface_name: string | null;
+}
+/**
+ * The stop request, if the session was stopped.
+ */
+interface SessionStopped {
+    /**
+     * When a stop was requested, if one was.
+     */
+    at: string | null;
+    /**
+     * GitHub account id of the user who stopped the session, if known.
+     */
+    by: number | null;
+    /**
+     * The GitHub user who stopped the session, resolved at read time.
+     */
+    by_user: GithubAccountSnippet | null;
+}
+/**
+ * A live one-line summary of what the session is working on, refreshed
+ * every few steps while it runs.
+ */
+interface SessionSummary {
+    /**
+     * When this summary line was generated. Null on summaries written before generation time was tracked.
+     */
+    created_at: string | null;
+    /**
+     * One-line description of what the session is working on.
+     */
+    description: string;
+}
+/**
+ * The public status projection: the durable conversation (`session`), the current execution (`run`), and the one derived `status` word.
+ */
+interface SessionSurface {
+    run: RunStatus | null;
+    session: SessionLiveness | null;
+    status: string | null;
+}
+/**
+ * The tokens the session spent and the model they went to. `total` includes the prompt-cache lanes.
+ */
+interface SessionTokens {
+    /**
+     * Tokens written to the prompt cache.
+     */
+    cache_creation: number;
+    /**
+     * Tokens read from the prompt cache.
+     */
+    cache_read: number;
+    /**
+     * Input tokens used.
+     */
+    input: number;
+    /**
+     * The model the token counts are attributed to.
+     */
+    model: string;
+    /**
+     * Output tokens used.
+     */
+    output: number;
+    /**
+     * Total tokens consumed, INCLUDING the prompt-cache reads and writes — the same basis the token cost is priced on.
+     */
+    total: number;
+}
+/**
+ * The external event that started a session, without raw webhook payloads.
+ */
+interface SessionTrigger {
+    action: string | null;
+    actor: SessionTriggerActor | null;
+    branch: string | null;
+    number: number | null;
+    repository: string | null;
+    surface: string | null;
+    title: string | null;
+    url: string | null;
+}
+interface SessionTriggerActor {
+    avatar_url: string | null;
+    is_bot: boolean;
+    name: string;
+}
+interface AutomationListStreamMessage {
+    automations: Automation[];
+    type: 'automations';
+}
+/**
+ * An automation: a saved agent definition that runs on its trigger or
+ * when invoked, plus where it syncs from and the state of that sync.
+ */
+interface Automation {
+    config: AutomationConfig1;
+    /**
+     * When the automation was created.
+     */
+    created_at: string;
+    /**
+     * The raw ellipsis.name display text from the config file.
+     */
+    display_name: string | null;
+    /**
+     * The GitHub account that last edited the automation, when the edit came from a known user.
+     */
+    edited_by: GithubAccountSnippet | null;
+    /**
+     * Unique identifier of the automation.
+     */
+    id: string;
+    /**
+     * When that most recent session was created.
+     */
+    last_session_created_at: string | null;
+    /**
+     * The most recent session this automation started, or null if it has never run.
+     */
+    last_session_id: string | null;
+    /**
+     * The parse or validation error from the most recent sync attempt, or null when it succeeded. A non-null value means the automation is not running the YAML currently on the branch.
+     */
+    last_sync_error: string | null;
+    /**
+     * The last commit the automation was synced from.
+     */
+    last_synced_commit_sha: string | null;
+    managed_by: ConfigManagedBy;
+    /**
+     * The automation's account-unique addressable name (a slug of its display name); usable anywhere an automation is referenced, interchangeably with the id.
+     */
+    name: string | null;
+    /**
+     * The open pull request that adds this automation's file. Non-null means the automation is not live yet: it starts running once the pull request merges and syncs.
+     */
+    pending_pull_request_url: string | null;
+    /**
+     * The definition's content identity: the version fingerprint frozen onto each session that runs it.
+     */
+    sha: string;
+    /**
+     * The repository, path, and branch the automation syncs from. Null only transiently, before the creating pull request's file lands on the branch.
+     */
+    source_details: GithubSourceDetails | null;
+    /**
+     * When the automation was last updated.
+     */
+    updated_at: string;
+}
+/**
+ * The automation definition itself, in the same schema as its YAML file: identity, trigger, input contract, and the session block.
+ */
+interface AutomationConfig1 {
+    ellipsis: AutomationIdentity;
+    input: InputContract | null;
+    session: SessionConfig;
+    trigger: (CronTrigger | ReactTrigger) | null;
+}
+/**
+ * Identifies the file a GitHub-sourced automation is synced from.
+ *
+ * Keyed on the repository ID (not owner/name) so repository and org renames
+ * don't orphan the config; resolve display names from gh_repositories at
+ * read time.
+ */
+interface GithubSourceDetails {
+    branch: string;
+    path: string;
+    repo_id: number;
+}
+interface CollectionStreamHeartbeat {
+    type: 'heartbeat';
+}
+interface SandboxSnapshotFrame {
+    sandbox: SandboxResponse;
+    type: 'snapshot';
+}
+interface SandboxResponse {
+    cache_tier: SandboxCacheTier | null;
+    cost_sandbox_cpu: number;
+    cost_sandbox_memory: number;
+    cpu: number;
+    dockerfile: string | null;
+    encrypted_ports: number[];
+    environment_variable_keys: string[];
+    failed_at: string | null;
+    id: string;
+    image_setup: string | null;
+    memory_mib: number;
+    phase_timings: {
+        [k: string]: number;
+    };
+    post_clone: string | null;
+    post_start: string | null;
+    repositories: SandboxRepository[];
+    running_at: string | null;
+    scheduled_at: string;
+    source: SandboxSource;
+    source_session_id: string | null;
+    status: SandboxStatus;
+    terminated_at: string | null;
+    terminating_at: string | null;
+    timeout_seconds: number;
+    tunnels: SandboxPort[];
+    type: SandboxType;
+    unencrypted_ports: number[];
+}
+interface SandboxRepository {
+    id: number;
+    name: string;
+    owner_id: number;
+    owner_name: string;
+    sha: string;
+}
+interface SandboxPort {
+    port: number;
+    tcp_host: string | null;
+    tcp_port: number | null;
+    tls_host: string;
+    tls_port: number;
+    tunnel_url: string;
+    unencrypted_host: string | null;
+    unencrypted_port: number | null;
+}
+interface SandboxUpdateFrame {
+    sandbox: SandboxResponse;
+    type: 'sandbox';
+}
 
 interface CursorResponse {
     has_more: boolean;
@@ -23,6 +1081,7 @@ interface SessionsApi {
     stop(sessionId: string): Promise<S$1['SessionResponse']>;
     sendMessage(sessionId: string, options: {
         message: string;
+        images?: S$1['ImageAttachment'][];
         idempotency_key?: string | null;
     }): Promise<S$1['SessionMessageResponse']>;
     records(sessionId: string, options?: {
@@ -42,6 +1101,7 @@ declare class SessionHandle {
         pollIntervalMs?: number;
     }): Promise<S$1['Session']>;
     send(message: string, options?: {
+        images?: S$1['ImageAttachment'][];
         idempotencyKey?: string;
     }): Promise<S$1['SessionMessage']>;
     stop(): Promise<S$1['Session']>;
@@ -69,6 +1129,344 @@ declare class Transport {
 }
 
 type S = components['schemas'];
+declare class EllipsisAccountApiKeys {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * Create Api Key
+     *
+     * Create an organization key. Requires a verified GitHub administrator.
+     *
+     * Authenticate as a dashboard user or with a user token. An organization
+     * API key cannot create other keys. The secret is returned only once.
+     */
+    create(options: {
+        name: string;
+    }): Promise<S['CreateApiKeyResponse']>;
+    /**
+     * List Api Keys
+     */
+    list(): Promise<S['ListApiKeysResponse']>;
+    /**
+     * Revoke Api Key
+     *
+     * Revoke an organization key as a verified GitHub administrator.
+     */
+    revoke(api_key_id: string): Promise<S['TokenRevokedResponse']>;
+}
+declare class EllipsisAccountBillingAutoRecharge {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * Get Auto Recharge
+     *
+     * Get your automatic credit recharge settings.
+     *
+     * An account without saved settings returns disabled defaults and no
+     * card. No payment-method identifier or card details are exposed.
+     */
+    get(): Promise<S['AutoRechargeSettings']>;
+    /**
+     * Update Auto Recharge
+     *
+     * Set your automatic credit recharge policy.
+     *
+     * Requires a human account administrator; API keys and sandbox tokens
+     * cannot change this policy. Supply enabled explicitly. Saving amounts
+     * with enabled=false keeps recharge off; enabling requires a saved card.
+     * A recharge buys amount_cents of credit and charges the platform fee
+     * in addition. Amounts and thresholds preserve exact cents.
+     */
+    set(options: {
+        amount_cents: number;
+        enabled: boolean;
+        threshold_cents: number;
+    }): Promise<S['AutoRechargeSettings']>;
+}
+declare class EllipsisAccountBilling {
+    private readonly transport;
+    readonly autoRecharge: EllipsisAccountBillingAutoRecharge;
+    constructor(transport: Transport);
+    /**
+     * Create Card Setup Session
+     *
+     * Save a card through Stripe's hosted setup flow.
+     *
+     * Requires a human account administrator. Open the returned URL to
+     * finish setup and return to Billing. Saving a card does not enable
+     * auto-recharge or buy credit.
+     */
+    cardSetup(): Promise<S['BillingCheckout']>;
+    /**
+     * Create Credit Checkout Session
+     *
+     * Buy prepaid credit through Stripe's hosted checkout.
+     *
+     * Requires a human account administrator. Open the returned URL to
+     * complete payment. Credit is granted only after payment succeeds;
+     * the platform fee is charged in addition to amount_cents. Returning
+     * to Billing carries the checkout session ID for receipt lookup.
+     */
+    checkout(options: {
+        amount_cents: number;
+    }): Promise<S['BillingCheckout']>;
+    /**
+     * Claim Signup Credit
+     *
+     * The "Claim $100" button. Runs the same idempotent billing
+     * bootstrap that otherwise fires lazily at the first session (Stripe
+     * customer + usage subscription + the signup grant). A repeat call is
+     * a no-op that returns the current state.
+     */
+    claimSignupCredit(): Promise<S['BillingStatus']>;
+    /**
+     * Get Fee Schedule
+     *
+     * Get the account's rate card, in US dollars.
+     */
+    feeSchedule(): Promise<S['FeeScheduleResponse']>;
+    /**
+     * List Credit Grants
+     *
+     * List your confirmed credit grants and reversals.
+     *
+     * Returns only your account's grants. The total is before usage;
+     * /v1/account/budget reports the available balance.
+     */
+    grants(): Promise<S['CreditGrantsResponse']>;
+    /**
+     * Get Credit Purchase
+     *
+     * Read the amount collected for a credit purchase.
+     *
+     * The amount includes the platform fee and comes from Stripe. An
+     * incomplete, missing, or other-account purchase returns 404.
+     */
+    purchase(checkout_id: string): Promise<S['CreditPurchaseReceipt']>;
+    /**
+     * Get Credit Purchase Options
+     *
+     * Get credit purchase bounds and the platform fee.
+     *
+     * All amounts are integer US cents. The fee is added to the credit
+     * amount; it does not reduce the credit granted.
+     */
+    purchaseOptions(): Promise<S['CreditPurchaseOptions']>;
+    /**
+     * Get Account Billing
+     *
+     * Explain whether your account can start sessions.
+     *
+     * Uses the same account gate as session admission, including credit,
+     * contact email, and personal Claude subscription eligibility. Scoped
+     * spend limits are reported separately by /v1/account/budget.
+     */
+    status(): Promise<S['BillingStatus']>;
+}
+declare class EllipsisAccountModels {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * List Account Models
+     *
+     * List selectable agent models.
+     *
+     * Grouped by manufacturer and model family, newest versions first
+     * within each family, with the organization's default model
+     * flagged (`is_default_agent_model`: the `default_model` of
+     * `GET /v1/account/settings`).
+     *
+     * Reads the same registry as the dashboard's rate table, so a
+     * client's model picker can never drift from what's offered. The
+     * selectable set is global; only the flag is account-scoped.
+     */
+    list(): Promise<S['ModelsListResponse']>;
+}
+declare class EllipsisAccountNotifications {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * Send Test Notification Email
+     *
+     * Send the alert email template to one address with sample data,
+     * so a typo'd finance alias is caught by a human instead of failing
+     * silently when a real alert fires.
+     */
+    testEmail(options: {
+        email: string;
+    }): Promise<S['AccountActionResponse']>;
+}
+declare class EllipsisAccountProvidersAnthropic {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * Delete Anthropic Config
+     */
+    delete(): Promise<void>;
+    /**
+     * Get Anthropic Config
+     */
+    get(): Promise<S['AnthropicConfigResponse']>;
+    /**
+     * Put Anthropic Config
+     */
+    set(options: {
+        api_key: string;
+    }): Promise<S['AnthropicConfigResponse']>;
+    /**
+     * Validate Anthropic Config
+     */
+    validate(): Promise<S['ValidateAnthropicConfigResponse']>;
+}
+declare class EllipsisAccountProvidersBedrock {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * Delete Bedrock Config
+     */
+    delete(): Promise<void>;
+    /**
+     * Get Bedrock Config
+     */
+    get(): Promise<S['BedrockConfigResponse']>;
+    /**
+     * Put Bedrock Config
+     */
+    set(options: {
+        model_map: Record<string, string>;
+        region: string;
+        role_arn: string;
+    }): Promise<S['BedrockConfigResponse']>;
+    /**
+     * Validate Bedrock Config
+     */
+    validate(): Promise<S['ValidateBedrockConfigResponse']>;
+}
+declare class EllipsisAccountProviders {
+    private readonly transport;
+    readonly anthropic: EllipsisAccountProvidersAnthropic;
+    readonly bedrock: EllipsisAccountProvidersBedrock;
+    constructor(transport: Transport);
+}
+declare class EllipsisAccountSettings {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * Get Account Settings
+     *
+     * Get the organization settings.
+     *
+     * Session model and budget defaults, code review and mention behavior,
+     * analytics, retention, and notification contacts. PATCH replaces
+     * supplied sections; PUT preserves its model-and-budget-only behavior.
+     */
+    get(): Promise<S['AccountSettings']>;
+    /**
+     * Set Organization Settings
+     *
+     * Set the organization settings.
+     *
+     * Replaces both: `default_model` accepts an alias or canonical id
+     * and is stored canonical, and cannot be cleared (it is the only
+     * default a session's model resolves against);
+     * `budget_ceiling.session` is in US dollars, at most the platform
+     * ceiling, and null clears it.
+     * Refused for sandbox tokens (potentially prompt-injected code must
+     * not repoint the organization's defaults).
+     */
+    set(options: {
+        budget_ceiling?: S['BudgetCeiling'];
+        default_model: string;
+    }): Promise<S['OrganizationSettings']>;
+    /**
+     * Patch Account Settings
+     *
+     * Replace supplied settings sections without changing omitted sections.
+     *
+     * Changes to model or budget defaults require a GitHub administrator.
+     */
+    update(options?: {
+        analytics?: S['AnalyticsSettings'] | null;
+        budget_ceiling?: S['BudgetCeiling'] | null;
+        code_review?: S['CodeReviewSettings'] | null;
+        data_retention?: S['DataRetentionSettings'] | null;
+        default_model?: string | null;
+        mention?: S['MentionSettings'] | null;
+        notifications?: S['NotificationSettings'] | null;
+    }): Promise<S['AccountSettings']>;
+}
+declare class EllipsisAccount {
+    private readonly transport;
+    readonly apiKeys: EllipsisAccountApiKeys;
+    readonly billing: EllipsisAccountBilling;
+    readonly models: EllipsisAccountModels;
+    readonly notifications: EllipsisAccountNotifications;
+    readonly providers: EllipsisAccountProviders;
+    readonly settings: EllipsisAccountSettings;
+    constructor(transport: Transport);
+    /**
+     * Get Customer Activity
+     *
+     * All-time per-surface activity flags: the dashboards' demo-data
+     * fallback reads these instead of inferring "no history" from a
+     * windowed, filtered response.
+     */
+    activity(): Promise<S['AccountActivity']>;
+    /**
+     * Get Customer Audit Log
+     */
+    auditLog(): Promise<S['AccountAuditLogResponse']>;
+    /**
+     * Get Account Budget
+     *
+     * Get prepaid credit, actual trailing budgets, and developer/API-key limits.
+     *
+     * Budgets cover the trailing 1, 7 and 28 days; they do not replenish
+     * prepaid credit. Amounts include measured usage from active sessions.
+     * Each paid LLM request requires positive credit and budget headroom.
+     * An admitted request can overshoot; concurrency is limited to five
+     * paid requests per account and one per session.
+     */
+    budget(): Promise<S['BudgetSummary']>;
+    /**
+     * Update Customer
+     */
+    update(options?: {
+        can_start_job_runs?: boolean | null;
+        contact_email?: string | null;
+    }): Promise<S['AccountResponse']>;
+    /**
+     * Update Budget
+     *
+     * Update spending policy or budget alerts as an account administrator.
+     *
+     * Each supplied section replaces that section; omitted sections are
+     * preserved. Set policy.developer_defaults to null to disable developer
+     * limits. Null override windows inherit their default. API keys use
+     * their stable ID, not their secret. Changes apply to the next paid
+     * request, including sessions already running. API keys and sandbox
+     * credentials cannot edit budgets. The session ceiling remains at
+     * /account/settings; purchasing credits is separate from budget policy.
+     */
+    updateBudget(options?: {
+        alerts?: S['BudgetAlerts'] | null;
+        policy?: S['BudgetPolicy'] | null;
+    }): Promise<S['BudgetSummary']>;
+    /**
+     * Get Usage
+     *
+     * Get usage for a calendar month, including its funding sources.
+     *
+     * Omit period_start for the current UTC month; select a period returned
+     * in billing_periods to view history. Credit debits are distinct from
+     * rated token usage through BYOK, customer Bedrock, or a developer's
+     * Claude subscription. Rated usage estimates are not provider invoices.
+     * Pending and unresolved requests identify missing measurements.
+     */
+    usage(options?: {
+        period_start?: string | null;
+    }): Promise<S['GetUsageOverTimeResponse']>;
+}
 declare class EllipsisAlerts {
     private readonly transport;
     constructor(transport: Transport);
@@ -264,18 +1662,26 @@ declare class EllipsisAutomations {
      *
      * Invoke an automation.
      *
-     * Runs the automation exactly as defined — its persona, model,
-     * environment, permissions, skills, and budget bind — and returns
-     * the session it started. The body carries only what a caller may
-     * supply: the typed `input` its schema demands, an optional tighter
-     * `budget`, and `metadata`. For a different persona or environment,
-     * start a raw session with POST /v1/sessions instead.
+     * Runs a certified automation with its configured instructions, model,
+     * environment, permissions, skills, and budget, and returns
+     * the session it started. The session runs once and does not accept
+     * follow-up messages. If the automation declares input.json_schema,
+     * send only `input` for its initial message. Otherwise send a non-empty
+     * `prompt`, which becomes the initial message verbatim. Both fields
+     * together, neither field, and input that renders an empty message are
+     * rejected with 422. An optional `budget` lowers the session cap;
+     * `metadata` tags the session. Codex invocations are not supported.
      */
     run(automation_id: string, options?: {
         budget?: number | null;
         input?: Record<string, unknown> | null;
         metadata?: Record<string, string>;
+        prompt?: string | null;
     }): Promise<S['SessionResponse']>;
+    /**
+     * Get Automations Stream Ticket
+     */
+    streamTicket(): Promise<S['StreamTicketResponse']>;
     /**
      * Unlink Automation
      *
@@ -391,7 +1797,12 @@ declare class EllipsisFiles {
      * Return one file's metadata and download link.
      *
      * Includes the gated dashboard URL and a short-lived presigned
-     * `download_url`.
+     * `download_url`, plus the owning account's GitHub login.
+     *
+     * Signed-in dashboard users are checked against the file's owning
+     * account, regardless of their selected organization. API keys,
+     * CLI user tokens, and sandbox tokens remain restricted to their
+     * own account. Missing, deleted, and inaccessible files return 404.
      *
      * To fetch the bytes locally, call this and then GET download_url
      * immediately — the JSON API never carries the file. The CLI's
@@ -403,13 +1814,16 @@ declare class EllipsisFiles {
      *
      * 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.
+     * Metadata only by default. Set include_download_urls=true to get
+     * a download_urls map keyed by file id for thumbnails or batch
+     * downloads. URLs expire within about a minute. session_id scopes
+     * the list to one session's uploads.
      */
     list(options?: {
         session_id?: string | null;
         limit?: number;
         cursor?: string | null;
+        include_download_urls?: boolean;
     }): Promise<Page<S['File'], S['FilesListResponse']>>;
 }
 declare class EllipsisIntegrationsGithub {
@@ -433,20 +1847,41 @@ declare class EllipsisIntegrationsGithub {
      * List GitHub repositories connected to the installation.
      */
     repos(): Promise<S['GithubRepositoriesListResponse']>;
+    /**
+     * Uninstall Github App
+     */
+    uninstall(options: {
+        confirm_account_login: string;
+    }): Promise<S['AccountActionResponse']>;
 }
 declare class EllipsisIntegrationsLinear {
     private readonly transport;
     constructor(transport: Transport);
+    /**
+     * Delete Linear Integration
+     */
+    delete(): Promise<S['AccountActionResponse']>;
     /**
      * List Linear Teams
      *
      * List the teams of the connected Linear workspace.
      */
     teams(): Promise<S['LinearTeamsListResponse']>;
+    /**
+     * Update Linear Teams
+     */
+    updateSettings(options: {
+        mcp_inclusion?: S['McpInclusionMode'] | null;
+        teams: (S['LinearTeamUpdate'])[];
+    }): Promise<S['AccountActionResponse']>;
 }
 declare class EllipsisIntegrationsSentry {
     private readonly transport;
     constructor(transport: Transport);
+    /**
+     * Delete Sentry Integration
+     */
+    delete(integration_id: string): Promise<S['AccountActionResponse']>;
     /**
      * List Sentry Organizations
      *
@@ -464,6 +1899,14 @@ declare class EllipsisIntegrationsSlack {
      * live from the Slack API.
      */
     channels(): Promise<S['SlackChannelsListResponse']>;
+    /**
+     * Create Operations Channel
+     */
+    createOperationsChannel(): Promise<S['SlackChannel']>;
+    /**
+     * Delete Slack Integration
+     */
+    delete(): Promise<S['AccountActionResponse']>;
     /**
      * List Slack Members
      *
@@ -471,6 +1914,12 @@ declare class EllipsisIntegrationsSlack {
      * live from the Slack API.
      */
     members(): Promise<S['SlackMembersListResponse']>;
+    /**
+     * Update Slack Settings
+     */
+    updateSettings(options: {
+        mcp_inclusion: S['McpInclusionMode'];
+    }): Promise<S['AccountActionResponse']>;
 }
 declare class EllipsisIntegrations {
     private readonly transport;
@@ -565,26 +2014,13 @@ declare class EllipsisMemories {
         prefix?: string | null;
     }): Promise<S['MemoriesListResponse']>;
 }
-declare class EllipsisModels {
+declare class EllipsisReviews {
     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 Review Configs
      */
-    list(): Promise<S['ModelsListResponse']>;
-}
-declare class EllipsisReviews {
-    private readonly transport;
-    constructor(transport: Transport);
+    configs(): Promise<S['GetCodeReviewConfigsResponse']>;
     /**
      * Create Review
      *
@@ -628,7 +2064,8 @@ declare class EllipsisReviews {
      *
      * `findings` and `configuration` are omitted (counters only). Each
      * filter is a set: repeat `repository`, `pull_request_number`, or
-     * `status` to match any of several values.
+     * `status` to match any of several values. `start` and `end` bound
+     * the review's creation time.
      *
      * Webhook-created reviews appear here too, so this answers "show
      * me every review on this PR".
@@ -637,10 +2074,28 @@ declare class EllipsisReviews {
         repository?: (string)[];
         pull_request_number?: (number)[];
         status?: (S['CodeReviewRunStatus'])[];
+        start?: string | null;
+        end?: string | null;
         limit?: number;
         cursor?: string | null;
     }): Promise<Page<S['Review'], S['ReviewsListResponse']>>;
 }
+declare class EllipsisSandboxes {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * Get Single Sandbox
+     */
+    get(sandbox_id: string): Promise<S['SandboxResponse']>;
+    /**
+     * Get Sandboxes
+     */
+    list(): Promise<void>;
+    /**
+     * Get Sandbox Stream Ticket
+     */
+    streamTicket(sandbox_id: string): Promise<S['StreamTicketResponse']>;
+}
 declare class EllipsisSecrets {
     private readonly transport;
     constructor(transport: Transport);
@@ -679,6 +2134,20 @@ declare class EllipsisSecrets {
 declare class EllipsisSessions {
     private readonly transport;
     constructor(transport: Transport);
+    /**
+     * Get Agent Session Analytics
+     *
+     * Measured tokens and spend over time, plus estimated content cost.
+     *
+     * Token lanes use the request's saved rates. Content attribution
+     * apportions input/cache spend by text size, counting carried context
+     * on every request. It is an estimate, not a tool execution fee.
+     * Only the latest 200 retained request bodies are inspected; missing
+     * or unsupported context remains explicitly unattributed. No raw
+     * prompts or tool results are returned. Sandbox tokens may read only
+     * their own session's analytics.
+     */
+    analytics(session_id: string): Promise<S['SessionAnalytics']>;
     /**
      * Get Agent Session Diff
      *
@@ -691,6 +2160,17 @@ declare class EllipsisSessions {
      * sandbox token may read only its own session's diff.
      */
     diff(session_id: string): Promise<S['SessionDiffResponse']>;
+    /**
+     * List Session Executions
+     *
+     * Return the session's execution attempts, oldest first.
+     *
+     * Includes the selected harness, model, resolved instructions, initial
+     * query, and common result summary. Complete native outputs remain in
+     * the session's records. Internal launch options and checkpoint storage
+     * references are excluded.
+     */
+    executions(session_id: string): Promise<S['SessionExecutionsListResponse']>;
     /**
      * Export Agent Session
      *
@@ -719,6 +2199,15 @@ declare class EllipsisSessions {
      * live on the detail endpoints, not here.
      */
     get(session_id: string): Promise<S['SessionResponse']>;
+    /**
+     * Get Agent Session Git
+     *
+     * The session's GitHub-side git view: its commits, and each PR it
+     * opened joined to the live gh_prs row and reviews. The identity list
+     * (output_git) rides the session itself over the WebSocket; this is
+     * the join a "run" notify tells an open pane to refetch.
+     */
+    git(session_id: string): Promise<S['SessionGitResponse']>;
     /**
      * Ingest Agent Session Transcript
      *
@@ -753,6 +2242,7 @@ declare class EllipsisSessions {
         author_id?: number | null;
         repo?: string | null;
         unfinished?: boolean;
+        exclude_code_review?: boolean;
     }): Promise<Page<S['Session'], S['SessionsListResponse']>>;
     /**
      * Get Agent Session Output
@@ -765,7 +2255,7 @@ declare class EllipsisSessions {
      * when the agent declares no output block, or when no execution
      * produced output.
      */
-    output(session_id: string): Promise<void>;
+    output(session_id: string): Promise<Record<string, unknown>>;
     /**
      * Get Agent Session Records
      *
@@ -780,7 +2270,23 @@ declare class EllipsisSessions {
     records(session_id: string, options?: {
         cursor?: string | null;
         limit?: number | null;
-    }): Promise<Page<S['ClaudeSessionRecord'] | S['CodexSessionRecord'] | S['LifecycleSessionRecord'], S['SessionRecordsListResponse']>>;
+    }): Promise<Page<S['SessionRecord'], S['SessionRecordsListResponse']>>;
+    /**
+     * Search Agent Sessions
+     */
+    search(options?: {
+        q?: string;
+        scope?: S['SessionSearchScope'];
+        source?: (S['SessionSource'])[] | null;
+        author_id?: (number)[] | null;
+        automation_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
      *
@@ -793,8 +2299,13 @@ declare class EllipsisSessions {
      */
     sendMessage(session_id: string, options: {
         idempotency_key?: string | null;
+        images?: (S['ImageAttachment'])[];
         message: string;
     }): Promise<S['SessionMessageResponse']>;
+    /**
+     * Get Session Stream Ticket
+     */
+    sessionStreamTicket(session_id: string): Promise<S['StreamTicketResponse']>;
     /**
      * Start Agent Session
      *
@@ -802,20 +2313,22 @@ declare class EllipsisSessions {
      *
      * The daily driver: a prompt, optionally where to run it
      * (`environment`) and the run's own settings, in the AutomationConfig
-     * vocabulary. Anything omitted comes from the organization's
-     * settings — default model, default environment, budget — so
+     * vocabulary. What you send is what runs: omit `environment` and the
+     * session runs in the built-in basic sandbox. A missing model or
+     * budget comes from the organization's settings, so
      * `{"prompt": "..."}` alone is a complete request. `prompt` is the
      * first message; omit it and the session starts idle, waiting for
      * one. 400 when `interactive` is false and there is no prompt, or
      * when `budget` exceeds the organization's per-session ceiling. To
      * run a saved automation, use POST /v1/automations/{automation_id}/sessions.
      */
-    start(options?: {
+    start(options: {
         budget?: number | null;
-        claude?: S['ClaudeConfig'] | null;
-        codex?: S['CodexConfig'] | null;
         environment?: string | S['EnvironmentConfig'] | null;
         force_rebuild?: boolean;
+        harness: S['HarnessOptions'];
+        images?: (S['ImageAttachment'])[];
+        instructions?: S['Instructions'];
         interactive?: boolean;
         metadata?: Record<string, string>;
         output?: S['OutputConfig'] | null;
@@ -833,45 +2346,40 @@ declare class EllipsisSessions {
      * to a GitHub account.
      */
     stop(session_id: string): Promise<S['SessionResponse']>;
+    /**
+     * Get Sessions Stream Ticket
+     */
+    streamTicket(): Promise<S['StreamTicketResponse']>;
     /** 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 EllipsisSettingsOrganization {
+declare class EllipsisSupportSlack {
     private readonly transport;
     constructor(transport: Transport);
     /**
-     * Get Organization Settings
-     *
-     * Get the organization settings.
-     *
-     * The default model and default environment every session falls
-     * back to when neither its request nor its automation names one,
-     * and the per-session budget ceiling no session may exceed.
+     * Request Slack Help
      */
-    get(): Promise<S['OrganizationSettings']>;
+    create(options: {
+        emails: (string)[];
+        resend?: boolean;
+    }): Promise<S['SlackHelpResponse']>;
     /**
-     * Set Organization Settings
-     *
-     * Set the organization settings.
-     *
-     * Replaces all three: `default_model` accepts an alias or canonical
-     * id and is stored canonical; `default_environment` accepts a name
-     * or `env_` id and is stored as the id; `budget_ceiling.session` is
-     * in US dollars, at most the platform ceiling. Null clears each.
-     * Refused for sandbox tokens (potentially prompt-injected code must
-     * not repoint the organization's defaults).
+     * Get Slack Help
      */
-    set(options?: {
-        budget_ceiling?: S['BudgetCeiling'];
-        default_environment?: string | null;
-        default_model?: string | null;
-    }): Promise<S['OrganizationSettings']>;
+    get(): Promise<void>;
+    /**
+     * Invite To Slack Help
+     */
+    invite(options: {
+        emails: (string)[];
+        resend?: boolean;
+    }): Promise<S['SlackHelpResponse']>;
 }
-declare class EllipsisSettings {
+declare class EllipsisSupport {
     private readonly transport;
-    readonly organization: EllipsisSettingsOrganization;
+    readonly slack: EllipsisSupportSlack;
     constructor(transport: Transport);
 }
 declare class EllipsisTemplates {
@@ -893,8 +2401,193 @@ declare class EllipsisTemplates {
      */
     list(): Promise<S['AgentTemplatesListResponse']>;
 }
+declare class EllipsisUserSubscriptionTokens {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * Delete Subscription Token
+     *
+     * Delete your subscription token for a provider.
+     *
+     * Your sessions stop billing your subscription immediately, and the
+     * usage reading goes with it — it described that token's plan.
+     */
+    delete(provider: S['SubscriptionProvider']): Promise<void>;
+    /**
+     * Get Subscription Token
+     *
+     * Get one provider's subscription token.
+     *
+     * `configured` is false when nothing is saved. The token itself is
+     * never returned, only `token_last4`.
+     */
+    get(provider: S['SubscriptionProvider']): Promise<S['SubscriptionToken']>;
+    /**
+     * List Subscription Tokens
+     *
+     * List your subscription tokens.
+     *
+     * One entry per supported provider, whether or not you have saved a
+     * token for it. Tokens are write-only: the response carries only
+     * `token_last4`, never the token.
+     */
+    list(): Promise<S['SubscriptionTokensListResponse']>;
+    /**
+     * Set Subscription Token
+     *
+     * Save your subscription token for a provider.
+     *
+     * Replaces whatever was stored. The token is saved DISABLED and
+     * routes nothing until `POST /v1/user/subscription_tokens/{provider}/verify`
+     * succeeds. For Claude, use `claude setup-token`. For Codex, paste
+     * the auth.json credentials from a ChatGPT login. Each subscription
+     * pays only for models from its corresponding provider.
+     */
+    set(provider: S['SubscriptionProvider'], options: {
+        token: string;
+    }): Promise<S['SubscriptionToken']>;
+    /**
+     * Get Subscription Usage
+     *
+     * Get your plan's last-observed rate-limit windows.
+     *
+     * Display-only, and only as fresh as your last call through Ellipsis
+     * (`observed_at`) — the same plan used outside Ellipsis moves the
+     * real windows without us seeing them. Null unless a token is
+     * enabled for the provider: a disabled token routes nothing, so any
+     * reading behind it is stale by construction.
+     */
+    usage(provider: S['SubscriptionProvider']): Promise<S['SubscriptionUsageResponse']>;
+    /**
+     * Verify Subscription Token
+     *
+     * Verify the stored token by using it.
+     *
+     * Makes one minimal call on the exact runtime path, so a pass proves
+     * the token is what will pay. This is the gate on routing: success
+     * enables the token, failure disables it, so verifying a revoked
+     * token is how you stop it routing. A 200 with `ok: false` is the
+     * normal way a bad token is reported — it is an answer, not a
+     * transport failure.
+     */
+    verify(provider: S['SubscriptionProvider']): Promise<S['VerifySubscriptionTokenResponse']>;
+}
+declare class EllipsisUserTokens {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * List User Tokens
+     */
+    list(): Promise<S['ListUserTokensResponse']>;
+    /**
+     * Revoke User Token
+     */
+    revoke(token_id: string): Promise<S['TokenRevokedResponse']>;
+}
+declare class EllipsisUser {
+    private readonly transport;
+    readonly subscriptionTokens: EllipsisUserSubscriptionTokens;
+    readonly tokens: EllipsisUserTokens;
+    constructor(transport: Transport);
+}
+declare class EllipsisWebhooksDeliveries {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * Get Webhook Delivery
+     *
+     * Inspect a delivery's payload and attempts.
+     *
+     * Payloads are immutable across retries. Attempt details include HTTP
+     * status, timing, and errors. Response bodies are not retained.
+     */
+    get(delivery_id: string): Promise<S['WebhookDeliveryResponse']>;
+    /**
+     * List Webhook Deliveries
+     *
+     * List webhook deliveries, newest first.
+     *
+     * Includes verification pings and deliveries for deleted webhooks.
+     * History is retained for 30 days. Retries belong to the same delivery.
+     */
+    list(options?: {
+        webhook_id?: string | null;
+        event_type?: S['WebhookEventType'] | null;
+        status?: S['WebhookDeliveryStatus'] | null;
+        start?: string | null;
+        end?: string | null;
+        limit?: number;
+        cursor?: string | null;
+    }): Promise<Page<S['WebhookDelivery'], S['WebhookDeliveriesListResponse']>>;
+}
+declare class EllipsisWebhooks {
+    private readonly transport;
+    readonly deliveries: EllipsisWebhooksDeliveries;
+    constructor(transport: Transport);
+    /**
+     * Create Webhook
+     *
+     * Create a webhook and send a verification ping.
+     *
+     * Save the signing secret from this response; it is returned once.
+     * Accounts can have three webhooks, including unverified and pending
+     * ones. A ping returning HTTP 200 moves unverified to pending. Contact
+     * Ellipsis to activate it and receive session.create events.
+     */
+    create(options: {
+        description?: string | null;
+        events: ("session.create")[];
+        url: string;
+    }): Promise<S['CreateWebhookResponse']>;
+    /**
+     * Delete Webhook
+     *
+     * Delete a webhook and cancel outstanding deliveries.
+     *
+     * An HTTP request already in flight may finish. Delivery history remains
+     * available for 30 days. Deletion frees one of the account's three slots.
+     */
+    delete(webhook_id: string): Promise<void>;
+    /**
+     * Get Webhook
+     *
+     * Get a webhook's configuration and approval state.
+     */
+    get(webhook_id: string): Promise<S['WebhookResponse']>;
+    /**
+     * List Webhooks
+     *
+     * List your webhooks and their delivery summaries.
+     */
+    list(): Promise<S['WebhooksListResponse']>;
+    /**
+     * Ping Webhook
+     *
+     * Send a signed verification or test ping.
+     *
+     * Available in every state. Only HTTP 200 verifies a destination;
+     * successful pings never activate it. At most five pings per account
+     * per minute, including pings from creation and URL changes.
+     */
+    ping(webhook_id: string): Promise<void>;
+    /**
+     * Update Webhook
+     *
+     * Replace a webhook's configuration.
+     *
+     * Changing the URL cancels outstanding deliveries, clears verification
+     * and approval, and sends another ping. State and signing secret cannot
+     * be set here. Updating description or subscriptions preserves approval.
+     */
+    update(webhook_id: string, options: {
+        description?: string | null;
+        events: ("session.create")[];
+        url: string;
+    }): Promise<S['WebhookResponse']>;
+}
 declare class Ellipsis {
     private readonly transport;
+    readonly account: EllipsisAccount;
     readonly alerts: EllipsisAlerts;
     readonly analytics: EllipsisAnalytics;
     readonly auth: EllipsisAuth;
@@ -903,31 +2596,21 @@ declare class Ellipsis {
     readonly files: EllipsisFiles;
     readonly integrations: EllipsisIntegrations;
     readonly memories: EllipsisMemories;
-    readonly models: EllipsisModels;
     readonly reviews: EllipsisReviews;
+    readonly sandboxes: EllipsisSandboxes;
     readonly secrets: EllipsisSecrets;
     readonly sessions: EllipsisSessions;
-    readonly settings: EllipsisSettings;
+    readonly support: EllipsisSupport;
     readonly templates: EllipsisTemplates;
+    readonly user: EllipsisUser;
+    readonly webhooks: EllipsisWebhooks;
     constructor(options: TransportOptions);
-    /**
-     * Get Budget
-     *
-     * Return the caller's current budget summary.
-     */
-    budget(): Promise<S['BudgetSummary']>;
     /**
      * Current Identity
      *
      * Return the identity behind the caller's credential.
      */
-    me(): Promise<S['WhoAmIResponse']>;
-    /**
-     * Get Usage
-     *
-     * Return the caller's usage dashboard data.
-     */
-    usage(): Promise<S['GetUsageDashboardResponse']>;
+    identity(): Promise<S['Identity']>;
 }
 
 declare class EllipsisError extends Error {
@@ -962,4 +2645,4 @@ declare class RateLimitError extends APIError {
 declare class ServerError extends APIError {
 }
 
-export { APIError, AuthenticationError, ConflictError, DEFAULT_BASE_URL, Ellipsis, EllipsisError, ForbiddenError, NotFoundError, Page, RateLimitError, ServerError, SessionHandle, TERMINAL_STATUSES, Transport, TransportError, type TransportOptions, UnprocessableError, components, isSettled };
+export { APIError, AuthenticationError, type AutomationListStreamMessage, type CollectionStreamFrame, type CollectionStreamHeartbeat, ConflictError, DEFAULT_BASE_URL, Ellipsis, EllipsisError, ForbiddenError, NotFoundError, Page, RateLimitError, type SandboxSnapshotFrame, type SandboxUpdateFrame, ServerError, SessionHandle, type SessionListStreamMessage, TERMINAL_STATUSES, Transport, TransportError, type TransportOptions, UnprocessableError, components, isSettled };