@ellipsis-dev/sdk 0.1.0

package/dist/types-BRE4NMnS.d.ts

@@ -0,0 +1,1192 @@
+interface paths {
+    '/v1/sessions/{session_id}': {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get Agent Session */
+        get: operations['get_agent_session_v1_sessions__session_id__get'];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    '/v1/sessions/{session_id}/messages': {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Send Agent Session Message */
+        post: operations['send_agent_session_message_v1_sessions__session_id__messages_post'];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    '/v1/sessions/{session_id}/records': {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get Agent Session Records */
+        get: operations['get_agent_session_records_v1_sessions__session_id__records_get'];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    '/v1/sessions/{session_id}/turns': {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get Agent Session Turns */
+        get: operations['get_agent_session_turns_v1_sessions__session_id__turns_get'];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+interface components {
+    schemas: {
+        /**
+         * AgentSessionExitStatus
+         * @description Why a terminal agent session ended — a finer-grained reason than `status`.
+         *
+         *     `status` (AgentSessionStatus) is the lifecycle state: COMPLETED / ERROR /
+         *     CANCELLED. `exit_status` explains *why* a run reached that terminal state, so
+         *     the UI and metrics can tell a budget cutoff apart from a crashed tool call or
+         *     a deliberate cancellation. It is None until the run reaches a terminal state.
+         * @enum {string}
+         */
+        AgentSessionExitStatus: 'completed' | 'budget_hit' | 'payment_required' | 'tool_call_failed' | 'lifecycle_hook_failed' | 'missing_repo_access' | 'missing_token_permissions' | 'cancelled' | 'interrupted' | 'error' | 'stopped';
+        /**
+         * AgentSessionPr
+         * @description A pull request this session created, denormalized at capture time so
+         *     session surfaces render a labeled link without joining gh_prs. Live PR
+         *     state (open/merged/closed) is not stored here — read it from gh_prs where
+         *     a view needs it.
+         */
+        AgentSessionPr: {
+            /** Gh Pr Id */
+            gh_pr_id?: number | null;
+            /** Number */
+            number: number;
+            /** Repo Full Name */
+            repo_full_name: string;
+            /** Title */
+            title?: string | null;
+            /** Url */
+            url: string;
+        };
+        /**
+         * AgentSessionSource
+         * @enum {string}
+         */
+        AgentSessionSource: 'react' | 'manual' | 'api' | 'cli' | 'mention' | 'cron' | 'laptop';
+        /**
+         * AgentSessionStatus
+         * @enum {string}
+         */
+        AgentSessionStatus: 'scheduled' | 'creating_sandbox' | 'running' | 'retrying' | 'completed' | 'error' | 'cancelled' | 'stopped';
+        /** AgentSessionWire */
+        AgentSessionWire: {
+            /** Agent Config Id */
+            agent_config_id?: string | null;
+            attributed_user?: components['schemas']['GithubAccountSnippet'] | null;
+            /** Attribution Id */
+            attribution_id?: string | null;
+            attribution_type?: components['schemas']['AttributionType'] | null;
+            /** Client Version */
+            client_version?: string | null;
+            /** Config Override */
+            config_override?: {
+                [key: string]: unknown;
+            } | null;
+            /** Context Repository */
+            context_repository?: string | null;
+            /**
+             * Cost Fee
+             * @default 0
+             */
+            cost_fee: number;
+            /**
+             * Cost Sandbox Cpu
+             * @default 0
+             */
+            cost_sandbox_cpu: number;
+            /**
+             * Cost Sandbox Memory
+             * @default 0
+             */
+            cost_sandbox_memory: number;
+            /** Cost Tokens */
+            cost_tokens: number;
+            /**
+             * Created At
+             * Format: date-time
+             */
+            created_at: string;
+            /** Customer Id */
+            customer_id: string;
+            default_resolution?: components['schemas']['DefaultResolution'] | null;
+            exit_status?: components['schemas']['AgentSessionExitStatus'] | null;
+            harness: components['schemas']['Harness'];
+            /** Id */
+            id: string;
+            /** Last Activity At */
+            last_activity_at?: string | null;
+            /** Last Message At */
+            last_message_at?: string | null;
+            /** Live Summary */
+            live_summary?: string | null;
+            /**
+             * Metadata
+             * @default {}
+             */
+            metadata: {
+                [key: string]: string;
+            };
+            /** Output Prs */
+            output_prs?: components['schemas']['AgentSessionPr'][] | null;
+            /** Parent Agent Session Id */
+            parent_agent_session_id?: string | null;
+            parent_kind?: components['schemas']['ParentKind'] | null;
+            /** Prompt */
+            prompt?: string | null;
+            /** Replayed From Session Id */
+            replayed_from_session_id?: string | null;
+            /** Resolved Budget Cents */
+            resolved_budget_cents: number;
+            resolved_budget_source: components['schemas']['BudgetSource'];
+            /** Sandbox Id */
+            sandbox_id?: string | null;
+            /** Session Key */
+            session_key?: string | null;
+            session_state?: components['schemas']['SessionState'] | null;
+            source: components['schemas']['AgentSessionSource'];
+            status: components['schemas']['AgentSessionStatus'];
+            /** Status Reason */
+            status_reason?: string | null;
+            /** Stopped At */
+            stopped_at?: string | null;
+            /** Stopped By */
+            stopped_by?: number | null;
+            stopped_by_user?: components['schemas']['GithubAccountSnippet'] | null;
+            surface?: components['schemas']['SessionSurface'] | null;
+            /**
+             * Tokens Cache Creation
+             * @default 0
+             */
+            tokens_cache_creation: number;
+            /**
+             * Tokens Cache Read
+             * @default 0
+             */
+            tokens_cache_read: number;
+            /**
+             * Tokens Input
+             * @default 0
+             */
+            tokens_input: number;
+            /** Tokens Model */
+            tokens_model: string;
+            /**
+             * Tokens Output
+             * @default 0
+             */
+            tokens_output: number;
+            /**
+             * Tokens Total
+             * @default 0
+             */
+            tokens_total: number;
+            /**
+             * Updated At
+             * Format: date-time
+             */
+            updated_at: string;
+            /** Webhook Id */
+            webhook_id?: string | null;
+            webhook_type?: components['schemas']['WebhookType'] | null;
+        };
+        /**
+         * AgentTurn
+         * @description One exchange within a session: a single Claude Code execution driven by the
+         *     session's inbox. Over subsequent slices this absorbs the per-execution fields
+         *     (status, cost, tokens, exit_status) that currently live on agent_sessions.
+         */
+        AgentTurn: {
+            /** Agent Session Id */
+            agent_session_id: string;
+            /** Completed At */
+            completed_at?: string | null;
+            /**
+             * Cost Fee
+             * @default 0
+             */
+            cost_fee: number;
+            /**
+             * Cost Sandbox Cpu
+             * @default 0
+             */
+            cost_sandbox_cpu: number;
+            /**
+             * Cost Sandbox Memory
+             * @default 0
+             */
+            cost_sandbox_memory: number;
+            /**
+             * Cost Tokens
+             * @default 0
+             */
+            cost_tokens: number;
+            /**
+             * Created At
+             * Format: date-time
+             */
+            created_at: string;
+            exit_status?: components['schemas']['AgentSessionExitStatus'] | null;
+            /** Id */
+            id: string;
+            /** React Action */
+            react_action?: string | null;
+            /** Sandbox Id */
+            sandbox_id?: string | null;
+            /** Session Execution Id */
+            session_execution_id?: string | null;
+            /** Started At */
+            started_at?: string | null;
+            status: components['schemas']['AgentTurnStatus'];
+            /** Status Reason */
+            status_reason?: string | null;
+            /**
+             * Tokens Cache Creation
+             * @default 0
+             */
+            tokens_cache_creation: number;
+            /**
+             * Tokens Cache Read
+             * @default 0
+             */
+            tokens_cache_read: number;
+            /**
+             * Tokens Input
+             * @default 0
+             */
+            tokens_input: number;
+            /** Tokens Model */
+            tokens_model?: string | null;
+            /**
+             * Tokens Output
+             * @default 0
+             */
+            tokens_output: number;
+            /**
+             * Tokens Total
+             * @default 0
+             */
+            tokens_total: number;
+            /** Turn Index */
+            turn_index: number;
+            /**
+             * Updated At
+             * Format: date-time
+             */
+            updated_at: string;
+            /** Webhook Id */
+            webhook_id?: string | null;
+            webhook_type?: components['schemas']['WebhookType'] | null;
+        };
+        /**
+         * AgentTurnStatus
+         * @enum {string}
+         */
+        AgentTurnStatus: 'scheduled' | 'running' | 'completed' | 'error' | 'cancelled';
+        /**
+         * AttributionType
+         * @enum {string}
+         */
+        AttributionType: 'github_user' | 'linear_user' | 'slack_user' | 'api_key';
+        /**
+         * BudgetSource
+         * @description Which layer actually determined the enforced budget.
+         *
+         *     Not derivable from the run row alone (the run does not store the config
+         *     cents or the customer default), so we persist it for the UI / audit.
+         * @enum {string}
+         */
+        BudgetSource: 'system' | 'account' | 'config' | 'run';
+        /**
+         * DefaultResolution
+         * @description How a session that arrived with no explicit config source resolved its
+         *     config (documents/eng/DEFAULT_CONFIGS.md §4). Persisted on the session so
+         *     audit and clients can say "ran under X (repo default)". A session started
+         *     with an explicit config/config_id/template_id never enters resolution and
+         *     stores None.
+         * @enum {string}
+         */
+        DefaultResolution: 'repo_default' | 'account_default' | 'none';
+        /**
+         * GithubAccountSnippet
+         * @description 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.
+         */
+        GithubAccountSnippet: {
+            /** Avatar Url */
+            avatar_url: string;
+            /** Id */
+            id: number;
+            /** Login */
+            login: string;
+            type: components['schemas']['GithubAccountType'];
+        };
+        /**
+         * GithubAccountType
+         * @enum {string}
+         */
+        GithubAccountType: 'User' | 'Organization' | 'Bot' | 'Mannequin';
+        /** HTTPValidationError */
+        HTTPValidationError: {
+            /** Detail */
+            detail?: components['schemas']['ValidationError'][];
+        };
+        /**
+         * Harness
+         * @enum {string}
+         */
+        Harness: 'claude_code';
+        /** ListSessionRecordsResponse */
+        ListSessionRecordsResponse: {
+            /** Earliest Feed Seq */
+            earliest_feed_seq?: number | null;
+            /**
+             * Has More
+             * @default false
+             */
+            has_more: boolean;
+            /**
+             * Messages
+             * @default []
+             */
+            messages: components['schemas']['SessionMessageWire'][];
+            /** Records */
+            records: components['schemas']['SessionRecordWire'][];
+        };
+        /** ListSessionTurnsResponse */
+        ListSessionTurnsResponse: {
+            /** Messages */
+            messages: components['schemas']['SessionMessage'][];
+            /** Turns */
+            turns: components['schemas']['AgentTurn'][];
+        };
+        /** ModelTokensInfo */
+        ModelTokensInfo: {
+            /**
+             * Cache Creation Input Tokens
+             * @default 0
+             */
+            cache_creation_input_tokens: number;
+            /**
+             * Cache Read Input Tokens
+             * @default 0
+             */
+            cache_read_input_tokens: number;
+            /**
+             * Cost Usd
+             * @default 0
+             */
+            cost_usd: number;
+            /**
+             * Input Tokens
+             * @default 0
+             */
+            input_tokens: number;
+            /**
+             * Output Tokens
+             * @default 0
+             */
+            output_tokens: number;
+        };
+        /**
+         * ParentKind
+         * @description How a session relates to its predecessor (parent_agent_session_id) —
+         *     the ONE "preceded-by" chain for every predecessor relationship. Routing
+         *     reads this when the distinction matters.
+         *
+         *     CONTINUATION — a follow-up in the same conversation surface (e.g. a Slack
+         *     thread reply spawning a fresh session on the same thread).
+         *     HANDOFF — a session started to take over work from another surface (e.g.
+         *     laptop → cloud handoff; later phase).
+         *     RESUME — a conversation re-hosted on a new box after its sandbox was torn
+         *     down (interactive platform; later phase).
+         * @enum {string}
+         */
+        ParentKind: 'continuation' | 'handoff' | 'resume';
+        /**
+         * RecordSource
+         * @description `session_records.source` — the client render switch. `lifecycle` rows are
+         *     controller-emitted platform notifications; a harness value means a native
+         *     transcript record from that harness.
+         * @enum {string}
+         */
+        RecordSource: 'lifecycle' | 'claude_code';
+        /**
+         * RunStatus
+         * @description What the current (or most recent) execution is doing (backs `run`).
+         * @enum {string}
+         */
+        RunStatus: 'scheduled' | 'starting' | 'working' | 'waiting' | 'done' | 'failed' | 'stopped' | 'cancelled' | 'retrying';
+        /**
+         * SendSessionMessageRequest
+         * @description A human message posted into a durable (keyed) session's conversation
+         *     (documents/eng/SESSION_IDE.md). Delivered to the live Claude Code process
+         *     at the next turn boundary, or wakes the session when idle. This is what
+         *     the `agent` CLI's connect composer calls — including from inside the
+         *     session's own sandbox, where the sandbox token inherits the session's
+         *     attribution.
+         */
+        SendSessionMessageRequest: {
+            /** Idempotency Key */
+            idempotency_key?: string | null;
+            /** Message */
+            message: string;
+        };
+        /**
+         * SessionLiveness
+         * @description The durable conversation axis (backs the surfaced `session` field).
+         * @enum {string}
+         */
+        SessionLiveness: 'alive' | 'sleeping' | 'closed';
+        /**
+         * SessionMessage
+         * @description One entry in a session's inbox: an event, rendered into a user message,
+         *     waiting to be consumed by a turn. body is the RENDERED text (pointers to
+         *     code/events, never embedded diffs), so a turn's initial query is built from
+         *     the pending messages without re-fetching the trigger.
+         */
+        SessionMessage: {
+            /** Agent Session Id */
+            agent_session_id: string;
+            /** Author */
+            author?: string | null;
+            /** Body */
+            body: string;
+            /**
+             * Closes Session
+             * @default false
+             */
+            closes_session: boolean;
+            /**
+             * Created At
+             * Format: date-time
+             */
+            created_at: string;
+            /** Delivered At */
+            delivered_at?: string | null;
+            /** Delivered Turn Id */
+            delivered_turn_id?: string | null;
+            /** Feed Seq */
+            feed_seq?: number | null;
+            /** Id */
+            id: string;
+            /** Idempotency Key */
+            idempotency_key?: string | null;
+            /** Platform Ts */
+            platform_ts?: string | null;
+            /** Sender Attribution Id */
+            sender_attribution_id?: string | null;
+            sender_attribution_type?: components['schemas']['AttributionType'] | null;
+            status: components['schemas']['SessionMessageStatus'];
+            /** Webhook Id */
+            webhook_id?: string | null;
+            webhook_type?: components['schemas']['WebhookType'] | null;
+        };
+        /**
+         * SessionMessageStatus
+         * @enum {string}
+         */
+        SessionMessageStatus: 'pending' | 'delivered';
+        /**
+         * SessionMessageWire
+         * @description The wire shape of one inbox message (§3.3): what a queued chip renders
+         *     and retires on. `author` is the message's attribution string; the webhook
+         *     provenance internals stay off the wire.
+         */
+        SessionMessageWire: {
+            /** Agent Session Id */
+            agent_session_id: string;
+            /** Author */
+            author?: string | null;
+            /** Body */
+            body: string;
+            /**
+             * Created At
+             * Format: date-time
+             */
+            created_at: string;
+            /** Delivered At */
+            delivered_at?: string | null;
+            /** Delivered Turn Id */
+            delivered_turn_id?: string | null;
+            /** Feed Seq */
+            feed_seq?: number | null;
+            /** Id */
+            id: string;
+            /** Sender Attribution Id */
+            sender_attribution_id?: string | null;
+            sender_attribution_type?: components['schemas']['AttributionType'] | null;
+            status: components['schemas']['SessionMessageStatus'];
+        };
+        /**
+         * SessionRecordWire
+         * @description The wire shape of one session record (§3.3): the §3.6 stable envelope +
+         *     the native `payload`, by explicit allowlist. Internal-only columns
+         *     (`search_text`, `clis`, ingest bookkeeping, attribution denormalizations)
+         *     are deliberately absent so internal model evolution stays free.
+         */
+        SessionRecordWire: {
+            /** Agent Session Id */
+            agent_session_id: string;
+            /** Agent Turn Id */
+            agent_turn_id?: string | null;
+            /** Cost */
+            cost?: number | null;
+            /**
+             * Created At
+             * Format: date-time
+             */
+            created_at: string;
+            /** Duration */
+            duration?: number | null;
+            /** Feed Seq */
+            feed_seq: number;
+            /** Id */
+            id: string;
+            /** Model */
+            model?: string | null;
+            /** Payload */
+            payload: {
+                [key: string]: unknown;
+            };
+            /** Record Format */
+            record_format: string;
+            /** Record Type */
+            record_type: string;
+            /** Session Message Id */
+            session_message_id?: string | null;
+            source: components['schemas']['RecordSource'];
+            /** Stream Seq */
+            stream_seq: number;
+            tokens_info?: components['schemas']['TokensInfo'] | null;
+            /** Tools */
+            tools?: string[] | null;
+        };
+        /**
+         * SessionState
+         * @description Lifecycle of a keyed (multi-turn) session — the durable conversation.
+         *     Distinct from AgentSessionStatus, which is per-execution (one turn's run) and
+         *     moves to agent_turns in a later slice. IDLE: alive, waiting for the next
+         *     message. RUNNING: a turn is executing. CLOSED: the conversation is done and
+         *     its sandbox/snapshots are torn down.
+         * @enum {string}
+         */
+        SessionState: 'idle' | 'running' | 'closed';
+        /**
+         * SessionSurface
+         * @description The three fields we expose. All `None` for an un-keyed (laptop) session.
+         *
+         *     `use_enum_values=True` (from CustomBaseModel) stores the members as their
+         *     string values, so this serializes to `{"session": "alive", "run": "waiting",
+         *     "status": "waiting"}` — a plain object, not enum names.
+         */
+        SessionSurface: {
+            run: components['schemas']['RunStatus'] | null;
+            session: components['schemas']['SessionLiveness'] | null;
+            /** Status */
+            status: string | null;
+        };
+        /** TokensInfo */
+        TokensInfo: {
+            /**
+             * Cache Creation Input Tokens
+             * @default 0
+             */
+            cache_creation_input_tokens: number;
+            /**
+             * Cache Read Input Tokens
+             * @default 0
+             */
+            cache_read_input_tokens: number;
+            /**
+             * Cost Usd
+             * @default 0
+             */
+            cost_usd: number;
+            /**
+             * Initial System Prompt Tokens
+             * @default 0
+             */
+            initial_system_prompt_tokens: number;
+            /**
+             * Input Tokens
+             * @default 0
+             */
+            input_tokens: number;
+            /**
+             * Num Turns
+             * @default 0
+             */
+            num_turns: number;
+            /**
+             * Output Tokens
+             * @default 0
+             */
+            output_tokens: number;
+            /**
+             * Per Model
+             * @default {}
+             */
+            per_model: {
+                [key: string]: components['schemas']['ModelTokensInfo'];
+            };
+            /**
+             * Per Turn
+             * @default []
+             */
+            per_turn: components['schemas']['TurnTokensInfo'][];
+            /**
+             * Thinking Tokens
+             * @default 0
+             */
+            thinking_tokens: number;
+        };
+        /** TurnTokensInfo */
+        TurnTokensInfo: {
+            /**
+             * Cache Creation Input Tokens
+             * @default 0
+             */
+            cache_creation_input_tokens: number;
+            /**
+             * Cache Read Input Tokens
+             * @default 0
+             */
+            cache_read_input_tokens: number;
+            /**
+             * Input Tokens
+             * @default 0
+             */
+            input_tokens: number;
+            /**
+             * Output Tokens
+             * @default 0
+             */
+            output_tokens: number;
+        };
+        /** ValidationError */
+        ValidationError: {
+            /** Context */
+            ctx?: Record<string, never>;
+            /** Input */
+            input?: unknown;
+            /** Location */
+            loc: (string | number)[];
+            /** Message */
+            msg: string;
+            /** Error Type */
+            type: string;
+        };
+        /**
+         * WebhookType
+         * @enum {string}
+         */
+        WebhookType: 'github.issue' | 'github.issue_comment' | 'github.push' | 'github.pull_request' | 'github.pull_request_comment' | 'github.pull_request_review' | 'github.pull_request_review_comment' | 'slack.app_mention' | 'slack.message' | 'slack.channel_created' | 'linear.issue' | 'linear.issue_comment' | 'sentry.event_alert' | 'sentry.metric_alert' | 'user.message';
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+interface operations {
+    get_agent_session_v1_sessions__session_id__get: {
+        parameters: {
+            query?: never;
+            header?: {
+                'user-agent'?: string | null;
+            };
+            path: {
+                session_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['AgentSessionWire'];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['HTTPValidationError'];
+                };
+            };
+        };
+    };
+    send_agent_session_message_v1_sessions__session_id__messages_post: {
+        parameters: {
+            query?: never;
+            header?: {
+                'user-agent'?: string | null;
+            };
+            path: {
+                session_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                'application/json': components['schemas']['SendSessionMessageRequest'];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['SessionMessageWire'];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['HTTPValidationError'];
+                };
+            };
+        };
+    };
+    get_agent_session_records_v1_sessions__session_id__records_get: {
+        parameters: {
+            query?: {
+                after_seq?: number;
+                limit?: number | null;
+            };
+            header?: {
+                'user-agent'?: string | null;
+            };
+            path: {
+                session_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['ListSessionRecordsResponse'];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['HTTPValidationError'];
+                };
+            };
+        };
+    };
+    get_agent_session_turns_v1_sessions__session_id__turns_get: {
+        parameters: {
+            query?: never;
+            header?: {
+                'user-agent'?: string | null;
+            };
+            path: {
+                session_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['ListSessionTurnsResponse'];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['HTTPValidationError'];
+                };
+            };
+        };
+    };
+}
+
+/**
+ * One server-to-client frame of the Ellipsis session stream protocol v2 (WS /v1/sessions/{id}/stream?protocol=2). Clients MUST ignore frames with unknown `type` values — additive frames are not a protocol break.
+ */
+type SessionStreamFrame = SnapshotFrame | RecordsAppendFrame | MessagesFrame | SessionFrame | DeltaFrame | HeartbeatFrame | DoneFrame | ErrorFrame;
+type AttributionType = 'github_user' | 'linear_user' | 'slack_user' | 'api_key';
+type SessionMessageStatus = 'pending' | 'delivered';
+type GithubAccountType = 'User' | 'Organization' | 'Bot' | 'Mannequin';
+/**
+ * How a session that arrived with no explicit config source resolved its
+ * config (documents/eng/DEFAULT_CONFIGS.md §4). Persisted on the session so
+ * audit and clients can say "ran under X (repo default)". A session started
+ * with an explicit config/config_id/template_id never enters resolution and
+ * stores None.
+ */
+type DefaultResolution = 'repo_default' | 'account_default' | 'none';
+/**
+ * Why a terminal agent session ended — a finer-grained reason than `status`.
+ *
+ * `status` (AgentSessionStatus) is the lifecycle state: COMPLETED / ERROR /
+ * CANCELLED. `exit_status` explains *why* a run reached that terminal state, so
+ * the UI and metrics can tell a budget cutoff apart from a crashed tool call or
+ * a deliberate cancellation. It is None until the run reaches a terminal state.
+ */
+type AgentSessionExitStatus = 'completed' | 'budget_hit' | 'payment_required' | 'tool_call_failed' | 'lifecycle_hook_failed' | 'missing_repo_access' | 'missing_token_permissions' | 'cancelled' | 'interrupted' | 'error' | 'stopped';
+type Harness = 'claude_code';
+/**
+ * How a session relates to its predecessor (parent_agent_session_id) —
+ * the ONE "preceded-by" chain for every predecessor relationship. Routing
+ * reads this when the distinction matters.
+ *
+ * CONTINUATION — a follow-up in the same conversation surface (e.g. a Slack
+ * thread reply spawning a fresh session on the same thread).
+ * HANDOFF — a session started to take over work from another surface (e.g.
+ * laptop → cloud handoff; later phase).
+ * RESUME — a conversation re-hosted on a new box after its sandbox was torn
+ * down (interactive platform; later phase).
+ */
+type ParentKind = 'continuation' | 'handoff' | 'resume';
+/**
+ * Which layer actually determined the enforced budget.
+ *
+ * Not derivable from the run row alone (the run does not store the config
+ * cents or the customer default), so we persist it for the UI / audit.
+ */
+type BudgetSource = 'system' | 'account' | 'config' | 'run';
+/**
+ * Lifecycle of a keyed (multi-turn) session — the durable conversation.
+ * Distinct from AgentSessionStatus, which is per-execution (one turn's run) and
+ * moves to agent_turns in a later slice. IDLE: alive, waiting for the next
+ * message. RUNNING: a turn is executing. CLOSED: the conversation is done and
+ * its sandbox/snapshots are torn down.
+ */
+type SessionState = 'idle' | 'running' | 'closed';
+type AgentSessionSource = 'react' | 'manual' | 'api' | 'cli' | 'mention' | 'cron' | 'laptop';
+type AgentSessionStatus = 'scheduled' | 'creating_sandbox' | 'running' | 'retrying' | 'completed' | 'error' | 'cancelled' | 'stopped';
+/**
+ * What the current (or most recent) execution is doing (backs `run`).
+ */
+type RunStatus = 'scheduled' | 'starting' | 'working' | 'waiting' | 'done' | 'failed' | 'stopped' | 'cancelled' | 'retrying';
+/**
+ * The durable conversation axis (backs the surfaced `session` field).
+ */
+type SessionLiveness = 'alive' | 'sleeping' | 'closed';
+type WebhookType = 'github.issue' | 'github.issue_comment' | 'github.push' | 'github.pull_request' | 'github.pull_request_comment' | 'github.pull_request_review' | 'github.pull_request_review_comment' | 'slack.app_mention' | 'slack.message' | 'slack.channel_created' | 'linear.issue' | 'linear.issue_comment' | 'sentry.event_alert' | 'sentry.metric_alert' | 'user.message';
+/**
+ * First frame after accept. Lean: session + open inbox only — records
+ * always arrive via records_append (§3.4).
+ */
+interface SnapshotFrame {
+    earliest_feed_seq: number | null;
+    messages: SessionMessageWire[];
+    protocol: number;
+    session: AgentSessionWire;
+    type: 'snapshot';
+}
+/**
+ * The wire shape of one inbox message (§3.3): what a queued chip renders
+ * and retires on. `author` is the message's attribution string; the webhook
+ * provenance internals stay off the wire.
+ */
+interface SessionMessageWire {
+    agent_session_id: string;
+    author: string | null;
+    body: string;
+    created_at: string;
+    delivered_at: string | null;
+    delivered_turn_id: string | null;
+    feed_seq: number | null;
+    id: string;
+    sender_attribution_id: string | null;
+    sender_attribution_type: AttributionType | null;
+    status: SessionMessageStatus;
+}
+interface AgentSessionWire {
+    agent_config_id: string | null;
+    attributed_user: GithubAccountSnippet | null;
+    attribution_id: string | null;
+    attribution_type: AttributionType | null;
+    client_version: string | null;
+    config_override: {
+        [k: string]: unknown;
+    } | null;
+    context_repository: string | null;
+    cost_fee: number;
+    cost_sandbox_cpu: number;
+    cost_sandbox_memory: number;
+    cost_tokens: number;
+    created_at: string;
+    customer_id: string;
+    default_resolution: DefaultResolution | null;
+    exit_status: AgentSessionExitStatus | null;
+    harness: Harness;
+    id: string;
+    last_activity_at: string | null;
+    last_message_at: string | null;
+    live_summary: string | null;
+    metadata: {
+        [k: string]: string;
+    };
+    output_prs: AgentSessionPr[] | null;
+    parent_agent_session_id: string | null;
+    parent_kind: ParentKind | null;
+    prompt: string | null;
+    replayed_from_session_id: string | null;
+    resolved_budget_cents: number;
+    resolved_budget_source: BudgetSource;
+    sandbox_id: string | null;
+    session_key: string | null;
+    session_state: SessionState | null;
+    source: AgentSessionSource;
+    status: AgentSessionStatus;
+    status_reason: string | null;
+    stopped_at: string | null;
+    stopped_by: number | null;
+    stopped_by_user: GithubAccountSnippet | null;
+    surface: SessionSurface | null;
+    tokens_cache_creation: number;
+    tokens_cache_read: number;
+    tokens_input: number;
+    tokens_model: string;
+    tokens_output: number;
+    tokens_total: number;
+    updated_at: string;
+    webhook_id: string | null;
+    webhook_type: WebhookType | 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;
+}
+/**
+ * A pull request this session created, denormalized at capture time so
+ * session surfaces render a labeled link without joining gh_prs. Live PR
+ * state (open/merged/closed) is not stored here — read it from gh_prs where
+ * a view needs it.
+ */
+interface AgentSessionPr {
+    gh_pr_id: number | null;
+    number: number;
+    repo_full_name: string;
+    url: string;
+}
+/**
+ * The three fields we expose. All `None` for an un-keyed (laptop) session.
+ *
+ * `use_enum_values=True` (from CustomBaseModel) stores the members as their
+ * string values, so this serializes to `{"session": "alive", "run": "waiting",
+ * "status": "waiting"}` — a plain object, not enum names.
+ */
+interface SessionSurface {
+    run: RunStatus | null;
+    session: SessionLiveness | null;
+    status: string | null;
+}
+/**
+ * Cursored append-only: raw records ordered by feed_seq, all sources.
+ * Every record in the frame advances the resume cursor — including ones a
+ * client renders as nothing (§3.4).
+ */
+interface RecordsAppendFrame {
+    records: SessionRecordWire[];
+    type: 'records_append';
+}
+/**
+ * The wire shape of one session record (§3.3): the §3.6 stable envelope +
+ * the native `payload`, by explicit allowlist. Internal-only columns
+ * (`search_text`, `clis`, ingest bookkeeping, attribution denormalizations)
+ * are deliberately absent so internal model evolution stays free.
+ */
+interface SessionRecordWire {
+    agent_session_id: string;
+    agent_turn_id: string | null;
+    cost: number | null;
+    created_at: string;
+    duration: number | null;
+    feed_seq: number;
+    id: string;
+    model: string | null;
+    payload: {
+        [k: string]: unknown;
+    };
+    record_format: string;
+    record_type: string;
+    session_message_id: string | null;
+    /**
+     * Who wrote the record. Known values: claude_code (a native harness transcript record) | lifecycle (a platform notification). Open vocabulary: ignore records with unknown sources.
+     */
+    source: string;
+    stream_seq: number;
+    tokens_info: TokensInfo | null;
+    tools: string[] | null;
+}
+interface TokensInfo {
+    cache_creation_input_tokens: number;
+    cache_read_input_tokens: number;
+    cost_usd: number;
+    initial_system_prompt_tokens: number;
+    input_tokens: number;
+    num_turns: number;
+    output_tokens: number;
+    per_model: {
+        [k: string]: ModelTokensInfo;
+    };
+    per_turn: TurnTokensInfo[];
+    thinking_tokens: number;
+}
+interface ModelTokensInfo {
+    cache_creation_input_tokens: number;
+    cache_read_input_tokens: number;
+    cost_usd: number;
+    input_tokens: number;
+    output_tokens: number;
+}
+interface TurnTokensInfo {
+    cache_creation_input_tokens: number;
+    cache_read_input_tokens: number;
+    input_tokens: number;
+    output_tokens: number;
+}
+/**
+ * LWW snapshot of the OPEN inbox slice: all PENDING rows plus rows that
+ * flipped (delivered, re-pended) within this connection since the last frame.
+ * Deliberately not the full message history — delivered rows render through
+ * their transcript user-echo records; structural history stays on REST
+ * /turns (§3.3).
+ */
+interface MessagesFrame {
+    messages: SessionMessageWire[];
+    type: 'messages';
+}
+/**
+ * LWW snapshot of the enriched public session (§4.1) — the only way
+ * status/state/cost arrive. Resent whole on any field change.
+ */
+interface SessionFrame {
+    session: AgentSessionWire;
+    type: 'session';
+}
+/**
+ * Fire-and-forget partial assistant output for the current response.
+ * No seq, never resumable; superseded by the committed record.
+ */
+interface DeltaFrame {
+    agent_turn_id: string | null;
+    /**
+     * What the partial text is. Known values: text ('thinking' reserved). Open vocabulary: ignore deltas with unknown kinds.
+     */
+    kind: string;
+    output_tokens: number | null;
+    text: string | null;
+    type: 'delta';
+}
+/**
+ * Sent after HEARTBEAT_SECONDS of idleness; doubles as the dead-socket
+ * probe.
+ */
+interface HeartbeatFrame {
+    ts: string;
+    type: 'heartbeat';
+}
+/**
+ * Terminal marker: the conversation is over, after the final session frame
+ * carried the end state. Followed by close 1000.
+ */
+interface DoneFrame {
+    type: 'done';
+}
+/**
+ * Terminal error marker, before close 1011. Curated copy only.
+ */
+interface ErrorFrame {
+    message: string;
+    type: 'error';
+}
+
+type StreamFrame = SessionStreamFrame | {
+    type: string;
+    [key: string]: unknown;
+};
+type SendSessionMessageRequest = components['schemas']['SendSessionMessageRequest'];
+type ListSessionRecordsResponse = components['schemas']['ListSessionRecordsResponse'];
+type ListSessionTurnsResponse = components['schemas']['ListSessionTurnsResponse'];
+type AgentTurn = components['schemas']['AgentTurn'];
+type AgentTurnStatus = components['schemas']['AgentTurnStatus'];
+
+export type { AgentSessionWire as A, BudgetSource as B, DefaultResolution as D, ErrorFrame as E, GithubAccountSnippet as G, Harness as H, ListSessionRecordsResponse as L, MessagesFrame as M, ParentKind as P, RecordsAppendFrame as R, SessionMessageWire as S, TokensInfo as T, ListSessionTurnsResponse as a, AgentSessionExitStatus as b, AgentSessionPr as c, AgentSessionSource as d, AgentSessionStatus as e, AgentTurn as f, AgentTurnStatus as g, AttributionType as h, DeltaFrame as i, DoneFrame as j, GithubAccountType as k, HeartbeatFrame as l, ModelTokensInfo as m, SendSessionMessageRequest as n, SessionFrame as o, SessionLiveness as p, SessionMessageStatus as q, SessionRecordWire as r, SessionState as s, SessionStreamFrame as t, SessionSurface as u, SnapshotFrame as v, StreamFrame as w, TurnTokensInfo as x, components as y, paths as z };