@ellipsis-dev/sdk 0.27.0 → 0.30.0

package/dist/index.d.ts

@@ -1,5 +1,1241 @@
-import { c as components } from './types-ClEF_IA9.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-ClEF_IA9.js';
+import { c as components } from './types-DrPhhfOb.js';
+export { A as AgentConfig, a as AgentIdentity, b as AttributionType, B as BudgetConfig, C as ClaudeAssistantEvent, d as ClaudeAssistantMessage, e as ClaudeConfig, f as ClaudeConversationResetEvent, g as ClaudeNativeEvent, h as ClaudeNativeSessionRecord, i as ClaudeNativeUsage, j as ClaudeRateLimitEvent, k as ClaudeRateLimitInfo, l as ClaudeResultEvent, m as ClaudeSessionRecord, n as ClaudeSystemEvent, o as ClaudeUserEvent, p as ClaudeUserMessage, q as CodexAgentMessage, r as CodexAgentMessageItem, s as CodexAppServerError, t as CodexAppServerEvent, u as CodexAppServerItem, v as CodexAppServerNotification, w as CodexAppServerSessionRecord, x as CodexCommandExecution, y as CodexCommandExecutionItem, z as CodexConfig, D as CodexContextCompaction, E as CodexEffortLevel, F as CodexErrorEvent, G as CodexErrorItem, H as CodexErrorParams, I as CodexEvent, J as CodexFileChange, K as CodexFileChangeItem, L as CodexFileUpdate, M as CodexItem, N as CodexItemCompleted, O as CodexItemCompletedEvent, P as CodexItemParams, Q as CodexItemStarted, R as CodexItemStartedEvent, S as CodexItemUpdatedEvent, T as CodexLocalImageInput, U as CodexMcpToolCall, V as CodexMcpToolCallAppContext, W as CodexMcpToolCallError, X as CodexMcpToolCallItem, Y as CodexMcpToolCallResult, Z as CodexPlan, _ as CodexReasoning, $ as CodexReasoningItem, a0 as CodexSessionRecord, a1 as CodexTextInput, a2 as CodexThread, a3 as CodexThreadStarted, a4 as CodexThreadStartedEvent, a5 as CodexThreadStartedParams, a6 as CodexThreadTokenUsage, a7 as CodexTodoListItem, a8 as CodexTokenUsageBreakdown, a9 as CodexTokenUsageParams, aa as CodexTokenUsageUpdated, ab as CodexTurn, ac as CodexTurnCompleted, ad as CodexTurnCompletedEvent, ae as CodexTurnError, af as CodexTurnFailedEvent, ag as CodexTurnParams, ah as CodexTurnStarted, ai as CodexTurnStartedEvent, aj as CodexUsage, ak as CodexUserInput, al as CodexUserMessage, am as CodexWebSearch, an as CodexWebSearchItem, ao as ComputeConfig, ap as ComputeConfig1, aq as ConfigMetadata, ar as ConversationState, as as CreateReviewRequest, at as CronTrigger, au as DeltaFrame, av as DoneFrame, aw as Duration, ax as EffortLevel, ay as EllipsisGrant, az as EllipsisPermissions, aA as EnvironmentBaseBuild, aB as EnvironmentConfig, aC as EnvironmentHooks, aD as EnvironmentHooks1, aE as EnvironmentScript, aF as EnvironmentSource, aG as EnvironmentVariable, aH as ErrorFrame, aI as ExecutionResult, aJ as Finding, aK as GithubAccountFilter, aL as GithubAccountSelector, aM as GithubAccountSnippet, aN as GithubAccountType, aO as GithubIssueEvent, aP as GithubPermissions, aQ as GithubPullRequestEvent, aR as GithubPushEvent, aS as HandlerService, aT as HeartbeatFrame, aU as InputContract, aV as IssueAction, aW as LegacyAssistantPayload, aX as LegacyNativeUsage, aY as LegacyResultPayload, aZ as Level, a_ as LifecycleSessionRecord, a$ as LinearIssueAction, b0 as LinearIssueEvent, b1 as McpRemoteServer, b2 as McpServerRef, b3 as McpStdioServer, b4 as MemorySize, b5 as MessageDeliveredPayload, b6 as MessageDeliveredRecord, b7 as MessageReceivedPayload, b8 as MessageReceivedRecord, b9 as MessageRequeuedPayload, ba as MessageRequeuedRecord, bb as OutboxCollectedPayload, bc as OutboxCollectedRecord, bd as OutputConfig, be as PermissionsConfig, bf as PermissionsConfig1, bg as PlatformSessionRecord, bh as PromptBlockedReason, bi as PullRequestAction, bj as ReactIssue, bk as ReactLinearIssue, bl as ReactPullRequest, bm as ReactPush, bn as ReactSentry, bo as ReactSlackChannel, bp as ReactTrigger, bq as RecordsAppendFrame, br as RepositoryFilter, bs as RepositoryRef, bt as ResolvedReviewScope, bu as Review, bv as ReviewConfiguration, bw as ReviewCounters, bx as ReviewFinding, by as ReviewRequester, bz as ReviewScope, bA as ReviewScopeKind, bB as ReviewStage, bC as ReviewedCommit, bD as ReviewsListResponse, bE as SandboxOutputPayload, bF as SandboxOutputRecord, bG as SandboxPhasePayload, bH as SandboxPhaseRecord, bI as SandboxReadyPayload, bJ as SandboxReadyRecord, bK as SandboxStartingPayload, bL as SandboxStartingRecord, bM as SdkAssistantRecord, bN as SdkCacheCreation, bO as SdkContentBlock, bP as SdkRateLimitRecord, bQ as SdkRecord, bR as SdkResultRecord, bS as SdkServerToolResultBlock, bT as SdkServerToolUseBlock, bU as SdkSystemRecord, bV as SdkTextBlock, bW as SdkThinkingBlock, bX as SdkToolResultBlock, bY as SdkToolUseBlock, bZ as SdkUserRecord, b_ as SendSessionMessageRequest, b$ as SentryAction, c0 as SentryAlertEvent, c1 as Session, c2 as Session1, c3 as SessionAgent, c4 as SessionArchived, c5 as SessionAttribution, c6 as SessionCancelledPayload, c7 as SessionCancelledRecord, c8 as SessionClosedPayload, c9 as SessionClosedRecord, ca as SessionConfig, cb as SessionCost, cc as SessionEnvironment, cd as SessionEventActor, ce as SessionExecution, cf as SessionExecutionResult, cg as SessionExecutionsListResponse, ch as SessionExitStatus, ci as SessionFrame, cj as SessionGit, ck as SessionGitCommit, cl as SessionGitFile, cm as SessionGitPr, cn as SessionGitRepo, co as SessionHandler, cp as SessionIdlePayload, cq as SessionIdleRecord, cr as SessionLifecycle, cs as SessionLifecycleStatus, ct as SessionMessage, cu as SessionMessageImage, cv as SessionMessageResponse, cw as SessionMessageStatus, cx as SessionParent, cy as SessionPrompting, cz as SessionRecord, cA as SessionRecordsListResponse, cB as SessionResponse, cC as SessionResumedPayload, cD as SessionResumedRecord, cE as SessionRetryingPayload, cF as SessionRetryingRecord, cG as SessionScheduledPayload, cH as SessionScheduledRecord, cI as SessionSource, cJ as SessionStartingPayload, cK as SessionStartingRecord, cL as SessionStopped, cM as SessionStreamFrame, cN as SessionSummary, cO as SessionTimestamps, cP as SessionTokens, cQ as SessionsListResponse, cR as SettingsRef, cS as SkillRef, cT as SlackChannelCreatedEvent, cU as SlackMessageEvent, cV as SnapshotFrame, cW as StreamFrame, cX as TokensInfo, cY as TurnCompletedPayload, cZ as TurnCompletedRecord, c_ as TurnFailedPayload, c$ as TurnFailedRecord, d0 as TurnStartedPayload, d1 as TurnStartedRecord, d2 as UnknownSessionRecord, d3 as UpdateSessionRequest, d4 as paths } from './types-DrPhhfOb.js';
+
+/**
+ * Frames on /v1/sessions/stream, /v1/agents/stream and /v1/vm-executions/{id}/stream. Ignore unknown frame types.
+ */
+type CollectionStreamFrame = SessionListStreamMessage | AgentListStreamMessage | CollectionStreamHeartbeat | SandboxSnapshotFrame | SandboxUpdateFrame;
+/**
+ * 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.
+ */
+type Session = {
+    /**
+     * The agent the session was started from, or null for a raw session started with POST /v1/sessions.
+     */
+    agent: SessionAgent | null;
+    attribution: SessionAttribution;
+    /**
+     * The spend budget enforced for this session, in US dollars, after resolving defaults and ceilings.
+     */
+    budget: number;
+    /**
+     * Claude Code input and native options. Set exactly one of claude_code or codex.
+     */
+    claude_code: ClaudeConfig | null;
+    /**
+     * Codex input and native options. Set exactly one of claude_code or codex.
+     */
+    codex: CodexConfig | null;
+    cost: SessionCost;
+    environment: SessionEnvironment;
+    /**
+     * The typed external event that started the session; null for direct and scheduled starts.
+     */
+    event: (GithubPullRequestEvent | GithubIssueEvent | GithubPushEvent | LinearIssueEvent | SlackMessageEvent | SlackChannelCreatedEvent | SentryAlertEvent) | 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;
+    /**
+     * The saved handler and its effective display name when this session started, frozen at creation. Null for built-in responders, legacy sessions, and sessions started without a handler.
+     */
+    handler: SessionHandler | null;
+    /**
+     * Unique identifier of the session.
+     */
+    id: string;
+    lifecycle: SessionLifecycle;
+    /**
+     * Caller-supplied metadata key-value pairs.
+     */
+    metadata: {
+        [k: string]: string;
+    };
+    /**
+     * The structured-output exit contract for this session.
+     */
+    output: OutputConfig | null;
+    /**
+     * The predecessor session this session continues; null when there is none.
+     */
+    parent: SessionParent | null;
+    permissions: PermissionsConfig1;
+    /**
+     * Skills installed for this session.
+     */
+    skills: SkillRef[];
+    source: SessionSource;
+    /**
+     * The latest live summary of the session's progress while it runs, and when it was generated.
+     */
+    summary: SessionSummary | null;
+    tokens: SessionTokens;
+} & ({
+    claude_code: {
+        [k: string]: unknown;
+    };
+    codex: null;
+} | {
+    claude_code: null;
+    codex: {
+        [k: string]: unknown;
+    };
+});
+/**
+ * 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 (`sessions.session_config`); an agent
+ * carries one under `session:` (`AgentConfig.session`); and
+ * `POST /v1/sessions` is this shape flattened onto the request body, plus the
+ * run settings. Nothing in here is an agent's identity or trigger —
+ * those belong to `AgentConfig`.
+ *
+ * Field order is the canonical key order for `session:` blocks and YAML
+ * exports: what runs (`claude_code` or `codex`), where (`environment`), what it may
+ * touch (`permissions`), then the rest.
+ */
+type SessionConfig = {
+    budget: BudgetConfig;
+    /**
+     * Claude Code input and native options. Set exactly one of claude_code or codex.
+     */
+    claude_code: ClaudeConfig | null;
+    /**
+     * Codex input and native options. Set exactly one of claude_code or codex.
+     */
+    codex: CodexConfig | null;
+    environment: string | EnvironmentConfig;
+    output: OutputConfig | null;
+    permissions: PermissionsConfig;
+    skills: SkillRef[];
+} & ({
+    claude_code: {
+        [k: string]: unknown;
+    };
+    codex: null;
+} | {
+    claude_code: null;
+    codex: {
+        [k: string]: unknown;
+    };
+});
+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';
+type AttributionType = 'github_user' | 'linear_user' | 'slack_user' | 'api_key';
+type GithubAccountType = 'User' | 'Organization' | 'Bot' | 'Mannequin';
+/**
+ * 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' | 'agent' | 'repo_default' | 'account_default' | 'platform_default';
+/**
+ * The service the handler responds to.
+ */
+type HandlerService = 'slack' | 'github' | 'linear' | 'sentry';
+/**
+ * Whether the conversation is open or permanently closed. Open does not imply direct messages are permitted.
+ */
+type ConversationState = 'open' | 'closed';
+/**
+ * Why the last execution ended; completed also includes parking an open conversation.
+ */
+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';
+/**
+ * Why direct prompting is refused. Absent when prompting is allowed.
+ */
+type PromptBlockedReason = 'mention_surface' | 'ephemeral_trigger' | 'non_interactive' | 'harness_single_turn' | 'closed';
+/**
+ * Canonical current activity. working means a turn is in progress; waiting means the worker is warm and awaiting input; idle means parked. A failed, stopped, or cancelled execution may leave an open conversation.
+ */
+type SessionLifecycleStatus = 'scheduled' | 'starting' | 'working' | 'waiting' | 'retrying' | 'idle' | 'closed' | 'failed' | 'stopped' | 'cancelled';
+/**
+ * Where the session came from (e.g. react, web, api, cli, mention, cron).
+ */
+type SessionSource = 'react' | 'web' | 'api' | 'cli' | 'mention' | 'cron';
+/**
+ * Which writer owns this agent. "github" agents are defined by a file in a repository and are changed by editing that file; "api" agents 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' | 'session' | 'image_refresh' | 'test' | 'script';
+type SandboxStatus = 'scheduled' | 'building' | 'running' | 'released' | 'terminating' | 'terminated' | 'failed';
+type SandboxType = 'claude_code';
+interface SessionListStreamMessage {
+    session: Session;
+    type: 'session';
+}
+/**
+ * The agent this session was started from: the definition frozen
+ * when the session was created, and the saved agent 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 SessionAgent {
+    config: AgentConfig;
+    /**
+     * Identifier of the saved agent 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 agent behind them. Points at the agent as it exists now, which may have changed since.
+     */
+    id: string | null;
+}
+/**
+ * The agent definition the session was started from, frozen when the session was created.
+ */
+interface AgentConfig {
+    ellipsis: AgentIdentity;
+    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 agent (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 AgentIdentity {
+    description: string | null;
+    enabled: boolean;
+    kind: 'agent';
+    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` validates customer data sent as `input` to
+ * `POST /v1/agents/{id}/sessions` and stored as `session.input`.
+ * Invocations require input when a schema is declared. React agents
+ * cannot declare schemas: the platform defines their event payloads.
+ *
+ * `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 AgentConfig's
+ * `_check_input`).
+ */
+interface InputContract {
+    json_schema: {
+        [k: string]: unknown;
+    } | null;
+    message: string | null;
+}
+interface BudgetConfig {
+    day: number | null;
+    month: number | null;
+    session: number | null;
+    week: number | 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;
+    /**
+     * The initial user message, passed verbatim. Omit to start an interactive session idle.
+     */
+    prompt: string | null;
+    settings: SettingsRef | null;
+}
+/**
+ * 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;
+}
+interface RepositoryRef {
+    name: string;
+    owner: string | null;
+    ref: string | 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;
+    /**
+     * The initial user message, passed verbatim. Omit to start an interactive session idle.
+     */
+    prompt: string | 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, 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;
+    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/vms/vm_execution.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;
+}
+/**
+ * Environment lifecycle scripts, in order: build_base, after_checkout,
+ * before_start. The first two produce reusable snapshots; before_start runs
+ * before an agent starts or resumes its session. Scripts run as the sandbox
+ * user in /sandbox. A nonzero exit fails the session.
+ *
+ * Legacy post_start/post_clone scripts remain supported for existing configs;
+ * both run after workspace preparation, before the agent starts or resumes.
+ * They cannot be combined with the new lifecycle fields.
+ */
+interface EnvironmentHooks {
+    /**
+     * Prepare the requested source revision after Ellipsis checks out all repositories, before saving the prepared sandbox. Skipped when that prepared sandbox is reused.
+     */
+    after_checkout: EnvironmentScript | string | null;
+    /**
+     * Run before the agent starts or resumes a session, after the sandbox is ready. This hook is not cached and adds to session startup time.
+     */
+    before_start: EnvironmentScript | string | null;
+    /**
+     * Build a reusable environment before full checkout. Cached by declared inputs, script, toolchain, resources, and build configuration. A string is shorthand for run with all repositories as inputs.
+     */
+    build_base: EnvironmentBaseBuild | string | null;
+    /**
+     * Legacy session startup script. Use before_start for session setup or after_checkout for cached source preparation.
+     */
+    post_clone: string | null;
+    /**
+     * Legacy session startup script. Use before_start in new configurations.
+     */
+    post_start: string | null;
+}
+/**
+ * An inline shell script run as the sandbox user, with /sandbox as cwd.
+ */
+interface EnvironmentScript {
+    /**
+     * Shell script to run in /sandbox.
+     */
+    run: string;
+}
+/**
+ * Create a reusable base, optionally using only selected repository files.
+ */
+interface EnvironmentBaseBuild {
+    /**
+     * Exact files relative to /sandbox, including the repository name. Only these files are available during build_base and their contents and modes determine reuse. Omit to use all repositories and invalidate on any source change; [] means no repository files.
+     */
+    inputs: string[] | null;
+    /**
+     * Shell script to run in /sandbox.
+     */
+    run: string;
+}
+/**
+ * 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 `hooks.build_base` /
+ * `hooks.after_checkout` if the managed environment 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;
+}
+/**
+ * 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;
+}
+/**
+ * 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 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;
+}
+/**
+ * What the session cost, in millicents, broken down by leg and carrying its own total.
+ */
+interface SessionCost {
+    /**
+     * Sandbox CPU spend in millicents.
+     */
+    cpu: number;
+    /**
+     * Platform fee in millicents.
+     */
+    fee: number;
+    /**
+     * LLM spend in millicents.
+     */
+    llm: number;
+    /**
+     * Sandbox memory spend in millicents.
+     */
+    memory: number;
+    /**
+     * The grand total in millicents: llm + cpu + memory + fee.
+     */
+    total: number;
+}
+/**
+ * The full environment configuration frozen when the session was created, with the saved environment's id and how it was chosen.
+ */
+interface SessionEnvironment {
+    compute: ComputeConfig1;
+    hooks: EnvironmentHooks1;
+    /**
+     * Identifier of the saved environment the session's config resolved. Null for an inline environment block or the built-in basic sandbox.
+     */
+    id: string | null;
+    mcp_servers: (string | McpServerRef | McpStdioServer | McpRemoteServer)[];
+    repositories: RepositoryRef[];
+    /**
+     * How the environment was chosen (request, agent, platform_default; repo_default and account_default on sessions from before those ladders were removed). An inline request uses request; an inline environment declared in session configuration has no source.
+     */
+    source: EnvironmentSource | null;
+    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/vms/vm_execution.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 ComputeConfig1 {
+    cpu: number | null;
+    memory: string | MemorySize | null;
+    timeout: string | Duration | null;
+}
+/**
+ * Environment lifecycle scripts, in order: build_base, after_checkout,
+ * before_start. The first two produce reusable snapshots; before_start runs
+ * before an agent starts or resumes its session. Scripts run as the sandbox
+ * user in /sandbox. A nonzero exit fails the session.
+ *
+ * Legacy post_start/post_clone scripts remain supported for existing configs;
+ * both run after workspace preparation, before the agent starts or resumes.
+ * They cannot be combined with the new lifecycle fields.
+ */
+interface EnvironmentHooks1 {
+    /**
+     * Prepare the requested source revision after Ellipsis checks out all repositories, before saving the prepared sandbox. Skipped when that prepared sandbox is reused.
+     */
+    after_checkout: EnvironmentScript | string | null;
+    /**
+     * Run before the agent starts or resumes a session, after the sandbox is ready. This hook is not cached and adds to session startup time.
+     */
+    before_start: EnvironmentScript | string | null;
+    /**
+     * Build a reusable environment before full checkout. Cached by declared inputs, script, toolchain, resources, and build configuration. A string is shorthand for run with all repositories as inputs.
+     */
+    build_base: EnvironmentBaseBuild | string | null;
+    /**
+     * Legacy session startup script. Use before_start for session setup or after_checkout for cached source preparation.
+     */
+    post_clone: string | null;
+    /**
+     * Legacy session startup script. Use before_start in new configurations.
+     */
+    post_start: string | null;
+}
+interface GithubPullRequestEvent {
+    action: PullRequestAction | 'review_commented';
+    actor: SessionEventActor | null;
+    branch: string;
+    number: number;
+    repository: string;
+    title: string;
+    type: 'github.pull_request';
+    url: string;
+}
+/**
+ * The event's initiator, when known; never inferred from resource ownership.
+ */
+interface SessionEventActor {
+    avatar_url: string | null;
+    is_bot: boolean | null;
+    name: string;
+}
+interface GithubIssueEvent {
+    action: IssueAction;
+    actor: SessionEventActor | null;
+    number: number;
+    repository: string;
+    title: string;
+    type: 'github.issue';
+    url: string;
+}
+interface GithubPushEvent {
+    actor: SessionEventActor | null;
+    after: string;
+    before: string;
+    branch: string;
+    repository: string;
+    type: 'github.push';
+    url: string;
+}
+interface LinearIssueEvent {
+    action: LinearIssueAction | 'commented';
+    actor: SessionEventActor | null;
+    identifier: string | null;
+    number: number;
+    title: string;
+    type: 'linear.issue';
+    url: string;
+}
+interface SlackMessageEvent {
+    action: 'message' | 'app_mention';
+    actor: SessionEventActor | null;
+    channel_id: string;
+    channel_name: string | null;
+    message_ts: string;
+    thread_ts: string | null;
+    type: 'slack.message';
+    url: string;
+}
+interface SlackChannelCreatedEvent {
+    actor: SessionEventActor | null;
+    channel_id: string;
+    channel_name: string | null;
+    type: 'slack.channel_created';
+    url: string;
+}
+interface SentryAlertEvent {
+    action: SentryAction;
+    actor: SessionEventActor | null;
+    organization_slug: string;
+    project_slug: string | null;
+    title: string | null;
+    type: 'sentry.alert';
+    url: string | null;
+}
+/**
+ * Every repo the session touched. Small enough to ride on `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;
+}
+/**
+ * The saved handler and its display name when the session started.
+ */
+interface SessionHandler {
+    /**
+     * The handler's effective display name when the session started: ellipsis.name, or the service default (Slack, GitHub, Linear, or sentry).
+     */
+    agent_name: string;
+    /**
+     * Identifier of the saved handler.
+     */
+    id: string;
+    service: HandlerService;
+    /**
+     * Content fingerprint of the validated handler configuration used when the session started. This is not the Git commit SHA.
+     */
+    sha: string;
+}
+/**
+ * The session's activity, conversation state, messaging policy, outcomes, and timestamps.
+ */
+interface SessionLifecycle {
+    /**
+     * When and by whom the session was archived; null when unarchived. Archiving does not stop or close a session.
+     */
+    archived: SessionArchived | null;
+    conversation: ConversationState;
+    /**
+     * Explanation of the current status, when applicable.
+     */
+    detail: string | null;
+    /**
+     * Whether the session stays open after its first turn.
+     */
+    interactive: boolean;
+    /**
+     * The last finished execution's outcome, retained across resumes; null until an outcome has been recorded.
+     */
+    last_execution_result: SessionExecutionResult | null;
+    prompting: SessionPrompting;
+    status: SessionLifecycleStatus;
+    /**
+     * When and by whom a stop was requested; null when no stop is pending for this execution.
+     */
+    stopped: SessionStopped | null;
+    timestamps: SessionTimestamps;
+}
+/**
+ * When the session was archived and the GitHub user who archived it.
+ */
+interface SessionArchived {
+    /**
+     * When the session was archived.
+     */
+    at: string;
+    /**
+     * The GitHub user who archived the session; null if unknown or unavailable.
+     */
+    by: GithubAccountSnippet | null;
+}
+/**
+ * Outcome of the last finished execution, retained across subsequent resumes.
+ *
+ * An execution spans a start or resume through parking or termination, and may
+ * contain several turns. Admission failures also produce a result, even when
+ * provisioning never starts.
+ */
+interface SessionExecutionResult {
+    completion_reason: SessionExitStatus;
+    /**
+     * Human-readable explanation of that outcome.
+     */
+    detail: string | null;
+}
+/**
+ * The session's policy for direct messages. Caller authorization and message validation are checked separately.
+ */
+interface SessionPrompting {
+    blocked_reason: PromptBlockedReason | null;
+    detail: string | null;
+    enabled: boolean;
+    surface_name: string | null;
+}
+/**
+ * When a stop was requested and the GitHub user who requested it.
+ */
+interface SessionStopped {
+    /**
+     * When a stop was requested.
+     */
+    at: string;
+    /**
+     * The GitHub user who stopped the session, resolved at read time. Null if the user is unknown or unavailable.
+     */
+    by: GithubAccountSnippet | null;
+}
+interface SessionTimestamps {
+    /**
+     * When the session was created.
+     */
+    created_at: string;
+    /**
+     * When the session last showed agent activity.
+     */
+    last_activity_at: string | null;
+    /**
+     * When the session last received a message.
+     */
+    last_message_at: string | null;
+    /**
+     * When the session was last updated.
+     */
+    updated_at: string;
+}
+/**
+ * The predecessor session this session continues.
+ */
+interface SessionParent {
+    /**
+     * Identifier of the predecessor session this session continues, if any.
+     */
+    session_id: string | null;
+}
+/**
+ * What the session may touch, per minted credential.
+ */
+interface PermissionsConfig1 {
+    ellipsis: (true | 'all') | EllipsisPermissions;
+    github: GithubPermissions;
+}
+/**
+ * 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 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;
+}
+interface AgentListStreamMessage {
+    agents: Agent[];
+    type: 'agents';
+}
+/**
+ * An agent: a saved agent definition that runs on its trigger or
+ * when invoked, plus where it syncs from and the state of that sync.
+ */
+interface Agent {
+    config: AgentConfig1;
+    /**
+     * When the agent 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 agent, when the edit came from a known user.
+     */
+    edited_by: GithubAccountSnippet | null;
+    /**
+     * Unique identifier of the agent.
+     */
+    id: string;
+    /**
+     * When that most recent session was created.
+     */
+    last_session_created_at: string | null;
+    /**
+     * The most recent session this agent 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 agent is not running the YAML currently on the branch.
+     */
+    last_sync_error: string | null;
+    /**
+     * The last commit the agent was synced from.
+     */
+    last_synced_commit_sha: string | null;
+    managed_by: ConfigManagedBy;
+    /**
+     * The agent's account-unique addressable name (a slug of its display name); usable anywhere an agent is referenced, interchangeably with the id.
+     */
+    name: string | null;
+    /**
+     * The open pull request that adds this agent's file. Non-null means the agent 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 agent syncs from. Null only transiently, before the creating pull request's file lands on the branch.
+     */
+    source_details: GithubSourceDetails | null;
+    /**
+     * When the agent was last updated.
+     */
+    updated_at: string;
+}
+/**
+ * The agent definition itself, in the same schema as its YAML file: identity, trigger, input contract, and the session block.
+ */
+interface AgentConfig1 {
+    ellipsis: AgentIdentity;
+    input: InputContract | null;
+    session: SessionConfig;
+    trigger: (CronTrigger | ReactTrigger) | null;
+}
+/**
+ * Identifies the file a GitHub-sourced agent 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: VMExecutionResponse;
+    type: 'snapshot';
+}
+interface VMExecutionResponse {
+    cache_tier: SandboxCacheTier | null;
+    cost_sandbox_cpu: number;
+    cost_sandbox_memory: number;
+    cpu: number;
+    encrypted_ports: number[];
+    environment_variable_keys: string[];
+    failed_at: string | null;
+    hooks: EnvironmentHooks2;
+    id: string;
+    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[];
+}
+/**
+ * Environment lifecycle scripts, in order: build_base, after_checkout,
+ * before_start. The first two produce reusable snapshots; before_start runs
+ * before an agent starts or resumes its session. Scripts run as the sandbox
+ * user in /sandbox. A nonzero exit fails the session.
+ *
+ * Legacy post_start/post_clone scripts remain supported for existing configs;
+ * both run after workspace preparation, before the agent starts or resumes.
+ * They cannot be combined with the new lifecycle fields.
+ */
+interface EnvironmentHooks2 {
+    /**
+     * Prepare the requested source revision after Ellipsis checks out all repositories, before saving the prepared sandbox. Skipped when that prepared sandbox is reused.
+     */
+    after_checkout: EnvironmentScript | string | null;
+    /**
+     * Run before the agent starts or resumes a session, after the sandbox is ready. This hook is not cached and adds to session startup time.
+     */
+    before_start: EnvironmentScript | string | null;
+    /**
+     * Build a reusable environment before full checkout. Cached by declared inputs, script, toolchain, resources, and build configuration. A string is shorthand for run with all repositories as inputs.
+     */
+    build_base: EnvironmentBaseBuild | string | null;
+    /**
+     * Legacy session startup script. Use before_start for session setup or after_checkout for cached source preparation.
+     */
+    post_clone: string | null;
+    /**
+     * Legacy session startup script. Use before_start in new configurations.
+     */
+    post_start: string | null;
+}
+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: VMExecutionResponse;
+    type: 'sandbox';
+}
 
 interface CursorResponse {
     has_more: boolean;
@@ -31,46 +1267,798 @@ interface SessionsApi {
         limit?: number;
     }): 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?: {
-        images?: S$1['ImageAttachment'][];
-        idempotencyKey?: string;
-    }): Promise<S$1['SessionMessage']>;
-    stop(): Promise<S$1['Session']>;
+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?: {
+        images?: S$1['ImageAttachment'][];
+        idempotencyKey?: 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 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.
+     *
+     * Required permissions: write:tokens.
+     * API key: Requires a CLI user token belonging to an account administrator.
+     * CLI user token: Requires an account administrator.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    create(options: {
+        name: string;
+    }): Promise<S['CreateApiKeyResponse']>;
+    /**
+     * List Api Keys
+     *
+     * Required permissions: read:tokens.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    list(): Promise<S['ListApiKeysResponse']>;
+    /**
+     * Revoke Api Key
+     *
+     * Revoke an organization key as a verified GitHub administrator.
+     *
+     * Required permissions: delete:tokens.
+     * API key: Requires a CLI user token belonging to an account administrator.
+     * CLI user token: Requires an account administrator.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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.
+     *
+     * Required permissions: read:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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.
+     *
+     * Required permissions: write:account.
+     * API key: Requires a CLI user token belonging to an account administrator.
+     * CLI user token: Requires an account administrator.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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.
+     *
+     * Required permissions: write:account.
+     * API key: Requires a CLI user token belonging to an account administrator.
+     * CLI user token: Requires an account administrator.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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.
+     *
+     * Required permissions: write:account.
+     * API key: Requires a CLI user token belonging to an account administrator.
+     * CLI user token: Requires an account administrator.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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.
+     *
+     * Required permissions: write:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    claimSignupCredit(): Promise<S['BillingStatus']>;
+    /**
+     * Get Fee Schedule
+     *
+     * Get the account's rate card, in US dollars.
+     *
+     * Required permissions: read:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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.
+     *
+     * Required permissions: read:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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.
+     *
+     * Required permissions: read:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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.
+     *
+     * Required permissions: read:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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.
+     *
+     * Required permissions: read:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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.
+     *
+     * Required permissions: read:templates.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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.
+     *
+     * Required permissions: write:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    testEmail(options: {
+        email: string;
+    }): Promise<S['AccountActionResponse']>;
+}
+declare class EllipsisAccountOnboarding {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * Get Account Onboarding
+     *
+     * Read the account's saved onboarding answers, or null before setup.
+     *
+     * Required permissions: read:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    get(): Promise<S['AccountOnboardingResponse']>;
+    /**
+     * Update Account Onboarding
+     *
+     * Save supplied onboarding answers, preserving omitted answers.
+     *
+     * Organizations can save their work email before selecting use cases.
+     * Saving use cases requires a valid organization work email and at
+     * least one choice. When Other is the only choice, describe it.
+     * Personal accounts save a null work email. This does not change the
+     * billing contact email. Sandbox credentials cannot update answers.
+     * Supplying an organization work email requires a human user and sends
+     * a Slack Connect invitation. Slack failures do not undo saved answers.
+     *
+     * Required permissions: write:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    update(options?: {
+        other_use_case?: string | null;
+        use_cases?: (S['AccountOnboardingUseCase'])[];
+        work_email?: string | null;
+    }): Promise<S['AccountOnboardingResponse']>;
+}
+declare class EllipsisAccountProvidersAnthropic {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * Delete Anthropic Config
+     *
+     * Required permissions: delete:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    delete(): Promise<void>;
+    /**
+     * Get Anthropic Config
+     *
+     * Required permissions: read:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    get(): Promise<S['AnthropicConfigResponse']>;
+    /**
+     * Put Anthropic Config
+     *
+     * Required permissions: write:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    set(options: {
+        api_key: string;
+    }): Promise<S['AnthropicConfigResponse']>;
+    /**
+     * Validate Anthropic Config
+     *
+     * Required permissions: write:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    validate(): Promise<S['ValidateAnthropicConfigResponse']>;
+}
+declare class EllipsisAccountProvidersBedrock {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * Delete Bedrock Config
+     *
+     * Required permissions: delete:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    delete(): Promise<void>;
+    /**
+     * Get Bedrock Config
+     *
+     * Required permissions: read:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    get(): Promise<S['BedrockConfigResponse']>;
+    /**
+     * Put Bedrock Config
+     *
+     * Required permissions: write:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    set(options: {
+        model_map: Record<string, string>;
+        region: string;
+        role_arn: string;
+    }): Promise<S['BedrockConfigResponse']>;
+    /**
+     * Validate Bedrock Config
+     *
+     * Required permissions: write:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    validate(): Promise<S['ValidateBedrockConfigResponse']>;
+}
+declare class EllipsisAccountProviders {
+    private readonly transport;
+    readonly anthropic: EllipsisAccountProvidersAnthropic;
+    readonly bedrock: EllipsisAccountProvidersBedrock;
+    constructor(transport: Transport);
 }
-
-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 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.
+     *
+     * Required permissions: read:defaults.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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).
+     *
+     * Required permissions: write:defaults.
+     * API key: Requires a CLI user token belonging to an account administrator.
+     * CLI user token: Requires an account administrator.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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.
+     *
+     * Required permissions: write:defaults.
+     * API key: Cannot set budget_ceiling, default_model to a non-null value; those changes require a CLI user token belonging to an account administrator.
+     * CLI user token: Requires an account administrator when setting budget_ceiling, default_model to a non-null value.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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;
+        notifications?: S['NotificationSettings'] | null;
+    }): Promise<S['AccountSettings']>;
 }
-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>;
+declare class EllipsisAccount {
+    private readonly transport;
+    readonly apiKeys: EllipsisAccountApiKeys;
+    readonly billing: EllipsisAccountBilling;
+    readonly models: EllipsisAccountModels;
+    readonly notifications: EllipsisAccountNotifications;
+    readonly onboarding: EllipsisAccountOnboarding;
+    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.
+     *
+     * Required permissions: read:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    activity(): Promise<S['AccountActivity']>;
+    /**
+     * Get Customer Audit Log
+     *
+     * Required permissions: read:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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; concurrent paid requests are limited
+     * by your account and per-session allowances.
+     *
+     * Required permissions: read:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    budget(): Promise<S['BudgetSummary']>;
+    /**
+     * Update Customer
+     *
+     * Required permissions: write:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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.
+     *
+     * Required permissions: write:defaults.
+     * API key: Requires a CLI user token belonging to an account administrator.
+     * CLI user token: Requires an account administrator.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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.
+     *
+     * Required permissions: read:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    usage(options?: {
+        period_start?: string | null;
+    }): Promise<S['GetUsageOverTimeResponse']>;
+}
+declare class EllipsisAgents {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * Create Agent
+     *
+     * Create an agent, managed through the API: no file, live
+     * immediately. To put its definition in a repository instead, create
+     * it here and then POST /v1/agents/{agent_id}/link.
+     *
+     * 409 when another live agent already holds the name.
+     *
+     * Required permissions: write:configs.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
+     */
+    create(options: {
+        agent: S['AgentConfig-Input'];
+    }): Promise<S['AgentResponse']>;
+    /**
+     * Delete Agent
+     *
+     * Delete an agent, by id or by name.
+     *
+     * It stops running and its name is freed immediately; its past
+     * sessions remain readable. Only for agents managed through
+     * this API — delete the file to remove one defined by a repository.
+     *
+     * Required permissions: write:configs.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
+     */
+    delete(agent_id: string): Promise<void>;
+    /**
+     * Get Agent
+     *
+     * Return one agent, by id or by name.
+     *
+     * Required permissions: read:configs.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
+     */
+    get(agent_id: string): Promise<S['AgentResponse']>;
+    /**
+     * Link Agent
+     *
+     * Move an agent into a repository, by id or by name.
+     *
+     * Opens a pull request adding its definition file. The agent
+     * keeps running unchanged meanwhile; merging hands it over to the
+     * file, after which the file is what changes it. Nothing happens
+     * if the pull request is never merged.
+     *
+     * Required permissions: write:configs.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
+     */
+    link(agent_id: string, options: {
+        path?: string | null;
+        repository: string;
+    }): Promise<S['LinkAgentResponse']>;
+    /**
+     * List Agents
+     *
+     * List agents.
+     *
+     * Required permissions: read:configs.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
+     */
+    list(): Promise<S['AgentsListResponse']>;
+    /**
+     * Get Agent Metrics
+     *
+     * Return an agent's session distribution and trailing spend,
+     * by id or by name.
+     *
+     * `samples` carries one entry per finished session (duration, cost,
+     * tokens) for distributions; `spend_windows` carries what the
+     * agent's sessions cost over the last 1, 7, and 28 days against
+     * its budget for each window.
+     *
+     * Required permissions: read:configs.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
+     */
+    metrics(agent_id: string): Promise<S['AgentMetricsResponse']>;
+    /**
+     * Start Agent Session
+     *
+     * Invoke an agent.
+     *
+     * Runs a certified agent 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 agent 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.
+     *
+     * Required permissions: write:sessions.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
+     */
+    run(agent_id: string, options?: {
+        budget?: number | null;
+        input?: Record<string, unknown> | null;
+        metadata?: Record<string, string>;
+        prompt?: string | null;
+    }): Promise<S['SessionResponse']>;
+    /**
+     * Get Agents Stream Ticket
+     *
+     * Required permissions: read:configs.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
+     */
+    streamTicket(): Promise<S['StreamTicketResponse']>;
+    /**
+     * Unlink Agent
+     *
+     * Take over an agent from its file, by id or by name.
+     *
+     * The file stops governing it immediately and further changes go
+     * through this API. The file is left in place, inert — delete it
+     * whenever you like.
+     *
+     * Required permissions: write:configs.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
+     */
+    unlink(agent_id: string): Promise<S['AgentResponse']>;
+    /**
+     * Update Agent
+     *
+     * Replace an agent's definition, by id or by name.
+     *
+     * The whole definition is replaced, and the change is live at
+     * once. Only for agents managed through this API: one defined
+     * by a repository file is a 409, since the next push to that file
+     * would revert the change — unlink it first to take ownership.
+     *
+     * Required permissions: write:configs.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
+     */
+    update(agent_id: string, options: {
+        agent: S['AgentConfig-Input'];
+    }): Promise<S['AgentResponse']>;
 }
-
-type S = components['schemas'];
 declare class EllipsisAlerts {
     private readonly transport;
     constructor(transport: Transport);
@@ -80,6 +2068,12 @@ declare class EllipsisAlerts {
      * Dismiss an open alert and return it.
      *
      * 409 when the alert is not open; 404 when it doesn't exist.
+     *
+     * Required permissions: write:alerts.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
      */
     dismiss(alert_id: string): Promise<S['AlertResponse']>;
     /**
@@ -88,6 +2082,12 @@ declare class EllipsisAlerts {
      * Return one alert by id.
      *
      * 404 if it doesn't exist or belongs to another organization.
+     *
+     * Required permissions: read:alerts.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
      */
     get(alert_id: string): Promise<S['AlertResponse']>;
     /**
@@ -99,6 +2099,12 @@ declare class EllipsisAlerts {
      *
      * Available to all credential types, so an agent can check "is
      * this org near budget?" mid-task.
+     *
+     * Required permissions: read:alerts.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
      */
     list(options?: {
         status?: S['AlertStatus'] | null;
@@ -122,6 +2128,12 @@ declare class EllipsisAnalytics {
      * the apps/agents). Available to all credential types: the
      * responses expose the organization's own GitHub PR/review activity,
      * no secrets.
+     *
+     * Required permissions: read:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
      */
     metrics(options?: {
         days?: number | null;
@@ -139,6 +2151,12 @@ declare class EllipsisAnalytics {
      *
      * Windowing: pass explicit start/end, or days (default: the last
      * 30 days). account_type in all|user|bot scopes the authors.
+     *
+     * Required permissions: read:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
      */
     pullRequests(options?: {
         days?: number | null;
@@ -158,6 +2176,12 @@ declare class EllipsisAnalytics {
      * 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).
+     *
+     * Required permissions: read:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
      */
     reviews(options?: {
         days?: number | null;
@@ -178,6 +2202,8 @@ declare class EllipsisAuthCli {
      * Poll a device-code auth flow for its token.
      *
      * Unauthenticated; the device code identifies the flow.
+     *
+     * Authentication: No token required.
      */
     poll(options: {
         device_code: string;
@@ -190,6 +2216,8 @@ declare class EllipsisAuthCli {
      * Unauthenticated: the CLI has no credential yet — that's what
      * it's obtaining. The human authorizes out-of-band in the
      * dashboard.
+     *
+     * Authentication: No token required.
      */
     start(): Promise<S['StartCliAuthResponse']>;
 }
@@ -198,110 +2226,6 @@ declare class EllipsisAuth {
     readonly cli: EllipsisAuthCli;
     constructor(transport: Transport);
 }
-declare class EllipsisAutomations {
-    private readonly transport;
-    constructor(transport: Transport);
-    /**
-     * Create Automation
-     *
-     * Create an automation, managed through the API: no file, live
-     * immediately. To put its definition in a repository instead, create
-     * it here and then POST /v1/automations/{automation_id}/link.
-     *
-     * 409 when another live automation already holds the name.
-     */
-    create(options: {
-        automation: S['AutomationConfig'];
-    }): Promise<S['AutomationResponse']>;
-    /**
-     * Delete Automation
-     *
-     * Delete an automation, by id or by name.
-     *
-     * It stops running and its name is freed immediately; its past
-     * sessions remain readable. Only for automations managed through
-     * this API — delete the file to remove one defined by a repository.
-     */
-    delete(automation_id: string): Promise<void>;
-    /**
-     * Get Automation
-     *
-     * Return one automation, by id or by name.
-     */
-    get(automation_id: string): Promise<S['AutomationResponse']>;
-    /**
-     * Link Automation
-     *
-     * Move an automation into a repository, by id or by name.
-     *
-     * Opens a pull request adding its definition file. The automation
-     * keeps running unchanged meanwhile; merging hands it over to the
-     * file, after which the file is what changes it. Nothing happens
-     * if the pull request is never merged.
-     */
-    link(automation_id: string, options: {
-        path?: string | null;
-        repository: string;
-    }): Promise<S['LinkAutomationResponse']>;
-    /**
-     * List Automations
-     *
-     * List automations.
-     */
-    list(): Promise<S['AutomationsListResponse']>;
-    /**
-     * Get Automation Metrics
-     *
-     * Return an automation's session distribution and trailing spend,
-     * by id or by name.
-     *
-     * `samples` carries one entry per finished session (duration, cost,
-     * tokens) for distributions; `spend_windows` carries what the
-     * automation's sessions cost over the last 1, 7, and 28 days against
-     * its budget for each window.
-     */
-    metrics(automation_id: string): Promise<S['AutomationMetricsResponse']>;
-    /**
-     * Start Automation Session
-     *
-     * 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.
-     */
-    run(automation_id: string, options?: {
-        budget?: number | null;
-        input?: Record<string, unknown> | null;
-        metadata?: Record<string, string>;
-    }): Promise<S['SessionResponse']>;
-    /**
-     * Unlink Automation
-     *
-     * Take over an automation from its file, by id or by name.
-     *
-     * The file stops governing it immediately and further changes go
-     * through this API. The file is left in place, inert — delete it
-     * whenever you like.
-     */
-    unlink(automation_id: string): Promise<S['AutomationResponse']>;
-    /**
-     * Update Automation
-     *
-     * Replace an automation's definition, by id or by name.
-     *
-     * The whole definition is replaced, and the change is live at
-     * once. Only for automations managed through this API: one defined
-     * by a repository file is a 409, since the next push to that file
-     * would revert the change — unlink it first to take ownership.
-     */
-    update(automation_id: string, options: {
-        automation: S['AutomationConfig'];
-    }): Promise<S['AutomationResponse']>;
-}
 declare class EllipsisEnvironments {
     private readonly transport;
     constructor(transport: Transport);
@@ -313,9 +2237,15 @@ declare class EllipsisEnvironments {
      * `kind: environment` YAML under an agents directory.
      *
      * 409 when another live environment already holds the name.
+     *
+     * Required permissions: write:environments.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
      */
     create(options: {
-        environment: S['EnvironmentDocument'];
+        environment: S['EnvironmentDocument-Input'];
     }): Promise<S['EnvironmentResponse']>;
     /**
      * Delete Environment
@@ -327,18 +2257,36 @@ declare class EllipsisEnvironments {
      * environment. Past sessions remain readable. Only for environments
      * managed through this API — delete the file to remove one defined
      * by a repository.
+     *
+     * Required permissions: delete:environments.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
      */
     delete(environment_id: string): Promise<void>;
     /**
      * Get Environment
      *
      * Return one saved environment, by id or by name.
+     *
+     * Required permissions: read:environments.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
      */
     get(environment_id: string): Promise<S['EnvironmentResponse']>;
     /**
      * List Environments
      *
      * List saved environments.
+     *
+     * Required permissions: read:environments.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
      */
     list(): Promise<S['EnvironmentsListResponse']>;
     /**
@@ -350,9 +2298,15 @@ declare class EllipsisEnvironments {
      * resolve the new body; running sessions keep the one frozen at
      * their start. Only for environments managed through this API: one
      * defined by a repository file is a 409.
+     *
+     * Required permissions: write:environments.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
      */
     update(environment_id: string, options: {
-        environment: S['EnvironmentDocument'];
+        environment: S['EnvironmentDocument-Input'];
     }): Promise<S['EnvironmentResponse']>;
 }
 declare class EllipsisFiles {
@@ -368,6 +2322,13 @@ declare class EllipsisFiles {
      * 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.
+     *
+     * Required permissions: write:files.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
      */
     create(options: {
         content_type: string;
@@ -385,6 +2346,13 @@ declare class EllipsisFiles {
      * 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.
+     *
+     * Required permissions: delete:files.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
      */
     delete(file_id: string): Promise<void>;
     /**
@@ -393,26 +2361,103 @@ 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
      * `agent file get` wraps exactly that two-step.
+     *
+     * Required permissions: read:files.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
      */
     get(file_id: string): Promise<S['GetFileResponse']>;
     /**
      * List Files
      *
-     * List uploaded files, newest first.
+     * List uploaded files, newest first.
+     *
+     * 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.
+     *
+     * Required permissions: read:files.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
+     */
+    list(options?: {
+        session_id?: string | null;
+        limit?: number;
+        cursor?: string | null;
+        include_download_urls?: boolean;
+    }): Promise<Page<S['File'], S['FilesListResponse']>>;
+}
+declare class EllipsisHandlers {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * List Handlers
+     *
+     * List the account's Slack, GitHub, Linear, and Sentry handlers.
+     *
+     * Returns at most one handler per service, from the current .ellipsis
+     * repository. Disabled handlers and last valid definitions with sync
+     * errors are included. Missing handlers are omitted. This reads saved
+     * state without fetching GitHub or triggering synchronization.
+     *
+     * Requires configs:read; scoped grants match handlers/{service}.
+     * Sandbox credentials with that grant may read handlers.
      *
-     * Metadata only — download URLs are minted per explicit GET, not
-     * per row. session_id scopes the list to one run's uploads.
+     * Required permissions: read:configs.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
      */
-    list(options?: {
-        session_id?: string | null;
-        limit?: number;
-        cursor?: string | null;
-    }): Promise<Page<S['File'], S['FilesListResponse']>>;
+    list(): Promise<S['HandlersListResponse']>;
+    /**
+     * Get Handler Metrics
+     *
+     * Return session counts and accumulated spend for a saved handler.
+     *
+     * Filters only by session creation time. Omitted bounds include all
+     * history. Counts use the current conversation outcome, so an idle
+     * session remains active. Spend includes the selected sessions' full
+     * accumulated cost, including activity after the creation-time window.
+     * Only sessions carrying this exact saved handler id are counted;
+     * legacy sessions without handler provenance are excluded.
+     *
+     * spend_windows reports current trailing 1-, 7-, and 28-day credit
+     * debits and effective handler budgets across all attributed sessions.
+     * Those windows use usage timestamps and are independent of start/end.
+     *
+     * Requires configs:read matching handlers/{service} and unrestricted
+     * sessions:read. Sandbox tokens with both grants may read metrics.
+     *
+     * Required permissions: read:sessions, read:configs.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
+     */
+    metrics(handler_id: string, options?: {
+        start?: string | null;
+        end?: string | null;
+    }): Promise<S['HandlerMetricsResponse']>;
 }
 declare class EllipsisIntegrationsGithub {
     private readonly transport;
@@ -427,32 +2472,101 @@ declare class EllipsisIntegrationsGithub {
      *
      * Members carry their linked Slack identity when a Slack-GitHub
      * link exists, and /slack/members carries the reverse link.
+     *
+     * Required permissions: read:integrations.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
      */
     members(): Promise<S['GithubMembersListResponse']>;
     /**
      * List Github Repositories
      *
      * List GitHub repositories connected to the installation.
+     *
+     * Required permissions: read:integrations.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
      */
     repos(): Promise<S['GithubRepositoriesListResponse']>;
+    /**
+     * Uninstall Github App
+     *
+     * Required permissions: write:integrations.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    uninstall(options: {
+        confirm_account_login: string;
+    }): Promise<S['AccountActionResponse']>;
 }
 declare class EllipsisIntegrationsLinear {
     private readonly transport;
     constructor(transport: Transport);
+    /**
+     * Delete Linear Integration
+     *
+     * Required permissions: delete:integrations.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    delete(): Promise<S['AccountActionResponse']>;
     /**
      * List Linear Teams
      *
      * List the teams of the connected Linear workspace.
+     *
+     * Required permissions: read:integrations.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
      */
     teams(): Promise<S['LinearTeamsListResponse']>;
+    /**
+     * Update Linear Teams
+     *
+     * Required permissions: write:integrations.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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
+     *
+     * Required permissions: delete:integrations.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    delete(integration_id: string): Promise<S['AccountActionResponse']>;
     /**
      * List Sentry Organizations
      *
      * List the connected Sentry organizations.
+     *
+     * Required permissions: read:integrations.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
      */
     organizations(): Promise<S['SentryOrganizationsListResponse']>;
 }
@@ -464,15 +2578,59 @@ declare class EllipsisIntegrationsSlack {
      *
      * List the channels of the connected Slack workspace, fetched
      * live from the Slack API.
+     *
+     * Required permissions: read:integrations.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
      */
     channels(): Promise<S['SlackChannelsListResponse']>;
+    /**
+     * Create Operations Channel
+     *
+     * Required permissions: write:integrations.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    createOperationsChannel(): Promise<S['SlackChannel']>;
+    /**
+     * Delete Slack Integration
+     *
+     * Required permissions: delete:integrations.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    delete(): Promise<S['AccountActionResponse']>;
     /**
      * List Slack Members
      *
      * List the members of the connected Slack workspace, fetched
      * live from the Slack API.
+     *
+     * Required permissions: read:integrations.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
      */
     members(): Promise<S['SlackMembersListResponse']>;
+    /**
+     * Update Slack Settings
+     *
+     * Required permissions: write:integrations.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    updateSettings(options: {
+        mcp_inclusion: S['McpInclusionMode'];
+    }): Promise<S['AccountActionResponse']>;
 }
 declare class EllipsisIntegrations {
     private readonly transport;
@@ -488,10 +2646,16 @@ declare class EllipsisIntegrations {
      *
      * 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 /automations.
+     * organizations it may name before POST /agents.
      *
      * Available to all credential types including sandbox tokens: the
      * responses never include OAuth tokens or any other secret.
+     *
+     * Required permissions: read:integrations.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
      */
     list(): Promise<S['GetIntegrationsResponse']>;
 }
@@ -510,6 +2674,13 @@ declare class EllipsisMemories {
      *
      * Creating never overwrites: a path that already exists is a 409, so
      * correcting an existing memory is an explicit edit.
+     *
+     * Required permissions: write:memories.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
      */
     create(options: {
         content: string;
@@ -524,6 +2695,13 @@ declare class EllipsisMemories {
      * 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.
+     *
+     * Required permissions: delete:memories.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
      */
     delete(memory_id: string, options?: {
         if_sha256?: string | null;
@@ -539,6 +2717,13 @@ declare class EllipsisMemories {
      *
      * Pass `if_sha256` (from a previous read) to make a concurrent write
      * a 409 instead of silently overwriting it.
+     *
+     * Required permissions: write:memories.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
      */
     edit(memory_id: string, options?: {
         content?: string | null;
@@ -551,6 +2736,13 @@ declare class EllipsisMemories {
      * Read one memory's full content.
      *
      * The id comes from the index returned by listing memories.
+     *
+     * Required permissions: read:memories.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
      */
     get(memory_id: string): Promise<S['MemoryResponse']>;
     /**
@@ -562,31 +2754,31 @@ declare class EllipsisMemories {
      * 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.
+     *
+     * Required permissions: read:memories.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
      */
     list(options?: {
         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.
+     * List Review Configs
      *
-     * 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.
+     * Required permissions: read:reviews.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
      */
-    list(): Promise<S['ModelsListResponse']>;
-}
-declare class EllipsisReviews {
-    private readonly transport;
-    constructor(transport: Transport);
+    configs(): Promise<S['GetCodeReviewConfigsResponse']>;
     /**
      * Create Review
      *
@@ -602,6 +2794,12 @@ declare class EllipsisReviews {
      * `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.
+     *
+     * Required permissions: write:reviews.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
      */
     create(options: {
         owner: string;
@@ -621,6 +2819,12 @@ declare class EllipsisReviews {
      * 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.
+     *
+     * Required permissions: read:reviews.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
      */
     get(review_id: string): Promise<S['Review']>;
     /**
@@ -635,6 +2839,12 @@ declare class EllipsisReviews {
      *
      * Webhook-created reviews appear here too, so this answers "show
      * me every review on this PR".
+     *
+     * Required permissions: read:reviews.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
      */
     list(options?: {
         repository?: (string)[];
@@ -656,6 +2866,13 @@ declare class EllipsisSecrets {
      *
      * Refused for sandbox tokens; mutations require an API key or
      * user token.
+     *
+     * Required permissions: delete:secrets.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
      */
     delete(name: string): Promise<void>;
     /**
@@ -665,6 +2882,13 @@ declare class EllipsisSecrets {
      *
      * Values are write-only: the response carries only names and
      * timestamps, never the stored value.
+     *
+     * Required permissions: read:secrets.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
      */
     list(): Promise<S['SecretsListResponse']>;
     /**
@@ -676,6 +2900,13 @@ declare class EllipsisSecrets {
      * only — values are write-only. Refused for sandbox tokens (held by
      * potentially-untrusted in-sandbox code); mutations require an
      * API key or user token.
+     *
+     * Required permissions: write:secrets.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
      */
     set(options: {
         secrets: (S['SecretInput'])[];
@@ -685,7 +2916,28 @@ declare class EllipsisSessions {
     private readonly transport;
     constructor(transport: Transport);
     /**
-     * Get Agent Session Diff
+     * Get 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.
+     *
+     * Required permissions: read:sessions.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own session.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
+     */
+    analytics(session_id: string): Promise<S['SessionAnalytics']>;
+    /**
+     * Get Session Diff
      *
      * Return the session's uncommitted changes as a patch.
      *
@@ -694,12 +2946,19 @@ declare class EllipsisSessions {
      * counts ride on the session itself (`git.repos[].files`); this
      * is the text behind them. Empty when the tree was clean. A
      * sandbox token may read only its own session's diff.
+     *
+     * Required permissions: read:sessions.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own session.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
      */
     diff(session_id: string): Promise<S['SessionDiffResponse']>;
     /**
-     * Export Agent Session
+     * Download Session
      *
-     * Export the complete session history.
+     * Download 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
@@ -709,23 +2968,71 @@ declare class EllipsisSessions {
      * 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.
+     *
+     * Required permissions: read:sessions.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
      */
-    export(session_id: string): Promise<S['GetSessionLogResponse']>;
+    download(session_id: string): Promise<S['GetSessionLogResponse']>;
     /**
-     * Get Agent Session
+     * 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.
+     *
+     * Required permissions: read:sessions.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
+     */
+    executions(session_id: string): Promise<S['SessionExecutionsListResponse']>;
+    /**
+     * Get 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
+     * frames carry, with attribution, stop, and archive actors resolved
      * at read time.
      *
      * The heavy near-static blobs (config snapshot, input/output)
      * live on the detail endpoints, not here.
+     *
+     * Required permissions: read:sessions.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
      */
     get(session_id: string): Promise<S['SessionResponse']>;
     /**
-     * Ingest Agent Session Transcript
+     * Get 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.
+     *
+     * Required permissions: read:sessions.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
+     */
+    git(session_id: string): Promise<S['SessionGitResponse']>;
+    /**
+     * Ingest Session Transcript
      *
      * Append transcript lines to a session's record.
      *
@@ -733,23 +3040,39 @@ declare class EllipsisSessions {
      *
      * A sandbox token may only push its own session's transcript.
      * Idempotent by transcript line uuid; tolerant of malformed lines.
+     *
+     * Required permissions: write:sessions.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own session.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
      */
     ingestTranscript(session_id: string, options: {
         lines: (string)[];
         offset?: number;
     }): Promise<S['TranscriptIngestResult']>;
     /**
-     * List Agent Sessions
+     * List Sessions
      *
      * List cloud agent sessions, newest first.
      *
-     * Optionally filtered by automation (id or name), source, time
+     * Optionally filtered by agent (id or name), source, service, handler, time
      * window, attributed author, repository, and whether the session is
      * still going.
+     *
+     * Required permissions: read:sessions.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
      */
     list(options?: {
-        automation?: string | null;
+        agent?: string | null;
         source?: (S['SessionSource'])[] | null;
+        service?: S['HandlerService'] | null;
+        handler?: string | null;
         days?: number | null;
         start?: string | null;
         end?: string | null;
@@ -758,9 +3081,10 @@ 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
+     * Get Session Output
      *
      * Return the session's typed output.
      *
@@ -769,10 +3093,17 @@ declare class EllipsisSessions {
      * while the session is still running (poll GET /v1/sessions/{id}),
      * when the agent declares no output block, or when no execution
      * produced output.
+     *
+     * Required permissions: read:sessions.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
      */
-    output(session_id: string): Promise<void>;
+    output(session_id: string): Promise<Record<string, unknown>>;
     /**
-     * Get Agent Session Records
+     * Get Session Records
      *
      * Return the session's stored transcript records, oldest first.
      *
@@ -781,13 +3112,45 @@ declare class EllipsisSessions {
      * agent answering "did X look into Y?" needs to read the sessions
      * it finds, and any org member sees the same transcript in the
      * dashboard.
+     *
+     * Required permissions: read:sessions.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
      */
     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 Sessions
+     *
+     * Required permissions: read:sessions.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
+     */
+    search(options?: {
+        q?: string;
+        scope?: S['SessionSearchScope'];
+        source?: (S['SessionSource'])[] | null;
+        service?: S['HandlerService'] | null;
+        handler?: string | null;
+        author_id?: (number)[] | null;
+        agent_id?: (string)[] | null;
+        session_ids?: (string)[] | null;
+        repo?: (string)[] | null;
+        status?: (S['SessionLifecycleStatus'])[] | null;
+        start?: string | null;
+        end?: string | null;
+        limit?: number;
+    }): Promise<S['SessionSearchResponse']>;
     /**
-     * Send Agent Session Message
+     * Send Session Message
      *
      * Send a message to a session.
      *
@@ -795,6 +3158,13 @@ declare class EllipsisSessions {
      * Returns the created message so the caller can track it by id; a
      * retried send with the same idempotency_key returns the original
      * message.
+     *
+     * Required permissions: write:sessions.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
      */
     sendMessage(session_id: string, options: {
         idempotency_key?: string | null;
@@ -802,82 +3172,152 @@ declare class EllipsisSessions {
         message: string;
     }): Promise<S['SessionMessageResponse']>;
     /**
-     * Start Agent Session
+     * Get Session Stream Ticket
+     *
+     * Required permissions: read:sessions.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
+     */
+    sessionStreamTicket(session_id: string): Promise<S['StreamTicketResponse']>;
+    /**
+     * Start Session
      *
      * Start a cloud agent session.
      *
      * The daily driver: a prompt, optionally where to run it
-     * (`environment`) and the run's own settings, in the AutomationConfig
+     * (`environment`) and the run's own settings, in the AgentConfig
      * 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
+     * `{"claude_code": {"prompt": "..."}}` is a complete request.
+     * Set exactly one of `claude_code` or `codex`. Its `prompt` is the
+     * first message; omit the prompt and the session starts idle, waiting for
+     * one. 400 when `lifecycle.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.
+     * run a saved agent, use POST /v1/agents/{agent_id}/sessions.
+     *
+     * Required permissions: write:sessions.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
      */
     start(options?: {
         budget?: number | null;
-        claude?: S['ClaudeConfig'] | null;
-        codex?: S['CodexConfig'] | null;
-        environment?: string | S['EnvironmentConfig'] | null;
+        claude_code?: S['ClaudeConfig-Input'] | null;
+        codex?: S['CodexConfig-Input'] | null;
+        environment?: string | S['EnvironmentConfig-Input'] | null;
         force_rebuild?: boolean;
         images?: (S['ImageAttachment'])[];
-        interactive?: boolean;
+        lifecycle?: S['SessionLifecycleConfig'];
         metadata?: Record<string, string>;
         output?: S['OutputConfig'] | null;
-        permissions?: S['PermissionsConfig'] | null;
-        prompt?: string | null;
+        permissions?: S['PermissionsConfig-Input'] | null;
         repositories?: (string)[] | null;
-        skills?: (S['SkillRef'])[] | null;
+        skills?: (S['SkillRef-Input'])[] | null;
     }): Promise<S['SessionResponse']>;
     /**
-     * Stop Agent Session
+     * Stop Session
      *
      * Stop an in-flight session and return it.
      *
      * stopped_by is recorded only when the caller's credential maps
      * to a GitHub account.
+     *
+     * Required permissions: write:sessions.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
      */
     stop(session_id: string): Promise<S['SessionResponse']>;
+    /**
+     * Get Sessions Stream Ticket
+     *
+     * Required permissions: read:sessions.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
+     */
+    streamTicket(): Promise<S['StreamTicketResponse']>;
+    /**
+     * Update Session
+     *
+     * Archive or unarchive a session and return it.
+     *
+     * Set archived to true to record the current server time and the
+     * authenticated GitHub user. API-key requests record no user.
+     * Repeated archive requests preserve the original time and user.
+     * Set archived to false to clear both fields. Archiving is available
+     * in any session state and does not stop a running session.
+     *
+     * Changes are delivered to session and session-list streams.
+     *
+     * Required permissions: write:sessions.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     * Grant match patterns can further restrict access to individual resources.
+     */
+    update(session_id: string, options: {
+        archived: boolean;
+    }): Promise<S['SessionResponse']>;
     /** 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.
+     * Request Slack Help
      *
-     * The default model every session falls back to when neither its
-     * request nor its automation names one, and the per-session budget
-     * ceiling no session may exceed.
+     * Required permissions: write:account.
+     * API key: Requires a CLI user token.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
      */
-    get(): Promise<S['OrganizationSettings']>;
+    create(options: {
+        emails: (string)[];
+        resend?: boolean;
+    }): Promise<S['SlackHelpResponse']>;
     /**
-     * Set Organization Settings
+     * Get Slack Help
      *
-     * Set the organization settings.
+     * Required permissions: read:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    get(): Promise<void>;
+    /**
+     * Invite To Slack Help
      *
-     * Replaces both: `default_model` accepts an alias or canonical id
-     * and is stored canonical; `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).
+     * Required permissions: write:account.
+     * API key: Requires a CLI user token.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
      */
-    set(options?: {
-        budget_ceiling?: S['BudgetCeiling'];
-        default_model?: string | null;
-    }): Promise<S['OrganizationSettings']>;
+    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 {
@@ -887,6 +3327,12 @@ declare class EllipsisTemplates {
      * Get Agent Template
      *
      * Return one built-in agent template by slug.
+     *
+     * Required permissions: read:templates.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
      */
     get(template_id: string): Promise<S['AgentTemplate']>;
     /**
@@ -896,44 +3342,431 @@ declare class EllipsisTemplates {
      *
      * Behind auth but not account-scoped — the data is static
      * product content shared by the dashboard, landing site, and CLI.
+     *
+     * Required permissions: read:templates.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
      */
     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.
+     *
+     * Required permissions: delete:user.
+     * API key: Requires a CLI user token.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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`.
+     *
+     * Required permissions: read:user.
+     * API key: Requires a CLI user token.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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.
+     *
+     * Required permissions: read:user.
+     * API key: Requires a CLI user token.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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.
+     *
+     * Required permissions: write:user.
+     * API key: Requires a CLI user token.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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.
+     *
+     * Required permissions: read:user.
+     * API key: Requires a CLI user token.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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.
+     *
+     * Required permissions: write:user.
+     * API key: Requires a CLI user token.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    verify(provider: S['SubscriptionProvider']): Promise<S['VerifySubscriptionTokenResponse']>;
+}
+declare class EllipsisUserTokens {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * List User Tokens
+     *
+     * Required permissions: read:user.
+     * API key: Requires a CLI user token.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    list(): Promise<S['ListUserTokensResponse']>;
+    /**
+     * Revoke User Token
+     *
+     * Required permissions: delete:user.
+     * API key: Requires a CLI user token.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    revoke(token_id: string): Promise<S['TokenRevokedResponse']>;
+}
+declare class EllipsisUser {
+    private readonly transport;
+    readonly subscriptionTokens: EllipsisUserSubscriptionTokens;
+    readonly tokens: EllipsisUserTokens;
+    constructor(transport: Transport);
+}
+declare class EllipsisVmExecutions {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * Get Single Vm Execution
+     *
+     * Required permissions: read:environments.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own sandbox.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    get(vm_execution_id: string): Promise<S['VMExecutionResponse']>;
+    /**
+     * Get Vm Executions
+     *
+     * Required permissions: read:environments.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own sandbox.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    list(): Promise<void>;
+    /**
+     * Get Vm Execution Stream Ticket
+     *
+     * Required permissions: read:environments.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own sandbox.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    streamTicket(vm_execution_id: string): Promise<S['StreamTicketResponse']>;
+}
+declare class EllipsisVmImages {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * Get Vm Image
+     *
+     * Get metadata for a reusable VM image.
+     *
+     * Required permissions: read:environments.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    get(image_id: string): Promise<S['VMImageResponse']>;
+    /**
+     * List Vm Images
+     *
+     * List reusable VM images.
+     *
+     * Includes expiration, repository revisions, and build identity.
+     *
+     * Required permissions: read:environments.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    list(options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<S['VMImageListResponse']>;
+}
+declare class EllipsisVms {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * Get Vm
+     *
+     * Get a VM and its most recent execution.
+     *
+     * Required permissions: read:environments.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own VM.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    get(vm_id: string): Promise<S['VM']>;
+    /**
+     * List Vms
+     *
+     * List VMs and their last recorded state.
+     *
+     * Each machine appears once, including paused and deleted VMs, newest execution first.
+     *
+     * Required permissions: read:environments.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration. Only the token's own VM.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    list(options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<S['VMListResponse']>;
+}
+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.
+     *
+     * Required permissions: read:webhooks.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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.
+     *
+     * Required permissions: read:webhooks.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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 default to three webhook slots, including unverified and
+     * pending ones; your account may have a custom allowance. A ping returning HTTP 200 moves unverified to pending. Contact
+     * Ellipsis to activate it and receive session.create events.
+     *
+     * Required permissions: write:webhooks.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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 a webhook slot.
+     *
+     * Required permissions: delete:webhooks.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    delete(webhook_id: string): Promise<void>;
+    /**
+     * Get Webhook
+     *
+     * Get a webhook's configuration and approval state.
+     *
+     * Required permissions: read:webhooks.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    get(webhook_id: string): Promise<S['WebhookResponse']>;
+    /**
+     * List Webhooks
+     *
+     * List your webhooks and their delivery summaries.
+     *
+     * Required permissions: read:webhooks.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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. The default limit is five pings per
+     * account per minute, including creation and URL changes. Custom
+     * account allowances apply.
+     *
+     * Required permissions: write:webhooks.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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.
+     *
+     * Required permissions: write:webhooks.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Not supported by sandbox tokens, even with permissions.ellipsis enabled.
+     * Higher permission levels include lower levels: read < write < delete.
+     */
+    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 agents: EllipsisAgents;
     readonly alerts: EllipsisAlerts;
     readonly analytics: EllipsisAnalytics;
     readonly auth: EllipsisAuth;
-    readonly automations: EllipsisAutomations;
     readonly environments: EllipsisEnvironments;
     readonly files: EllipsisFiles;
+    readonly handlers: EllipsisHandlers;
     readonly integrations: EllipsisIntegrations;
     readonly memories: EllipsisMemories;
-    readonly models: EllipsisModels;
     readonly reviews: EllipsisReviews;
     readonly secrets: EllipsisSecrets;
     readonly sessions: EllipsisSessions;
-    readonly settings: EllipsisSettings;
+    readonly support: EllipsisSupport;
     readonly templates: EllipsisTemplates;
+    readonly user: EllipsisUser;
+    readonly vmExecutions: EllipsisVmExecutions;
+    readonly vmImages: EllipsisVmImages;
+    readonly vms: EllipsisVms;
+    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.
+     * Required permissions: read:account.
+     * API key: Supported.
+     * CLI user token: Supported.
+     * Sandbox token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
+     * Higher permission levels include lower levels: read < write < delete.
      */
-    usage(): Promise<S['GetUsageDashboardResponse']>;
+    identity(): Promise<S['Identity']>;
 }
 
 declare class EllipsisError extends Error {
@@ -968,4 +3801,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, type AgentListStreamMessage, AuthenticationError, 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 };