@deepnoodle/mobius 0.0.28 → 0.0.29

package/dist/api/schema.d.ts

@@ -83,7 +83,7 @@ export interface paths {
         post?: never;
         /**
          * Delete action
-         * @description Deletes a project-owned custom action definition. Loops that still reference the action block deletion until the reference is removed.
+         * @description Deletes a project-owned custom action definition. Runnable loop specs that still reference the action block deletion with `409 Conflict` until the reference is removed.
          */
         delete: operations["deleteAction"];
         options?: never;
@@ -235,6 +235,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/projects/{project_handle}/catalog/worker-models": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List worker models
+         * @description Returns local LLM models currently advertised by online project workers. Each item includes the exact `model_route` object to assign to an agent or loop step. Matching is exact on `provider` and `model`; queues are not part of the standard local LLM path.
+         */
+        get: operations["listCatalogWorkerModels"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/projects/{project_handle}/environments": {
         parameters: {
             query?: never;
@@ -473,6 +493,96 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/projects/{project_handle}/interactions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List interactions
+         * @description Returns interactions newest-first, optionally filtered by kind, status, run, target, or the current caller's inbox. Inbox filtering includes direct targets.
+         */
+        get: operations["listInteractions"];
+        put?: never;
+        /**
+         * Create interaction
+         * @description Creates a standalone or run-backed interaction. Run-backed interactions emit an `interaction.responded` event when completed; omit `run_id` and `signal_name` for interactions with no loop-run side effect.
+         */
+        post: operations["createInteraction"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/projects/{project_handle}/interactions/{resource_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get interaction
+         * @description Returns one interaction with target, response, and completion metadata. Run-backed interactions include the run and signal identifiers used to resume loop execution.
+         */
+        get: operations["getInteraction"];
+        put?: never;
+        post?: never;
+        /**
+         * Delete interaction
+         * @description Deletes an interaction so it disappears from inbox and project listings. The row is retained for audit history. Only terminal interactions (`completed`, `cancelled`, `expired`) may be deleted; pending or in-review interactions must be cancelled first so any waiting loop run can route to a fallback.
+         */
+        delete: operations["deleteInteraction"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/projects/{project_handle}/interactions/{resource_id}/respond": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Respond to interaction
+         * @description Canonical response endpoint for every interaction kind. `action` defaults to `submit`; lifecycle operations beyond submit are not part of the launch model.
+         *
+         *     The request body is intentionally the same envelope for every kind: `action`, `value`, and `comment`. Kind-specific behavior is selected from the interaction itself, not from separate request-body shapes.
+         */
+        post: operations["respondToInteraction"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/projects/{project_handle}/interactions/{resource_id}/cancel": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Cancel open interaction
+         * @description Cancels an open interaction, recording who cancelled and an optional reason. Run-backed interactions resume the waiting loop step with a `{status: cancelled, reason}` signal payload so loops can route to a fallback. Only humans may cancel by default — agents must request cancellation through an interaction.
+         */
+        post: operations["cancelInteraction"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/projects/{project_handle}/agents": {
         parameters: {
             query?: never;
@@ -513,7 +623,7 @@ export interface paths {
         post?: never;
         /**
          * Delete agent
-         * @description Deletes the agent from normal use. The agent record is retained for audit and attribution history, but the agent is excluded from all listings and lookups. The agent's machine principal is disabled. In-flight jobs claiming this agent are not automatically cancelled.
+         * @description Deletes the agent from normal use. The agent record is retained for audit and attribution history, but the agent is excluded from all listings and lookups. The agent's backing machine principal is archived for attribution history. In-flight jobs claiming this agent are not automatically cancelled.
          */
         delete: operations["deleteAgent"];
         options?: never;
@@ -545,7 +655,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/v1/projects/{project_handle}/turns/{resource_id}/messages": {
+    "/v1/projects/{project_handle}/turns/{turn_id}/messages": {
         parameters: {
             query?: never;
             header?: never;
@@ -677,6 +787,92 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/projects/{project_handle}/agents/{resource_id}/memory": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get agent memory
+         * @description Returns a summary of the agent's private memory: how many entries it holds, a breakdown by kind, and when it last changed. Each agent has its own durable memory; only that agent reads or writes it during runs, but project members can observe and edit it here.
+         */
+        get: operations["getAgentMemory"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/projects/{project_handle}/agents/{resource_id}/memory/entries": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List agent memory entries
+         * @description Lists the entries in an agent's private memory, each a keyed, durable memory the agent remembered. Pass `query` to keyword-search over keys and content, and `kind` to filter to one kind. Returns an empty page when the agent has no memory yet.
+         */
+        get: operations["listAgentMemoryEntries"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/projects/{project_handle}/agents/{resource_id}/memory/entries/{memory_key}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /**
+         * Create or update a memory entry
+         * @description Creates or updates the memory entry identified by `memory_key`. Editing an agent's memory here is equivalent to the agent calling `mobius.memory.remember`. Provisions the store on first write.
+         */
+        put: operations["putAgentMemoryEntry"];
+        post?: never;
+        /**
+         * Delete a memory entry
+         * @description Deletes the memory entry identified by `memory_key`, equivalent to the agent calling `mobius.memory.forget`. Idempotent: succeeds even if no such entry exists.
+         */
+        delete: operations["deleteAgentMemoryEntry"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/projects/{project_handle}/agents/invoke": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Invoke an agent
+         * @description One compound runtime call for hosted apps: it resolves an agent, resolves or creates a session by `session_key`, appends the caller's input message, and starts an agent turn — collapsing the create-or-resolve-session plus start-turn sequence into a single retryable request. This is the entry point a product backend (an embedded app, a Slack handler, a Telegram bot) calls per inbound message; the lower-level session and turn APIs remain available for finer control.
+         *
+         *     By default it returns `202 Accepted` immediately with a durable `after_sequence` stream cursor; the turn keeps running even if the caller disconnects. When the request sets `Accept: text/event-stream`, the response is `200 OK` and the turn's activity is streamed inline on the same connection, identical to the `POST /v1/projects/{project_handle}/sessions/{session_id}/turns` stream. A repeated call with the same `input.idempotency_key` resolves the same session and resumes the existing turn rather than starting a second one, so a webhook handler can acknowledge fast and retry safely. Requires the `mobius.agent.invoke` permission (or the agent's own backing principal).
+         */
+        post: operations["invokeAgent"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/projects/{project_handle}/sessions": {
         parameters: {
             query?: never;
@@ -701,7 +897,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/v1/projects/{project_handle}/sessions/{resource_id}": {
+    "/v1/projects/{project_handle}/sessions/{session_id}": {
         parameters: {
             query?: never;
             header?: never;
@@ -729,7 +925,7 @@ export interface paths {
         patch: operations["updateSession"];
         trace?: never;
     };
-    "/v1/projects/{project_handle}/sessions/{resource_id}/messages": {
+    "/v1/projects/{project_handle}/sessions/{session_id}/messages": {
         parameters: {
             query?: never;
             header?: never;
@@ -738,7 +934,7 @@ export interface paths {
         };
         /**
          * List session messages
-         * @description Returns raw session messages in sequence order for replay.
+         * @description Returns a page of session transcript messages. The page is sequence-anchored and bidirectional: `after_sequence` pages forward (newer), `before_sequence` pages backward (older), and `order=desc` fetches the newest messages — the tail of a long session — in a single request. Items are always returned ascending by `sequence`; the response carries both `next_sequence` (forward cursor) and `prev_sequence` (backward cursor).
          */
         get: operations["listSessionMessages"];
         put?: never;
@@ -753,7 +949,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/v1/projects/{project_handle}/sessions/{resource_id}/turns": {
+    "/v1/projects/{project_handle}/sessions/{session_id}/turns": {
         parameters: {
             query?: never;
             header?: never;
@@ -762,10 +958,34 @@ export interface paths {
         };
         /**
          * List session turns
-         * @description Returns the session's turns in chronological order. Each turn groups related transcript messages and includes links to any run step or channel exchange that produced it.
+         * @description Returns the session's turns, the structure the turn-grouped transcript is built on. Each turn groups related transcript messages and includes links to any run step or channel exchange that produced it. Turns are ordered by creation time; `order=desc` returns the newest turns (the tail) first, and long sessions are walked page-by-page via the `next_cursor` returned in the response. Pass `ids` to fetch exactly a known set of turns in one bounded request — the join a transcript view uses to resolve a loaded message window's `turn_id`s to their headers; when `ids` is set the cursor and order parameters are ignored.
          */
         get: operations["listSessionTurns"];
         put?: never;
+        /**
+         * Start an agent turn
+         * @description Appends one caller input message to the session and starts an agent turn to respond. By default returns `202 Accepted` immediately with a durable `after_sequence` cursor (a message `sequence`) to stream from. The turn keeps running even if the caller disconnects. When the request sets `Accept: text/event-stream`, the response is `200 OK` and the turn's activity is streamed inline on the same connection, equivalent to opening `GET .../stream` at the returned cursor. A repeated call with the same `idempotency_key` resumes the existing turn rather than starting a second one. Requires the `mobius.agent.invoke` permission (or the agent's own backing principal).
+         */
+        post: operations["startTurn"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/projects/{project_handle}/sessions/{session_id}/turns/{turn_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get a session turn
+         * @description Returns one agent turn in the session.
+         */
+        get: operations["getSessionTurn"];
+        put?: never;
         post?: never;
         delete?: never;
         options?: never;
@@ -773,7 +993,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/v1/projects/{project_handle}/sessions/{resource_id}/events.stream": {
+    "/v1/projects/{project_handle}/sessions/{session_id}/turns/{turn_id}/live": {
         parameters: {
             query?: never;
             header?: never;
@@ -781,10 +1001,10 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Stream session events
-         * @description Streams Server-Sent Events for a conversation session. Durable lifecycle events (`user.message`, `session.status_running`, `agent.message`, `agent.tool_use`, `agent.tool_result`, and the terminal `session.status_*` events) are replayed from the durable log and then tailed live, so a client reconnecting with `?after_sequence=N` (or the `Last-Event-ID` header) resumes exactly where it left off. The stream closes after the terminal event for the active invocation is delivered. Live-only `generation.delta` frames are interleaved best-effort.
+         * Get live session turn snapshot
+         * @description Returns the process-local, live-only transcript preview frames currently known for an in-flight turn. This is an ephemeral recovery primitive for SSE reconnects and `live_sequence` gaps; it is not a durable event log replay endpoint and may return an empty frame list after process handoff or once the durable transcript has caught up.
          */
-        get: operations["streamSessionEvents"];
+        get: operations["getSessionTurnLive"];
         put?: never;
         post?: never;
         delete?: never;
@@ -793,7 +1013,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/v1/projects/{project_handle}/sessions/{resource_id}/events": {
+    "/v1/projects/{project_handle}/sessions/{session_id}/turns/{turn_id}/cancel": {
         parameters: {
             query?: never;
             header?: never;
@@ -803,17 +1023,43 @@ export interface paths {
         get?: never;
         put?: never;
         /**
-         * Send input to a session
-         * @description Appends one input message to a session and starts an agent invocation to respond, returning `202 Accepted` immediately with a durable `seq` cursor to stream from — the work continues even if the caller disconnects. A repeated send with the same `idempotency_key` returns the existing invocation's cursor without starting a second invocation or appending a second input message. Requires the `mobius.agent.invoke` permission (or the agent's own backing principal).
+         * Cancel a session turn
+         * @description Cancels one agent turn in the session if it is still active. The turn is marked cancelled and a terminal `turn.cancelled` event is emitted. Returns the updated turn. Requires the `mobius.agent.invoke` permission (or the agent's own backing principal).
+         */
+        post: operations["cancelTurn"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/projects/{project_handle}/sessions/{session_id}/stream": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Stream a session's activity
+         * @description Opens a long-lived Server-Sent Events stream that is a live view over the session's one durable conversation log (its transcript messages). It is the single streaming surface for a session.
+         *
+         *     The transcript messages with `sequence > after_sequence` are replayed first — covering any turn that committed between the client's last read and the stream open — then the in-flight turn is tailed live. Each committed message is framed as `event: <type>` (`user.message`, `agent.message`, or the non-terminal `compaction.created`) with a `data:` line carrying the message payload and an `id:` line carrying the message `sequence`. The cursor is therefore the same `sequence` the messages API uses: reconnect with `?after_sequence=N` (or the `Last-Event-ID` header) to resume exactly where you left off, with no separate event cursor.
+         *
+         *     The stream follows the session's active turn and closes once the session is idle — no queued or running turn — after the active turn's committed rows and a terminal `turn.completed` / `turn.failed` / `turn.cancelled` frame have been delivered. A later turn is a new activity tail; open a new stream for it or use the streaming `POST .../turns` response.
+         *
+         *     Live-only `generation.delta`, `session.message.preview`, `session.resync`, `tool.call`, and `tool.result` frames carry no `id:`, are interleaved best-effort for low-latency rendering, and are never persisted or replayed — on reconnect the durable message frames are the source of truth.
          */
-        post: operations["sendSessionEvents"];
+        get: operations["streamSession"];
+        put?: never;
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/v1/projects/{project_handle}/sessions/{resource_id}/cancel": {
+    "/v1/projects/{project_handle}/sessions/{session_id}/cancel": {
         parameters: {
             query?: never;
             header?: never;
@@ -823,8 +1069,8 @@ export interface paths {
         get?: never;
         put?: never;
         /**
-         * Cancel a session's active invocation
-         * @description Cancels the session's in-flight invocation. Queued and running grains for the session are marked cancelled and a terminal `session.status_cancelled` event is emitted. Returns the updated session. Requires the `mobius.agent.invoke` permission (or the agent's own backing principal).
+         * Cancel the session's active turn
+         * @description Cancels whichever turn is currently active in the session. Queued and running turns for the session are marked cancelled and a terminal `turn.cancelled` event is emitted. Returns the updated session. Requires the `mobius.agent.invoke` permission (or the agent's own backing principal).
          */
         post: operations["cancelSession"];
         delete?: never;
@@ -833,6 +1079,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/projects/{project_handle}/sessions/{session_id}/compact": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Compact the session transcript now
+         * @description Forces a compaction pass immediately, summarizing every message appended since the last compaction regardless of the session's configured strategy or token threshold. This is the manual counterpart to the `auto` strategy and the way to drive the `manual` strategy. It is a no-op when there is nothing new to compact. Returns the updated session. Requires the `mobius.agent.invoke` permission (or the agent's own backing principal).
+         */
+        post: operations["compactSession"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/projects/{project_handle}/loops": {
         parameters: {
             query?: never;
@@ -1013,8 +1279,10 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * List run events
+         * List or stream run events
          * @description Returns the durable event log for one run, ordered by sequence number. Use `after_sequence` to poll only events recorded after the last sequence the client has observed.
+         *
+         *     Content-negotiated: with `Accept: text/event-stream` this opens a long-lived Server-Sent Events stream instead of returning a JSON page: durable events are replayed from `after_sequence` and then tailed live, and the stream closes after the run is terminal and the server has drained all durable events committed before or with that terminal state. Reconnect with `?after_sequence=N` (or the `Last-Event-ID` header) to resume.
          */
         get: operations["listRunEvents"];
         put?: never;
@@ -1025,26 +1293,6 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/v1/projects/{project_handle}/runs/{resource_id}/events.stream": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        /**
-         * Stream run events
-         * @description Long-lived SSE stream of run events ordered by sequence number. Each `data:` frame is a JSON-encoded `LoopRunEvent`. The stream terminates when the run reaches a terminal status. Clients that disconnect should reconnect using `?after_sequence=N` (or the SSE `Last-Event-ID` header set to the last sequence) to resume without gaps.
-         */
-        get: operations["streamRunEvents"];
-        put?: never;
-        post?: never;
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
     "/v1/projects/{project_handle}/runs/{resource_id}/signals": {
         parameters: {
             query?: never;
@@ -1236,7 +1484,7 @@ export interface paths {
         head?: never;
         /**
          * Update table
-         * @description Updates table metadata or schema and resyncs declared indexes.
+         * @description Updates table metadata or schema. A table's identity column, secondary key column, and required column settings are immutable after creation.
          */
         patch: operations["updateTable"];
         trace?: never;
@@ -1312,7 +1560,7 @@ export interface paths {
         put?: never;
         /**
          * Search rows
-         * @description Token-prefix search over row data within one table. Punctuation, including hyphens, splits terms: searching `from-ui` matches a value like `from-ui-insert` because the `from` and `ui` tokens match. Optional field filters use the same syntax as row queries and are applied before text search.
+         * @description Search rows within one table using keyword, semantic, or hybrid mode. Keyword matching is token-prefix based. Punctuation, including hyphens, splits terms: searching `from-ui` matches a value like `from-ui-insert` because the `from` and `ui` tokens match. Optional field filters use the same syntax as row queries and are applied before search.
          */
         post: operations["searchTableRows"];
         delete?: never;
@@ -1511,6 +1759,44 @@ export interface components {
                 };
             };
         };
+        /** @description Event-type-specific payload for less common event types. */
+        GenericEventPayload: {
+            [key: string]: unknown;
+        };
+        /** @description Live-only token preview frame that can appear on run and session SSE streams. It is not persisted, does not carry an SSE `id:`, and cannot be replayed with `after_sequence` or `Last-Event-ID`. */
+        GenerationDeltaFrame: {
+            /** @enum {string} */
+            event_type: "generation.delta";
+            run_id?: string | null;
+            session_id?: string | null;
+            turn_id?: string | null;
+            job_id?: string | null;
+            tool_call_id?: string | null;
+            /**
+             * Format: int64
+             * @description Monotonic per-turn sequence across all live-only session frames; use to detect dropped live frames.
+             */
+            live_sequence?: number | null;
+            /**
+             * Format: int64
+             * @description Publisher-local ordering hint for deltas within a turn, not a replay cursor.
+             */
+            delta_sequence?: number | null;
+            /**
+             * Format: date-time
+             * @description Server timestamp when this live preview frame was emitted.
+             */
+            emitted_at?: string | null;
+            /** @description Token preview payload, usually `{ "text": "..." }`. */
+            delta: {
+                [key: string]: unknown;
+            };
+            worker_id?: string | null;
+            /** @description Model producing the generation, e.g. `claude-sonnet-4-6`. */
+            model?: string | null;
+        } & {
+            [key: string]: unknown;
+        };
         /**
          * @description Optional namespace for named runtime resources. Omitted/null means the project/default scope; `owner` means names are unique within `(project, owned_by)`.
          * @enum {string}
@@ -1602,18 +1888,40 @@ export interface components {
             mode: components["schemas"]["AgentModelRouteMode"];
             /** @description Environment to use for worker-backed model calls. */
             environment_id?: string;
-            /** @description Provider or worker route name. */
+            /** @description Provider id advertised by a local worker when `mode` is `worker`. */
             provider?: string;
             /** @description Model identifier to use for this route. */
             model?: string;
-            /** @description Worker queue for customer-worker model calls. */
-            queue?: string;
         };
         /**
          * @description Controls how granted actions are surfaced to the model in Mobius-hosted agent turns. `meta` (the default) groups related actions behind compact command routers, while `flat` exposes one tool per action.
          * @enum {string}
          */
         AgentToolPresentation: "flat" | "meta";
+        /**
+         * @description T-shirt size selecting when `auto` compaction triggers, smallest (`xs`, compact very early) to largest (`xl`, compact very late). The server maps each size to a token estimate; `sm` is the default.
+         * @enum {string}
+         */
+        SessionCompactionThreshold: "xs" | "sm" | "md" | "lg" | "xl";
+        /**
+         * @description Controls how a session's transcript is automatically summarized as it grows. On create the supplied fields are merged over the owning agent's default policy and the server defaults; on update they patch the session's current policy. Omitted fields keep their resolved values.
+         * @example {
+         *       "strategy": "auto",
+         *       "threshold": "sm",
+         *       "summary_model": "claude-haiku-4-5-20251001"
+         *     }
+         */
+        SessionCompactionPolicy: {
+            /**
+             * @description `auto` (default) compacts automatically when the transcript crosses the `threshold` size. `manual` only compacts on an explicit compact request. `disabled` (alias `none`) never compacts.
+             * @enum {string}
+             */
+            strategy?: "auto" | "manual" | "disabled" | "none";
+            /** @description Size at which `auto` compacts. A t-shirt size (`xs`–`xl`) rather than a raw token count, because the transcript size it gates on is an estimate. The size → token mapping is server-owned; `sm` is the default and the per-size token estimate is documented separately. */
+            threshold?: components["schemas"]["SessionCompactionThreshold"];
+            /** @description Model used to produce compaction summaries. */
+            summary_model?: string;
+        };
         /**
          * @description AI actor identity. An agent IS a principal (its permissions are role grants on that principal); agents are useful when loops need a named actor with instructions, configuration, and session presence.
          * @example {
@@ -1648,7 +1956,7 @@ export interface components {
             kind?: string;
             /** @description Display color for this agent in UI surfaces. One of the Mantine color palette keys (e.g. `indigo`, `teal`, `grape`); empty string falls back to a hash-derived color. */
             color?: string;
-            /** @description Model identifier for platform agents. Accepts any id returned by `GET /v1/projects/{project_handle}/catalog/models`, optionally `provider/`-prefixed (e.g. `xai/grok-4`); bare known ids (e.g. `claude-sonnet-4-6`) are auto-detected to their provider. Empty string falls back to the platform default. */
+            /** @description Model identifier for platform agents. Accepts any id returned by `GET /v1/projects/{project_handle}/catalog/models` (including slash-bearing OpenRouter catalog ids), optionally `provider/`-prefixed (e.g. `xai/grok-4`); bare known ids (e.g. `claude-sonnet-4-6`) are auto-detected to their provider. Empty string falls back to the platform default. */
             model?: string;
             /** @description Default route for model calls made by this agent. */
             model_route?: components["schemas"]["AgentModelRoute"];
@@ -1661,6 +1969,8 @@ export interface components {
              * @description Execution timeout, in seconds, for a single turn of this platform agent. `0` (or omitted) uses the platform default (600s / 10 minutes). A loop step's own timeout overrides this for that step.
              */
             timeout_seconds?: number;
+            /** @description Default session-compaction policy. New sessions opened against this agent inherit it (below server defaults, above explicit per-session overrides). Absent when the agent has no default. */
+            compaction_policy?: components["schemas"]["SessionCompactionPolicy"];
             /** @description Current agent status: `active` or `inactive`. */
             status: components["schemas"]["AgentStatus"];
             /** @description Inbox address provisioned via POST /v1/projects/{project_handle}/agents/{resource_id}/inbox (opt-in; not created automatically at agent creation). The field is populated only after a successful provisioning call. Use this address to add the agent as a member on external platforms (Linear, GitHub, Slack, etc.) so the platform can deliver notifications to the agent. */
@@ -2263,7 +2573,7 @@ export interface components {
         };
         /** @description Available model choices for one provider. */
         ModelProviderGroup: {
-            /** @description Canonical provider id (`anthropic`, `openai`, `gemini`, `xai`). */
+            /** @description Canonical provider id (`anthropic`, `openai`, `openrouter`, `gemini`, `xai`). */
             provider: string;
             /** @description Human-readable provider label. */
             display_name: string;
@@ -2277,7 +2587,7 @@ export interface components {
         };
         /** @description One selectable LLM model in the project model catalog. */
         ModelOption: {
-            /** @description Bare model id assigned to an agent's `model` field. */
+            /** @description Model id assigned to an agent's `model` field. Some catalog ids, such as OpenRouter slugs, include `/`. */
             id: string;
             /** @description Canonical provider id this model belongs to. */
             provider: string;
@@ -2288,13 +2598,34 @@ export interface components {
             /** @description Whether this is the suggested default for its provider. */
             recommended?: boolean;
         };
-        /**
-         * @description Backing provider: `sprites`, `cloudflare_containers`, or `worker`.
-         * @enum {string}
-         */
-        EnvironmentProvider: "sprites" | "cloudflare_containers" | "worker";
-        /**
-         * @description Providers the control plane can provision on demand: `sprites` or `cloudflare_containers`. Excludes `worker`: worker-provided environments are registered out-of-band via the attach endpoint and are never provisioned through create/acquire.
+        /** @description Local LLM models advertised by online project workers. */
+        WorkerModelCatalogResponse: {
+            items: components["schemas"]["WorkerModelCatalogItem"][];
+        };
+        /** @description One exact local model route available through online workers. */
+        WorkerModelCatalogItem: {
+            /** @description Worker-advertised provider id, matched exactly by `model_route.provider`. */
+            provider: string;
+            /** @description Worker-advertised model id, matched exactly by `model_route.model`. */
+            model: string;
+            /** @description Number of online workers currently advertising this exact provider/model pair. */
+            worker_count: number;
+            route: components["schemas"]["WorkerModelRoute"];
+        };
+        /** @description Assign this route to use a local worker model. */
+        WorkerModelRoute: {
+            /** @enum {string} */
+            mode: "worker";
+            provider: string;
+            model: string;
+        };
+        /**
+         * @description Backing provider: `sprites`, `cloudflare_containers`, or `worker`.
+         * @enum {string}
+         */
+        EnvironmentProvider: "sprites" | "cloudflare_containers" | "worker";
+        /**
+         * @description Providers the control plane can provision on demand: `sprites` or `cloudflare_containers`. Excludes `worker`: worker-provided environments are registered out-of-band via the attach endpoint and are never provisioned through create/acquire.
          * @enum {string}
          */
         ProvisionEnvironmentProvider: "sprites" | "cloudflare_containers";
@@ -2499,7 +2830,7 @@ export interface components {
             agent_turn_id?: string;
             session_id?: string;
             tool_call_id?: string;
-            /** @description Worker-specific action or generation payload. */
+            /** @description Worker-specific action or generation payload. For `kind=llm_generation`, this object follows `WorkerSocketLLMGenerationSpec`. */
             spec: {
                 [key: string]: unknown;
             };
@@ -2546,6 +2877,7 @@ export interface components {
              * @enum {string}
              */
             status: "completed" | "failed" | "cancelled";
+            /** @description Terminal result payload. For `llm_generation` jobs, this object must follow `WorkerSocketLLMGenerationResult`; plain text fallback results are not accepted. */
             result?: {
                 [key: string]: unknown;
             };
@@ -2844,6 +3176,362 @@ export interface components {
             /** @description Round-trip latency in milliseconds. */
             latency_ms?: number;
         };
+        /**
+         * @description Declarative UI/input primitive for collecting the response. This is a portable rendering contract, not executable code. Values are `confirm`, `select`, `multi_select`, and `input`.
+         * @enum {string}
+         */
+        InteractionMode: "confirm" | "select" | "multi_select" | "input";
+        /** @description Selectable option for `select` and `multi_select` modes. */
+        InteractionOption: {
+            /** @description Machine-readable value submitted when this option is chosen. */
+            value: string;
+            /** @description Human-readable label displayed for this option. */
+            label: string;
+            /** @description Optional additional context shown beneath the label. */
+            description?: string;
+        };
+        /**
+         * @description Declarative dialog contract for rendering and validating an interaction. Used at both authoring time (inside a loop definition) and runtime (persisted on an interaction). Protocol kind is decoupled from input shape: each kind declares which spec modes are *allowed*, not which is *implied*. An approval may now legitimately use `select` mode (approve/deny/defer), for example.
+         *
+         *     Allowed combinations:
+         *     * `approval` → `confirm`, `select`
+         *     * `review` → `select`, `input`
+         *     * `request` → `select`, `multi_select`, `input`
+         */
+        InteractionSpec: {
+            /** @description UI/input mode used to render and validate the response. */
+            mode: components["schemas"]["InteractionMode"];
+            /** @description Required for `select` and `multi_select` modes. */
+            options?: components["schemas"]["InteractionOption"][];
+            /** @description Default selected option for `select` mode. */
+            default_value?: string;
+            /** @description Default selected options for `multi_select` mode. */
+            default_values?: string[];
+            /** @description Initial text value for `input` mode. */
+            default_text?: string;
+            /** @description Initial yes/no value for `confirm` mode. */
+            default_confirmed?: boolean;
+            /** @description Hint text shown for `input` mode. */
+            placeholder?: string;
+            /** @description When true, render `input` mode as a multiline text area. */
+            multiline?: boolean;
+        };
+        /**
+         * @description Protocol kind of the interaction. Launch keeps this intentionally
+         *     small:
+         *     * `request_information` — a data-collection protocol with structured
+         *     or free-form input
+         *     * `request_approval` — a decision protocol (yes/no, optionally
+         *     yes/no/defer)
+         *     * `request_review` — a judgment protocol that evaluates supplied
+         *     material
+         * @enum {string}
+         */
+        InteractionKind: "request_information" | "request_approval" | "request_review";
+        /** @description Free-form JSON payload. Used both for responder-supplied values and for policy-derived values (e.g. `Interaction.outcome`, `ResolutionPolicy.proposal`); each consumer documents which. */
+        InteractionValue: ({
+            [key: string]: unknown;
+        } | null) | unknown[] | string | number | boolean;
+        /** @description Identifies the principal who answered an interaction. Agents answer through their agent principal ID. */
+        InteractionResponder: {
+            /** @description Responder user ID. */
+            user_id: string;
+        };
+        /** @description Pointer to the work item, artifact, external ticket, or Mobius entity this interaction is about. */
+        InteractionReference: {
+            /** @enum {string} */
+            kind: "external_url" | "mobius_entity";
+            /**
+             * Format: uri
+             * @description Required when kind is `external_url`.
+             */
+            url?: string;
+            /** @description Required when kind is `mobius_entity`. */
+            entity_type?: string;
+            /** @description Required when kind is `mobius_entity`. */
+            entity_id?: string;
+            /** @description Relationship such as `subject`, `evidence`, or `related`. */
+            relation?: string;
+            /** @description User-facing label for display. */
+            label?: string;
+        };
+        /** @description Optional per-interaction delivery override. When absent, each participant is notified via the app inbox only. */
+        Delivery: {
+            channels: components["schemas"]["DeliveryChannel"][];
+        };
+        /** @description A single delivery destination. `inbox_only` carries no payload; `email` requires the `email` variant. */
+        DeliveryChannel: {
+            /** @enum {string} */
+            kind: "inbox_only" | "email";
+            /** @description Email delivery payload when `kind=email`; null for inbox-only delivery. */
+            email?: components["schemas"]["EmailDelivery"] | null;
+        };
+        EmailDelivery: {
+            to: string[];
+        };
+        /** @description Polymorphic identifier of what is waiting on this interaction's resolution. Replaces the previously special-cased `run_id` + `signal_name` pair. When `kind=run`, the legacy fields are also populated for compatibility. `http_subscriber` requires `secret_ref` and enqueues a durable callback dispatch to `callback_url` when the interaction resolves; the canonical string `v1.{delivery_id}.{unix_timestamp}.{raw_body}` is signed with HMAC-SHA256 against the resolved project signing key and the signed dispatch carries `X-Mobius-Signature`, `X-Mobius-Secret-Ref`, `X-Mobius-Secret-Version`, and `X-Mobius-Timestamp`. Signed dispatches also carry `X-Mobius-Signature-Version: v1`. Every durable dispatch also carries the stable outbox row id in `X-Mobius-Delivery-Id` and `Idempotency-Key`; retries reuse the same value. Verifiers should recompute the signature over the exact raw body, reject stale timestamps (for example, older than five minutes), deduplicate by delivery id, and check the signing headers. */
+        Consumer: {
+            /** @enum {string} */
+            kind: "run" | "agent_tool" | "http_subscriber" | "none";
+            /** @description Run resume target when `kind=run`; null for other consumer kinds. */
+            run?: components["schemas"]["RunConsumer"] | null;
+            /** @description Agent tool continuation target when `kind=agent_tool`; null for other consumer kinds. */
+            agent_tool?: components["schemas"]["AgentToolConsumer"] | null;
+            /** @description HTTP callback target when `kind=http_subscriber`; null for other consumer kinds. */
+            http_subscriber?: components["schemas"]["HttpSubscriberConsumer"] | null;
+        };
+        RunConsumer: {
+            run_id: string;
+            signal_name: string;
+        };
+        AgentToolConsumer: {
+            invocation_id: string;
+            tool_call_id: string;
+        };
+        HttpSubscriberConsumer: {
+            /**
+             * Format: uri
+             * @description Absolute http(s) URL the server POSTs to when the interaction resolves. The body is a JSON object with the interaction id, kind, status, outcome value, comment, responder, and `resolved_by`. Delivery is enqueued as a `source_events` dispatch so the worker can retry failed attempts instead of dropping them inline with interaction resolution.
+             */
+            callback_url: string;
+            /** @description Required reference to a project secret used to sign deliveries with HMAC-SHA256 over the canonical string `v1.{delivery_id}.{unix_timestamp}.{raw_body}`, where `delivery_id` is the value in `X-Mobius-Delivery-Id` and `raw_body` is the exact callback request body bytes. Accepts `<name>` for the latest enabled version or `<name>:<version>` to pin a specific positive-integer version. The plaintext signing bytes are taken from the secret's `signing_key_b64` key, which must base64-decode to exactly 32 bytes. The hex signature is forwarded as `X-Mobius-Signature: sha256=<hex>` alongside `X-Mobius-Secret-Ref`, `X-Mobius-Secret-Version`, `X-Mobius-Signature-Version: v1`, and a unix `X-Mobius-Timestamp`. Consumers should reject stale timestamps (for example, older than five minutes). When `secret_ref` resolution fails the dispatch is retried by the event processor rather than sent unsigned. */
+            secret_ref: string;
+        };
+        /** @description One persisted answer artifact for an interaction. The response that triggered resolution is referenced from `Interaction.resolving_response_id`. */
+        InteractionResponse: {
+            /** @description Unique identifier for this response. */
+            id: string;
+            /** @description ID of the interaction this response belongs to. */
+            interaction_id: string;
+            /**
+             * @description Answer response.
+             * @enum {string}
+             */
+            response_kind: "response";
+            /**
+             * @description Lifecycle state for this response row.
+             * @enum {string}
+             */
+            state: "submitted";
+            /** @description User ID that submitted this response. */
+            responder_user_id: string;
+            /** @description JSON value supplied by this participant. */
+            value: components["schemas"]["InteractionValue"];
+            /** @description Optional free-text comment from this responder. */
+            comment?: string | null;
+            /**
+             * Format: date-time
+             * @description Timestamp when this response was submitted.
+             */
+            responded_at: string;
+            /** @description Reserved for future retry-aware response flows; null until attempts are tracked. */
+            attempt?: number | null;
+            /** Format: date-time */
+            created_at: string;
+            /** Format: date-time */
+            updated_at: string;
+        };
+        /** @description Declarative resolution rule attached to an Interaction. Determines how participant responses become a final outcome. */
+        ResolutionPolicy: {
+            /**
+             * @description Resolution rule. `any_of` resolves on the first acceptable response. `all_of` waits for every assigned participant. `quorum` resolves once `threshold` distinct participants respond.
+             * @enum {string}
+             */
+            type: "any_of" | "all_of" | "quorum";
+            /** @description Required when `type` is `quorum`. Number of distinct eligible participants that must respond before the interaction resolves. Must be `>= 1` and `<=` the participant count. */
+            threshold?: number;
+        };
+        /** @description Human or agent interaction request and its current response state. */
+        Interaction: {
+            /** @description Unique identifier for this interaction. */
+            id: string;
+            /** @description Originating loop run when the interaction is run-backed. */
+            run_id?: string | null;
+            /** @description Signal name used to resume the originating run when run-backed. */
+            signal_name?: string | null;
+            /** @description Canonical principal ID of the human or agent that created the interaction; null for legacy/system-created rows. */
+            created_by?: string | null;
+            /** @description Protocol kind of the interaction. */
+            kind: components["schemas"]["InteractionKind"];
+            /**
+             * @description Current status of the interaction: pending, completed, expired, or cancelled.
+             * @enum {string}
+             */
+            status: "pending" | "completed" | "expired" | "cancelled";
+            /** @description Short non-empty title shown to the responder. */
+            title: string;
+            /** @description Optional longer responder-facing detail or instructions. */
+            description?: string | null;
+            /** @description Primary work item or artifact the interaction is about; null when no subject was supplied. */
+            subject?: components["schemas"]["InteractionReference"] | null;
+            /** @description Supporting links and related entities. */
+            references?: components["schemas"]["InteractionReference"][];
+            /** @description Additional key-value context surfaced in the UI alongside the title and description when supplied. */
+            context?: {
+                [key: string]: unknown;
+            } | null;
+            tags?: components["schemas"]["TagMap"];
+            /** @description Free-form structured metadata attached to the interaction; null when no metadata is attached. */
+            properties?: {
+                [key: string]: unknown;
+            } | null;
+            /** @description Response controls and validation rules rendered to the recipient. */
+            spec?: components["schemas"]["InteractionSpec"];
+            /** @description Resolved user IDs targeted by the interaction. */
+            target_user_ids: string[];
+            /** @description User or agent that completed the interaction; null until completion. */
+            responder?: components["schemas"]["InteractionResponder"] | null;
+            /** @description ID of the response that triggered resolution. Null while the interaction is pending, cancelled, or expired. Look up the response in `responses` for the full payload. */
+            resolving_response_id?: string | null;
+            /** @description All response artifacts recorded against this interaction in arrival order. */
+            responses?: components["schemas"]["InteractionResponse"][];
+            /**
+             * Format: date-time
+             * @description Timestamp when this interaction expires if not responded to.
+             */
+            expires_at?: string | null;
+            /**
+             * Format: date-time
+             * @description Timestamp when the interaction received a terminal response.
+             */
+            completed_at?: string | null;
+            /**
+             * Format: date-time
+             * @description Timestamp when this interaction was created.
+             */
+            created_at: string;
+            /**
+             * Format: date-time
+             * @description Timestamp when this interaction was last updated.
+             */
+            updated_at: string;
+            /** @description When true, all target users must respond before completion. */
+            require_all?: boolean;
+            /** @description Declarative resolution rule attached at creation time. Legacy `require_all` inputs are synthesized into an equivalent policy at create time when present. Newer rows typically include this field; nullability covers historical rows and callers that omit it. */
+            resolution_policy?: components["schemas"]["ResolutionPolicy"] | null;
+            /** @description Polymorphic identifier of what is waiting on this interaction's resolution. Replaces the special-cased `run_id`/`signal_name` pair; the latter remain populated when `consumer.kind=run`. */
+            consumer?: components["schemas"]["Consumer"] | null;
+            /** @description Optional per-interaction delivery override. When absent, the dispatcher delivers to the app inbox only. */
+            delivery?: components["schemas"]["Delivery"] | null;
+            /** @description Final outcome selected by the resolution policy. Omitted while the interaction is still pending. */
+            outcome?: components["schemas"]["InteractionValue"];
+            /** @description Short audit string identifying which policy rule fired. Null until the interaction reaches a resolved state. */
+            resolved_by?: string | null;
+            /** @description Reason recorded when the interaction was cancelled. */
+            cancel_reason?: string | null;
+        };
+        InteractionListResponse: {
+            /** @description The list of results for this page. */
+            items: components["schemas"]["Interaction"][];
+            /** @description Whether additional pages are available. */
+            has_more?: boolean;
+            /** @description Opaque cursor to pass as `cursor` on the next request. Absent when `has_more` is false. */
+            next_cursor?: string;
+        };
+        /** @description Creates an interaction directly. Use the standalone variant with no loop-run side effect, or the run-backed variant that requires both `run_id` and `signal_name` so completion can resume the run. For worker/job usage, prefer the job-scoped route so the server can derive the owning run from the claimed job context. */
+        CreateInteractionRequest: components["schemas"]["CreateStandaloneInteractionRequest"] | components["schemas"]["CreateRunBackedInteractionRequest"];
+        /** @description Creates a standalone interaction. Completion records the response but does not deliver a loop signal. */
+        CreateStandaloneInteractionRequest: {
+            /** @description Resolved user IDs to target directly. Agents use their agent principal IDs. */
+            target_user_ids?: string[];
+            /** @description Protocol kind. */
+            kind: components["schemas"]["InteractionKind"];
+            /** @description Short non-empty title shown to the responder. */
+            title: string;
+            /** @description Optional longer responder-facing detail or instructions. */
+            description?: string;
+            /** @description Primary work item or artifact the interaction is about. */
+            subject?: components["schemas"]["InteractionReference"];
+            /** @description Supporting links and related entities. */
+            references?: components["schemas"]["InteractionReference"][];
+            /** @description Additional key-value context surfaced in the UI alongside the title and description. */
+            context?: {
+                [key: string]: unknown;
+            };
+            tags?: components["schemas"]["TagMap"];
+            /** @description Free-form structured metadata to attach to the interaction. */
+            properties?: {
+                [key: string]: unknown;
+            };
+            /** @description Response controls and validation rules rendered to the recipient. */
+            spec?: components["schemas"]["InteractionSpec"];
+            /** @description When true, all target users must respond before the interaction is considered complete. Defaults to false when omitted. Mutually exclusive with `resolution_policy`; prefer the policy form for new code. */
+            require_all?: boolean;
+            /** @description Declarative resolution rule. When supplied the policy evaluator drives completion. */
+            resolution_policy?: components["schemas"]["ResolutionPolicy"];
+            /** @description Polymorphic identifier of what is waiting on this interaction's resolution. When omitted on a run-backed create request, the server derives a `kind=run` consumer from `run_id` and `signal_name`. */
+            consumer?: components["schemas"]["Consumer"];
+            /** @description Optional per-interaction delivery override. */
+            delivery?: components["schemas"]["Delivery"];
+            /**
+             * Format: date-time
+             * @description Timestamp after which this interaction expires if not responded to.
+             */
+            expires_at?: string;
+        };
+        /**
+         * @description Creates an interaction linked to a loop run for audit. The server derives a `kind=run` consumer from `run_id` and `signal_name`.
+         *
+         *     This is an audit-only link: creating an interaction here does not suspend the run, and resolving it does not by itself resume a run. A run only blocks on, and resumes from, human input when the loop definition declares an interaction step — that step creates the interaction and registers the matching wait atomically. Use this endpoint to record a human decision against a run, not to drive run control flow.
+         */
+        CreateRunBackedInteractionRequest: {
+            /** @description ID of the loop run to resume when this interaction is completed. */
+            run_id: string;
+            /** @description Signal name the interaction will complete against when run-backed. */
+            signal_name: string;
+            /** @description Resolved user IDs to target directly. Agents use their agent principal IDs. */
+            target_user_ids?: string[];
+            /** @description Protocol kind. */
+            kind: components["schemas"]["InteractionKind"];
+            /** @description Short non-empty title shown to the responder. */
+            title: string;
+            /** @description Optional longer responder-facing detail or instructions. */
+            description?: string;
+            /** @description Primary work item or artifact the interaction is about. */
+            subject?: components["schemas"]["InteractionReference"];
+            /** @description Supporting links and related entities. */
+            references?: components["schemas"]["InteractionReference"][];
+            /** @description Additional key-value context surfaced in the UI alongside the title and description. */
+            context?: {
+                [key: string]: unknown;
+            };
+            tags?: components["schemas"]["TagMap"];
+            /** @description Free-form structured metadata to attach to the interaction. */
+            properties?: {
+                [key: string]: unknown;
+            };
+            /** @description Response controls and validation rules rendered to the recipient. */
+            spec?: components["schemas"]["InteractionSpec"];
+            /** @description When true, all target users must respond before the interaction is considered complete. Defaults to false when omitted. Mutually exclusive with `resolution_policy`; prefer the policy form for new code. */
+            require_all?: boolean;
+            /** @description Declarative resolution rule. When supplied the policy evaluator drives completion. */
+            resolution_policy?: components["schemas"]["ResolutionPolicy"];
+            /** @description Polymorphic identifier of what is waiting on this interaction's resolution. When omitted on a run-backed create request, the server derives a `kind=run` consumer from `run_id` and `signal_name`. */
+            consumer?: components["schemas"]["Consumer"];
+            /** @description Optional per-interaction delivery override. */
+            delivery?: components["schemas"]["Delivery"];
+            /**
+             * Format: date-time
+             * @description Timestamp after which this interaction expires if not responded to.
+             */
+            expires_at?: string;
+        };
+        RespondToInteractionRequest: {
+            /**
+             * @description Operation to perform through the canonical response endpoint. `submit` answers the interaction.
+             * @enum {string}
+             */
+            action?: "submit";
+            /** @description JSON value supplied by the responder. Required for `submit`. */
+            value?: components["schemas"]["InteractionValue"];
+            /** @description Optional free-text comment accompanying the action. Available on every interaction kind and never gated by the spec; the responder may always attach reasoning, caveats, or follow-up notes alongside `value`. */
+            comment?: string;
+        };
+        /** @description Optional payload accompanying a cancel request. The reason is recorded on the interaction and forwarded in the cancellation signal so loops can route to a fallback. */
+        CancelInteractionRequest: {
+            /** @description Free-text reason recorded on the interaction. */
+            reason?: string;
+        };
         /**
          * @description Direct-message access policy: `open`, `allowlist`, or `disabled`.
          * @enum {string}
@@ -2887,6 +3575,8 @@ export interface components {
             reply_mode: components["schemas"]["AgentMessagingReplyMode"];
             /** @description Optional model route override used for replies through this binding. */
             model_route?: components["schemas"]["AgentModelRoute"];
+            /** @description Optional compaction policy applied to sessions created from this binding. Unset inherits the agent default. */
+            compaction_policy?: components["schemas"]["SessionCompactionPolicy"];
             /**
              * Format: date-time
              * @description Time the binding was created.
@@ -2938,6 +3628,8 @@ export interface components {
             reply_mode?: components["schemas"]["AgentMessagingReplyMode"];
             /** @description Optional model route override used for replies through this binding. */
             model_route?: components["schemas"]["AgentModelRoute"];
+            /** @description Optional compaction policy applied to sessions created from this binding. Unset inherits the agent default. */
+            compaction_policy?: components["schemas"]["SessionCompactionPolicy"];
         };
         AgentMessagingBindingListResponse: {
             /** @description Messaging bindings configured for this agent. */
@@ -3069,7 +3761,7 @@ export interface components {
             kind?: string;
             /** @description Display color for this agent (Mantine palette key, e.g. `indigo`). Optional; empty falls back to a hash-derived color. */
             color?: string;
-            /** @description Model identifier for platform agents. Any id from `GET /v1/projects/{project_handle}/catalog/models`, optionally `provider/`-prefixed (e.g. `xai/grok-4`); bare known ids (e.g. `claude-sonnet-4-6`) are auto-detected. Empty falls back to the platform default. */
+            /** @description Model identifier for platform agents. Any id from `GET /v1/projects/{project_handle}/catalog/models`, including slash-bearing OpenRouter catalog ids, or an optionally `provider/`-prefixed id (e.g. `xai/grok-4`); bare known ids (e.g. `claude-sonnet-4-6`) are auto-detected. Empty falls back to the platform default. */
             model?: string;
             /** @description Default route for model calls made by this agent. */
             model_route?: components["schemas"]["AgentModelRoute"];
@@ -3082,6 +3774,8 @@ export interface components {
              * @description Per-turn execution timeout in seconds for this platform agent. Omit or `0` to use the platform default (600s / 10 minutes); a loop step's own timeout overrides it for that step.
              */
             timeout_seconds?: number;
+            /** @description Default session-compaction policy new sessions inherit from this agent. */
+            compaction_policy?: components["schemas"]["SessionCompactionPolicy"];
             /** @description Initial labels used for filtering, ownership, or automation. */
             tags?: components["schemas"]["TagMap"];
         };
@@ -3095,7 +3789,7 @@ export interface components {
             kind?: string;
             /** @description Replacement display color (Mantine palette key, e.g. `indigo`). Pass empty string to clear and fall back to a hash-derived color. */
             color?: string;
-            /** @description Replacement model identifier for platform agents (any id from `GET /v1/projects/{project_handle}/catalog/models`, optionally `provider/`-prefixed). */
+            /** @description Replacement model identifier for platform agents (any id from `GET /v1/projects/{project_handle}/catalog/models`, including slash-bearing OpenRouter catalog ids, or an optionally `provider/`-prefixed id). */
             model?: string;
             /** @description Replacement default route for model calls made by this agent. */
             model_route?: components["schemas"]["AgentModelRoute"];
@@ -3113,14 +3807,156 @@ export interface components {
              * @enum {string}
              */
             status?: "active" | "inactive";
+            /** @description Replacement default session-compaction policy. Send an empty object to clear the default and fall back to server defaults. */
+            compaction_policy?: components["schemas"]["SessionCompactionPolicy"];
             /** @description Replacement labels; send an empty object to clear all tags. */
             tags?: components["schemas"]["TagMap"];
         };
+        /**
+         * @description Classifies a memory entry. Kinds carry different retention and compaction semantics: facts and preferences are durable, episodes are the primary input to compaction, and a summary is the compacted product of other entries.
+         * @enum {string}
+         */
+        MemoryKind: "fact" | "preference" | "episode" | "summary";
+        /** @description Summary of an agent's private memory: how many entries it holds, a breakdown by kind, and when it last changed. */
+        AgentMemory: {
+            /** @description The agent that owns this memory. */
+            agent_id: string;
+            /** @description Number of entries currently held. */
+            entry_count: number;
+            /** @description Entry counts keyed by memory kind. */
+            counts_by_kind: {
+                [key: string]: number;
+            };
+            /**
+             * Format: date-time
+             * @description When any entry was last changed, when there are entries.
+             */
+            updated_at?: string;
+        };
+        /** @description A single durable memory in an agent's private memory, identified by a stable key the agent chose. */
+        AgentMemoryEntry: {
+            /** @description Stable identifier the agent chose for this memory. */
+            key: string;
+            kind: components["schemas"]["MemoryKind"];
+            /** @description Short one-line summary shown in the agent's memory index. */
+            summary?: string;
+            /** @description The remembered content. */
+            content?: string;
+            /** @description Structured metadata stored alongside the memory (provenance, tags, …). */
+            metadata?: {
+                [key: string]: unknown;
+            };
+            /** @description Rank from 0 to 100; higher ranks sooner in recall and is kept longer under the memory cap. */
+            importance: number;
+            /** @description Whether the entry is guaranteed in the memory index and exempt from the memory cap. */
+            pinned: boolean;
+            /** @description Identifier of the loop run that last wrote this memory, when known. */
+            source_run_id?: string;
+            /** @description Identifier of this memory entry. */
+            entry_id: string;
+            /** @description Monotonic version, incremented on each update. */
+            version: number;
+            /**
+             * Format: date-time
+             * @description When the entry was first remembered.
+             */
+            created_at: string;
+            /**
+             * Format: date-time
+             * @description When the entry was last updated.
+             */
+            updated_at: string;
+        };
+        AgentMemoryEntryListResponse: {
+            /** @description Memory entries in the current page. */
+            items: components["schemas"]["AgentMemoryEntry"][];
+            /** @description Whether more entries follow this page. */
+            has_more: boolean;
+            /** @description Cursor to fetch the next page, when has_more is true. */
+            next_cursor?: string;
+        };
+        /** @description Content for a memory entry. The key comes from the path. */
+        PutAgentMemoryEntryRequest: {
+            /** @description The content to remember. */
+            content?: string;
+            /** @description Optional short one-line summary (≤140 chars) shown in the memory index. */
+            summary?: string;
+            kind?: components["schemas"]["MemoryKind"];
+            /** @description Optional structured metadata to store alongside the memory. */
+            metadata?: {
+                [key: string]: unknown;
+            };
+            /** @description Optional importance from 0 to 100; higher is kept longer during compaction. */
+            importance?: number;
+            /** @description Pin to exempt this memory from compaction. */
+            pinned?: boolean;
+        };
         /**
          * @description Message role: `system`, `user`, `assistant`, `tool`, or `compaction`.
          * @enum {string}
          */
         SessionMessageRole: "system" | "user" | "assistant" | "tool" | "compaction";
+        /** @description Assistant or caller text. */
+        SessionTextBlock: {
+            /** @enum {string} */
+            type: "text";
+            /** @description The text content. */
+            text: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /** @description An extended-reasoning block produced by a reasoning model. */
+        SessionThinkingBlock: {
+            /** @enum {string} */
+            type: "thinking";
+            /** @description The reasoning text. */
+            thinking: string;
+            /** @description Provider signature for the reasoning block, when present. */
+            signature?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /** @description A tool call the agent issued. */
+        SessionToolUseBlock: {
+            /** @enum {string} */
+            type: "tool_use";
+            /** @description Tool-call id; the matching tool_result references it. */
+            id: string;
+            /** @description Tool name. */
+            name: string;
+            /** @description Tool input arguments. */
+            input: {
+                [key: string]: unknown;
+            };
+        } & {
+            [key: string]: unknown;
+        };
+        /** @description One content block in a session transcript message — the canonical, frozen JSON shape Mobius persists and replays, discriminated by `type`. The variants are `text`, `thinking`, `tool_use`, `tool_result`, and `image`. Each variant permits provider-specific extra fields (citations, signatures, cache hints, and the like), and unknown fields are preserved rather than rejected, so the transcript round-trips losslessly across providers. */
+        SessionContentBlock: components["schemas"]["SessionTextBlock"] | components["schemas"]["SessionThinkingBlock"] | components["schemas"]["SessionToolUseBlock"] | components["schemas"]["SessionToolResultBlock"] | components["schemas"]["SessionImageBlock"];
+        /** @description The result of a tool call. */
+        SessionToolResultBlock: {
+            /** @enum {string} */
+            type: "tool_result";
+            /** @description The tool_use id this result answers. */
+            tool_use_id: string;
+            /** @description Result payload — a string, or an array of typed sub-blocks using the same canonical block shape as a transcript message. */
+            content?: string | components["schemas"]["SessionContentBlock"][];
+            /** @description True when the tool reported a failure. */
+            is_error?: boolean;
+        } & {
+            [key: string]: unknown;
+        };
+        /** @description An image block, e.g. multimodal caller input. */
+        SessionImageBlock: {
+            /** @enum {string} */
+            type: "image";
+            /** @description Provider-specific image source descriptor. */
+            source?: {
+                [key: string]: unknown;
+            };
+        } & {
+            [key: string]: unknown;
+        };
         /**
          * @description Transcript entry type: `message` or `compaction`.
          * @enum {string}
@@ -3136,10 +3972,8 @@ export interface components {
             agent_id: string;
             /** @description Role of this message in the transcript. */
             role: components["schemas"]["SessionMessageRole"];
-            /** @description Ordered content blocks (text, tool calls, tool results, images). */
-            content: {
-                [key: string]: unknown;
-            }[];
+            /** @description Ordered canonical content blocks (text, thinking, tool_use, tool_result, image). */
+            content: components["schemas"]["SessionContentBlock"][];
             /** @description Whether this row is a normal message or a compaction summary. */
             entry_type: components["schemas"]["SessionMessageEntryType"];
             /** @description For `compaction` messages, the highest sequence number this summary covers. */
@@ -3161,6 +3995,18 @@ export interface components {
         SessionMessageListResponse: {
             /** @description Messages in this page, ordered by `sequence` ascending. */
             items: components["schemas"]["SessionMessage"][];
+            /** @description True when more messages exist past this page in the query's scan direction. */
+            has_more?: boolean;
+            /**
+             * Format: int64
+             * @description Sequence of the last (highest) item — pass back as `after_sequence` to page forward (newer).
+             */
+            next_sequence?: number;
+            /**
+             * Format: int64
+             * @description Sequence of the first (lowest) item — pass back as `before_sequence` with `order=desc` to page backward (older). After paginating history, open the stream with `after_sequence=next_sequence` to receive the in-flight turn and everything after it — the stream and the messages API share one `sequence` cursor, so there is no overlap and no gap.
+             */
+            prev_sequence?: number;
         };
         /**
          * @description Action selector included in a toolkit.
@@ -3305,11 +4151,11 @@ export interface components {
          */
         SessionVisibility: "project" | "private";
         /**
-         * @description Agent turn lifecycle status: `running`, `waiting`, `completed`, `failed`, or `cancelled`.
+         * @description Agent turn lifecycle status: `queued`, `running`, `waiting`, `completed`, `failed`, or `cancelled`.
          * @enum {string}
          */
-        AgentTurnStatus: "running" | "waiting" | "completed" | "failed" | "cancelled";
-        /** @description One attempt of an agent running the agent loop — the unit that produces a transcript. A turn is triggered either by a loop step (run_id + step_id) or an inbound channel message (channel_exchange_id); the two are mutually exclusive. Its messages are read via the turn's transcript endpoint. */
+        AgentTurnStatus: "queued" | "running" | "waiting" | "completed" | "failed" | "cancelled";
+        /** @description One attempt of an agent running the agent loop — the unit that produces a transcript. A turn is triggered by a direct send to the session, a loop step (run_id + step_key), or an inbound channel message (channel_exchange_id). Its messages are read via the turn's transcript endpoint. */
         AgentTurn: {
             /** @description Stable turn identifier. */
             id: string;
@@ -3352,6 +4198,10 @@ export interface components {
         AgentTurnListResponse: {
             /** @description Turns in this session, ordered by creation time. */
             items: components["schemas"]["AgentTurn"][];
+            /** @description True when more turns exist past this page. */
+            has_more?: boolean;
+            /** @description Opaque cursor to pass as `cursor` on the next request. Null when `has_more` is false. */
+            next_cursor?: string | null;
         };
         /** @description Durable conversation transcript owned by an agent. */
         Session: {
@@ -3379,10 +4229,10 @@ export interface components {
             model?: string;
             /** @description Provider for the recorded `model`. */
             model_provider?: string;
-            /** @description Per-session overrides for the message-compaction policy. */
-            compaction_policy?: {
-                [key: string]: unknown;
-            };
+            /** @description Resolved message-compaction policy in effect for this session. */
+            compaction_policy?: components["schemas"]["SessionCompactionPolicy"];
+            /** @description The most recent compaction marker in the transcript, or null when the session has never been compacted. Delineates summarized history (sequences at or below `covers_through_sequence`) from the live tail. Returned on the single-session read; absent from list entries. */
+            latest_compaction?: components["schemas"]["SessionCompactionBoundary"];
             /** @description Total messages currently in the session, including compaction summaries. */
             message_count: number;
             /** @description Lifetime input-token total reported for this session. */
@@ -3420,6 +4270,10 @@ export interface components {
         SessionListResponse: {
             /** @description The list of results for this page. */
             items: components["schemas"]["Session"][];
+            /** @description True when more sessions exist past this page. */
+            has_more?: boolean;
+            /** @description Opaque cursor for the next page — pass back as `cursor`. Null when `has_more` is false. */
+            next_cursor?: string | null;
         };
         /** @description Mutable display and lifecycle fields for a session. */
         UpdateSessionRequest: {
@@ -3427,51 +4281,317 @@ export interface components {
             title?: string;
             /** @description Lifecycle status. `active` restores archived sessions; `deleted` is terminal. */
             status?: components["schemas"]["SessionStatus"];
+            /** @description Partial patch to the session's compaction policy. Only the supplied fields change; omitted fields keep their current values. */
+            compaction_policy?: components["schemas"]["SessionCompactionPolicy"];
         };
-        /** @description JSON payload of a single `data:` line on the session event stream. The SSE `event:` field carries the event type (e.g. `generation.delta`); this object carries the event-specific fields. Additional fields beyond `session_id` vary by event type. */
-        SessionStreamEvent: {
-            /** @description The session this event belongs to. */
+        /**
+         * @description JSON payload of a single `data:` line on the session SSE stream, paired with an `event: <event type>` line.
+         *
+         *     The `event:` line is the authoritative frame selector. This union is reference-only: several payloads are structurally identical (e.g. `user.message` and `agent.message`) or permissive open objects, so the `data:` body alone cannot be shape-matched to a single variant. Consumers MUST dispatch on the `event:` name and decode the body as the corresponding payload — never validate the bare body against the union.
+         *
+         *     Durable message frames (`user.message`, `agent.message`, `compaction.created`) are replayed from the transcript and carry an SSE `id: <sequence>` — that `sequence` is the only cursor a client persists for `after_sequence` / `Last-Event-ID` resume. Terminal `turn.*` frames mark the active turn settling. `session.message.preview`, `session.resync`, `tool.call`, `tool.result`, and `generation.delta` frames are live-only and carry no `id:`.
+         */
+        SessionStreamFrame: components["schemas"]["SessionUserMessagePayload"] | components["schemas"]["AgentMessagePayload"] | components["schemas"]["CompactionCreatedPayload"] | components["schemas"]["TurnStartedPayload"] | components["schemas"]["TurnWaitingPayload"] | components["schemas"]["TurnCompletedPayload"] | components["schemas"]["TurnFailedPayload"] | components["schemas"]["TurnCancelledPayload"] | components["schemas"]["SessionMessagePreviewFrame"] | components["schemas"]["SessionResyncFrame"] | components["schemas"]["ToolCallPayload"] | components["schemas"]["ToolResultPayload"] | components["schemas"]["GenerationDeltaFrame"];
+        /** @description Live-only, SessionMessage-compatible transcript preview for an in-flight agent response segment. It carries no durable `seq`, transcript `sequence`, or stable `message_id`; the committed row later replaces it by `turn_id` plus `metadata.response_message_index`. */
+        SessionMessagePreviewFrame: {
+            /** @enum {string} */
+            event_type: "session.message.preview";
+            /** @description Provisional live id. Do not persist or use as the durable message id. */
+            id: string;
+            /** @description Session this preview belongs to. */
             session_id: string;
+            /** @description Agent that owns the parent session, when known. */
+            agent_id?: string;
+            /** @description Loop run that produced the preview, when applicable. */
+            run_id?: string;
+            /** @description Agent turn that produced the preview. */
+            turn_id: string;
+            /**
+             * Format: int64
+             * @description Monotonic per-turn sequence across all live-only session frames; use to detect dropped live frames.
+             */
+            live_sequence?: number;
+            role: components["schemas"]["SessionMessageRole"];
+            entry_type: components["schemas"]["SessionMessageEntryType"];
+            /** @description Ordered content blocks using the same canonical block shape as SessionMessage. */
+            content: components["schemas"]["SessionContentBlock"][];
+            /** @description Must include `response_message_index`, the handoff key shared with the durable transcript row. */
+            metadata: {
+                [key: string]: unknown;
+            };
+            /**
+             * Format: date-time
+             * @description Server timestamp when this live preview frame was emitted.
+             */
+            emitted_at?: string;
         } & {
             [key: string]: unknown;
         };
-        AppendSessionMessagesRequest: {
-            /** @description Messages to append to the session, in order. */
-            messages: components["schemas"]["AppendSessionMessage"][];
-            /** @description Updated lifetime input-token total for this session. */
-            token_input_total?: number;
-            /** @description Updated lifetime output-token total for this session. */
-            token_output_total?: number;
-            /** @description Model that produced these messages. */
-            model?: string;
-            /** @description Provider for the supplied `model`. */
-            model_provider?: string;
-        };
-        /** @description Message payload to append to an existing durable session. */
-        AppendSessionMessage: {
-            /** @description Role to store for this appended message. */
-            role: components["schemas"]["SessionMessageRole"];
-            /** @description Ordered content blocks (text, tool calls, tool results, images). */
-            content: {
+        /** @description Ephemeral, process-local live transcript snapshot for an in-flight turn. */
+        SessionLiveSnapshot: {
+            session_id: string;
+            turn_id: string;
+            /** @description Live-only frame payloads in live_sequence order. Each item has the same shape as its SSE `data:` payload. */
+            frames: {
                 [key: string]: unknown;
             }[];
-            /** @description Free-form caller metadata for this message. */
-            metadata?: {
-                [key: string]: unknown;
-            };
+            /**
+             * Format: int64
+             * @description Highest live_sequence included in `frames`, or 0 when no live frames are available.
+             */
+            last_live_sequence: number;
             /**
              * Format: date-time
-             * @description Caller-supplied creation timestamp. The server assigns one if absent.
+             * @description Server timestamp when the snapshot was last updated.
              */
-            created_at?: string;
+            updated_at: string;
         };
-        /** @description Resolve-or-create policy for a session. */
-        CreateSessionRequest: {
-            /** @description Agent that owns the session. */
-            agent_id: string;
+        /** @description Live-only marker asking the client to reconcile the active turn from the live snapshot endpoint. */
+        SessionResyncFrame: {
+            /** @enum {string} */
+            event_type: "session.resync";
+            session_id: string;
+            /** @description Machine-readable resync reason, e.g. `subscriber_overflow`. */
+            reason: string;
+        };
+        /** @description Payload of a `user.message` content event: the durable encoding of one non-assistant transcript message — caller input, or a user-role message carrying tool results. It mirrors the transcript row exactly, carrying the message identity (`message_id` + `sequence`) and full content. Replaying these events reconstructs the same view as reading the messages API. */
+        SessionUserMessagePayload: {
+            /** @description Id of the transcript message this event mirrors. */
+            message_id: string;
             /**
-             * @description `continue_or_create` (default) resolves an existing session for the `session_key` or creates one; `new` always creates a fresh session; `continue` resolves an existing session and fails if none exists.
-             * @enum {string}
+             * Format: int64
+             * @description The mirrored message's per-session transcript sequence.
+             */
+            sequence: number;
+            /** @description Transcript role of the message (e.g. `user`, `system`, or a user-role message carrying tool results); never `assistant`. */
+            role: components["schemas"]["SessionMessageRole"];
+            /** @description The message's full canonical content blocks (text, tool_result, …). */
+            content: components["schemas"]["SessionContentBlock"][];
+            /** @description The agent turn that produced this message, when applicable. */
+            turn_id?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /** @description Payload of a `turn.started` event. Empty: the turn is identified by the envelope `turn_id`, so nothing is duplicated in the payload. */
+        TurnStartedPayload: {
+            [key: string]: unknown;
+        };
+        /** @description Payload of an `agent.message` content event: the durable encoding of one assistant transcript message. Carries the message's full structured content (text, thinking, tool_use) plus the message identity (`message_id` + `sequence`). Replaying these events reconstructs the same view as reading the messages API. */
+        AgentMessagePayload: {
+            /** @description Id of the transcript message this event mirrors. */
+            message_id: string;
+            /**
+             * Format: int64
+             * @description The mirrored message's per-session transcript sequence.
+             */
+            sequence: number;
+            /**
+             * @description Always `assistant`.
+             * @enum {string}
+             */
+            role: "assistant";
+            /** @description The assistant message's full canonical content blocks (text, thinking, tool_use). */
+            content: components["schemas"]["SessionContentBlock"][];
+            /** @description The agent turn that produced this message. */
+            turn_id?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /** @description Payload of a live-only `tool.call` frame — an in-flight preview that a tool was invoked during the active turn. Never persisted and carries no sequence: the durable record of the call is the `tool_use` content block of the assistant message, delivered as an `agent.message` event when the turn commits. */
+        ToolCallPayload: {
+            tool_call_id?: string;
+            tool_name?: string;
+            input?: {
+                [key: string]: unknown;
+            };
+            /**
+             * Format: int64
+             * @description Monotonic per-turn sequence across all live-only session frames; use to detect dropped live frames.
+             */
+            live_sequence?: number;
+            /**
+             * Format: date-time
+             * @description Server timestamp when this live preview frame was emitted.
+             */
+            emitted_at?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /** @description Payload of a live-only `tool.result` frame — an in-flight preview that a tool returned during the active turn. Never persisted and carries no sequence: the durable record is the `tool_result` content block of the following transcript message, delivered as a `user.message` event when the turn commits. */
+        ToolResultPayload: {
+            tool_call_id?: string;
+            tool_name?: string;
+            /** @description The tool result as canonical content blocks (e.g. `[{ "type": "text", "text": "…" }]`), the same `SessionContentBlock` shape as the `tool_result` content of the durable transcript message — so the live preview and the committed record read identically. In practice the server collapses the result to a single `text` block. */
+            content?: components["schemas"]["SessionContentBlock"][];
+            display?: string;
+            is_error?: boolean;
+            error?: string;
+            /**
+             * Format: int64
+             * @description Monotonic per-turn sequence across all live-only session frames; use to detect dropped live frames.
+             */
+            live_sequence?: number;
+            /**
+             * Format: date-time
+             * @description Server timestamp when this live preview frame was emitted.
+             */
+            emitted_at?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        TurnWaitingPayload: {
+            turn_id?: string;
+            reason?: string;
+            wait?: {
+                [key: string]: unknown;
+            };
+        } & {
+            [key: string]: unknown;
+        };
+        /** @description Payload of a `turn.completed` event — the terminal idle marker carrying token usage. The assistant output is not duplicated here; it is delivered as `agent.message` content events when the transcript commits. */
+        TurnCompletedPayload: {
+            usage?: {
+                [key: string]: unknown;
+            };
+        } & {
+            [key: string]: unknown;
+        };
+        TurnFailedPayload: {
+            error?: string;
+            error_type?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        TurnCancelledPayload: {
+            reason?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /** @description Payload of a `compaction.created` event, emitted when the session transcript is summarized. The event is non-terminal: it never closes the session stream, so a live consumer observes a compaction landing inline. */
+        CompactionCreatedPayload: {
+            /** @description Id of the compaction summary message appended to the transcript. */
+            message_id?: string;
+            /**
+             * Format: int64
+             * @description The summary message's per-session transcript sequence.
+             */
+            sequence?: number;
+            /** @description Transcript role of the summary entry. */
+            role?: string;
+            /** @description The summary's full canonical content blocks, so replaying the stream reconstructs the compaction entry exactly. */
+            content?: components["schemas"]["SessionContentBlock"][];
+            /** @description Highest message sequence the new summary covers — the before/after boundary. */
+            covers_through_sequence?: number;
+            /** @description Number of transcript messages folded into this summary. */
+            message_count?: number;
+            /** @description Model that produced the summary. */
+            summary_model?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        AppendSessionMessagesRequest: {
+            /** @description Messages to append to the session, in order. */
+            messages: components["schemas"]["AppendSessionMessage"][];
+            /** @description Updated lifetime input-token total for this session. */
+            token_input_total?: number;
+            /** @description Updated lifetime output-token total for this session. */
+            token_output_total?: number;
+            /** @description Model that produced these messages. */
+            model?: string;
+            /** @description Provider for the supplied `model`. */
+            model_provider?: string;
+        };
+        /** @description Message payload to append to an existing durable session. */
+        AppendSessionMessage: {
+            /** @description Role to store for this appended message. */
+            role: components["schemas"]["SessionMessageRole"];
+            /** @description Ordered content blocks (text, tool calls, tool results, images). */
+            content: {
+                [key: string]: unknown;
+            }[];
+            /** @description Free-form caller metadata for this message. */
+            metadata?: {
+                [key: string]: unknown;
+            };
+            /**
+             * Format: date-time
+             * @description Caller-supplied creation timestamp. The server assigns one if absent.
+             */
+            created_at?: string;
+        };
+        /** @description Pointer to the latest compaction marker in a session's transcript. The marker is itself a transcript message (role `compaction`); everything at or below `covers_through_sequence` is summarized history. */
+        SessionCompactionBoundary: {
+            /** @description Id of the compaction summary message in the transcript. */
+            message_id: string;
+            /** @description Transcript sequence of the compaction marker itself. */
+            sequence: number;
+            /** @description Highest message sequence this summary covers — the before/after boundary. */
+            covers_through_sequence: number;
+        };
+        /** @description A single compound invocation: which agent to run, how to resolve the session, the caller's input message, and optional channel routing context. */
+        InvokeAgentRequest: {
+            agent_ref: components["schemas"]["AgentRef"];
+            session?: components["schemas"]["InvokeSessionSpec"];
+            input: components["schemas"]["InvokeInput"];
+            channel_context?: components["schemas"]["ChannelContext"];
+        };
+        /** @description Reference to an agent in this project. Supply exactly one of `id` (the agent identifier) or `name` (the project-unique agent name). A blueprint-binding reference form is reserved for a later release and is not resolvable yet. */
+        AgentRef: {
+            /** @description Agent identifier. */
+            id?: string;
+            /** @description Project-unique agent name. */
+            name?: string;
+        };
+        /** @description How to resolve or create the session this invocation runs in. Mirrors the create-session policy: `mode` + `session_key` resolve a durable conversation for the agent, and the remaining fields seed a session that does not already exist (they are ignored when an existing session is resolved). Omit the whole object to use a single default session per agent in `continue_or_create` mode. */
+        InvokeSessionSpec: {
+            /**
+             * @description `continue_or_create` (default) resolves an existing session for the `session_key` or creates one; `new` always creates a fresh session; `continue` resolves an existing session and fails if none exists.
+             * @enum {string}
+             */
+            mode?: "new" | "continue" | "continue_or_create";
+            /** @description Stable key identifying the conversation within the agent. */
+            session_key?: string;
+            /** @description Human-friendly title for a newly created session. */
+            title?: string;
+            visibility?: components["schemas"]["SessionVisibility"];
+            /** @description Per-session compaction overrides applied when the session is first created. Merged over the agent's default policy and server defaults. Ignored when an existing session is resolved. */
+            compaction_policy?: components["schemas"]["SessionCompactionPolicy"];
+            /** @description Free-form caller metadata stored on a newly created session. */
+            metadata?: {
+                [key: string]: unknown;
+            };
+        };
+        /** @description The caller input message that starts the agent turn. */
+        InvokeInput: {
+            /** @description Ordered content blocks (text, images) for the input message. */
+            content: {
+                [key: string]: unknown;
+            }[];
+            /** @description Dedup key scoped to the resolved session. A repeat call with the same key resumes the existing turn and writes nothing new — derive it from the provider event id for Slack/Telegram webhook retries. */
+            idempotency_key?: string;
+            /** @description Free-form caller metadata attached to the input message. */
+            metadata?: {
+                [key: string]: unknown;
+            };
+        };
+        /** @description Optional messaging provider/channel routing context (Slack, Telegram, …). Persisted on the started turn's input-message metadata under a `channel_context` key so chat history and support views can trace a turn back to the provider thread it came from. */
+        ChannelContext: {
+            /** @description Messaging provider, e.g. `slack` or `telegram`. */
+            provider?: string;
+            /** @description Provider workspace/team identifier. */
+            workspace_id?: string;
+            /** @description Provider channel or chat identifier. */
+            channel_id?: string;
+            /** @description Provider thread identifier within the channel. */
+            thread_id?: string;
+        };
+        /** @description Resolve-or-create policy for a session. */
+        CreateSessionRequest: {
+            /** @description Agent that owns the session. */
+            agent_id: string;
+            /**
+             * @description `continue_or_create` (default) resolves an existing session for the `session_key` or creates one; `new` always creates a fresh session; `continue` resolves an existing session and fails if none exists.
+             * @enum {string}
              */
             mode?: "new" | "continue" | "continue_or_create";
             /** @description Stable key identifying the conversation within the agent. */
@@ -3481,45 +4601,42 @@ export interface components {
             visibility?: components["schemas"]["SessionVisibility"];
             /** @description Model to record on the session. */
             model?: string;
+            /** @description Per-session compaction overrides applied when the session is first created. Merged over the agent's default policy and server defaults. Ignored when an existing session is resolved. */
+            compaction_policy?: components["schemas"]["SessionCompactionPolicy"];
             /** @description Free-form caller metadata for the session. */
             metadata?: {
                 [key: string]: unknown;
             };
         };
-        /** @description One input event in a send. Phase 1 supports a single `user.message`. */
-        SendSessionEventInput: {
+        /** @description Caller input that starts an agent turn in a session. */
+        StartTurnRequest: {
             /**
-             * @description Input event type. Defaults to `user.message`.
+             * @description Role of the input message. A turn carries caller input, so only `user` is accepted; defaults to `user` when omitted.
+             * @default user
              * @enum {string}
              */
-            type?: "user.message";
-            /** @description Role to store for the input message. Defaults to `user`. */
-            role?: components["schemas"]["SessionMessageRole"];
+            role: "user";
             /** @description Ordered content blocks (text, images) for the input message. */
             content: {
                 [key: string]: unknown;
             }[];
-        };
-        /** @description Caller input to append and run against a session. */
-        SendSessionEventsRequest: {
-            /** @description Input events to send. Phase 1 accepts exactly one `user.message`. */
-            events: components["schemas"]["SendSessionEventInput"][];
-            /** @description Dedup key scoped to the session. A repeat send with the same key returns the existing invocation's cursor and writes nothing new. */
+            /** @description Dedup key scoped to the session. A repeat call with the same key resumes the existing turn and writes nothing new. */
             idempotency_key?: string;
             /** @description Free-form caller metadata attached to the input message. */
             metadata?: {
                 [key: string]: unknown;
             };
         };
-        /** @description Acknowledgement that an invocation started, with a stream cursor. */
-        SessionInvocationAck: {
+        /** @description Acknowledgement that a turn started, with a stream cursor. */
+        TurnAck: {
             session: components["schemas"]["Session"];
+            turn: components["schemas"]["AgentTurn"];
             /**
              * Format: int64
-             * @description The durable event sequence cursor to stream from. Pass it as `after_sequence` to the events stream to follow this invocation.
+             * @description The transcript message `sequence` cursor to stream from. Pass it as `after_sequence` to `GET .../stream` to follow this turn.
              */
-            seq: number;
-            /** @description True when a repeated idempotency key returned an existing invocation. */
+            after_sequence: number;
+            /** @description True when a repeated idempotency key resumed an existing turn. */
             deduped?: boolean;
         };
         /**
@@ -4099,7 +5216,7 @@ export interface components {
         };
         /** @description Durable conversation-session policy for loop agent steps. Omit to enable the product default: loop-scoped sessions keyed from the triggering conversation when Mobius can identify one, such as a Telegram chat ID. */
         LoopAgentSessionPolicy: {
-            /** @description Disable durable session context and transcript writes for the affected agent step(s). */
+            /** @description Reserved for internal synthesized agent executions. Authored loop agent steps are session-backed; setting this to `true` is rejected. */
             disabled?: boolean;
             /**
              * @description Named-session boundary. `auto` and omitted use `loop`. `agent` intentionally shares the named session across loops using the same agent.
@@ -4112,25 +5229,8 @@ export interface components {
             title?: string;
             /** @description Visibility for durable sessions created from this policy. */
             visibility?: components["schemas"]["SessionVisibility"];
-            /**
-             * @description Optional per-session compaction policy merged with server defaults when the session is first created. Existing sessions keep their current compaction policy unless edited through a session-specific operation.
-             * @example {
-             *       "strategy": "auto",
-             *       "threshold_tokens": 25000,
-             *       "summary_model": "claude-haiku-4-5-20251001"
-             *     }
-             */
-            compaction_policy?: {
-                /**
-                 * @description Compaction strategy: `auto`, `manual`, `disabled`, or `none`.
-                 * @enum {string}
-                 */
-                strategy?: "auto" | "manual" | "disabled" | "none";
-                /** @description Token threshold that triggers automatic compaction. */
-                threshold_tokens?: number;
-                /** @description Model used to produce compaction summaries. */
-                summary_model?: string;
-            };
+            /** @description Optional per-session compaction policy merged with server defaults when the session is first created. Existing sessions keep their current compaction policy unless edited through a session-specific operation. */
+            compaction_policy?: components["schemas"]["SessionCompactionPolicy"];
         };
         /** @description Model-routing override for an agent step. */
         LoopModelRoute: {
@@ -4141,12 +5241,10 @@ export interface components {
             mode: "managed" | "worker";
             /** @description Managed environment to route worker-backed model calls to. */
             environment_id?: string;
-            /** @description Provider or worker route name. */
+            /** @description Provider id advertised by a local worker when `mode` is `worker`. */
             provider?: string;
             /** @description Model identifier for this route. */
             model?: string;
-            /** @description Worker queue for customer-worker model calls. */
-            queue?: string;
         };
         /** @description Action step configuration recognised inside `LoopSpec.steps[].config`. */
         LoopActionStep: {
@@ -4407,6 +5505,10 @@ export interface components {
             loop_version: number;
             /** @description Current lifecycle state of this run. */
             status: components["schemas"]["LoopRunStatus"];
+            /** @description Gate that placed this run in the durable queue. Present only while `status` is `queued`. */
+            queue_reason?: components["schemas"]["LoopRunQueueReason"];
+            /** @description Org-wide concurrent-run ceiling stamped at run start. Present when the run was evaluated against a plan concurrency limit. */
+            plan_concurrency_limit?: number;
             /** @description Terminal reason recorded when the run stops. */
             stop_reason?: components["schemas"]["LoopRunStopReason"];
             /**
@@ -4487,6 +5589,11 @@ export interface components {
          * @enum {string}
          */
         LoopRunStatus: "queued" | "running" | "suspended" | "completed" | "failed" | "cancelled";
+        /**
+         * @description Why a run is waiting in the queue. `plan_concurrency` means the organization's current plan has no active-run capacity available. `loop_policy` and `trigger_concurrency` mean authored concurrency policy deferred the run.
+         * @enum {string}
+         */
+        LoopRunQueueReason: "plan_concurrency" | "loop_policy" | "trigger_concurrency";
         /**
          * @description Why a run stopped. Set exactly once when the run reaches a terminal status; absent on non-terminal runs. `status` carries the lifecycle state and `error_type` classifies the error when one occurred; `stop_reason` classifies the stop itself.
          *
@@ -4650,113 +5757,325 @@ export interface components {
              */
             sequence: number;
             /**
-             * @description Event type from the run-stream taxonomy (e.g. `run.started`, `step.completed`, `wait.opened`, `action.called`, `action.completed`, `action.failed`, `artifact.created`, `limit.reached`, `usage.recorded`).
+             * @description Event type from the run-stream taxonomy (e.g. `run.started`, `step.completed`, `wait.opened`, `action.called`, `action.completed`, `action.failed`, `artifact.created`, `limit.reached`).
              *
-             *     Guardrail events: `run.budget_exceeded` fires when the budget halts the run at a checkpoint (payload: `credit_budget`, `credit_spent`, `percent_used`, plus the `step` it halted before). `usage.recorded` payloads carry `step_key`, the event's `credit_cost`, its `budget_cost` (rate-card cost counted against the run budget, nonzero even for BYOK), and the cumulative `run_credit_spent`.
+             *     Guardrail events: `run.budget_exceeded` fires when the budget halts the run at a checkpoint (payload: `credit_budget`, `credit_spent`, `percent_used`, plus the `step` it halted before). Metered spend is recorded in the billing ledger and denormalized onto the run's `credit_spent`; it is not represented as a timeline event.
              */
             event_type: string;
             /** @description ID of the step this event belongs to, when applicable. */
             step_id?: string | null;
             /** @description Legacy alias for the loop step ID this event belongs to, when applicable. */
             step_key?: string | null;
-            /** @description Event-type-specific payload. See the run-event taxonomy for shapes. */
-            payload?: {
-                [key: string]: unknown;
-            };
+            payload?: components["schemas"]["RunEventPayload"];
             /**
              * Format: date-time
              * @description Server timestamp when the event was recorded.
              */
             created_at: string;
         };
-        LoopRunEventListResponse: {
-            /** @description Run events in this page, ordered by `sequence` ascending. */
-            items: components["schemas"]["LoopRunEvent"][];
-            /**
-             * Format: int64
-             * @description Sequence number of the most recent event in `items`; clients can pass this back as `after_sequence` on the next poll.
-             */
-            next_sequence?: number;
-            /** @description True when more events exist after the returned page. */
-            has_more?: boolean;
+        /** @description Durable run lifecycle frame. SSE messages carrying this shape include `id: <sequence>`, and that value is the only cursor clients should persist for `after_sequence` or `Last-Event-ID` resume. */
+        LoopRunLifecycleFrame: components["schemas"]["LoopRunEvent"];
+        /** @description JSON payload of a single `data:` line on the run event SSE stream. Run stream frames are lifecycle/observability events and are replayable with an SSE `id:`. Agent transcript content is delivered by the referenced session stream. */
+        LoopRunStreamFrame: components["schemas"]["LoopRunLifecycleFrame"];
+        /** @description Typed payloads for common durable run event types. The containing `LoopRunEvent.event_type` selects the payload shape; payload objects do not duplicate that discriminator because some payloads use fields such as `event_type` for their own lifecycle data (for example, the external matcher recorded by `wait.opened`). */
+        RunEventPayload: components["schemas"]["RunStartedPayload"] | components["schemas"]["WaitPayload"] | components["schemas"]["RunResumedPayload"] | components["schemas"]["RunCompletedPayload"] | components["schemas"]["RunFailedPayload"] | components["schemas"]["RunCancelledPayload"] | components["schemas"]["StepStartedPayload"] | components["schemas"]["StepCompletedPayload"] | components["schemas"]["StepFailedPayload"] | components["schemas"]["StepRetriedPayload"] | components["schemas"]["StepResumedPayload"] | components["schemas"]["StepSkippedPayload"] | components["schemas"]["ActionCalledPayload"] | components["schemas"]["ActionCompletedPayload"] | components["schemas"]["ActionFailedPayload"] | components["schemas"]["ActionRetriedPayload"] | components["schemas"]["ActionResultPayload"] | components["schemas"]["CheckVerdictPayload"] | components["schemas"]["InteractionRespondedPayload"] | components["schemas"]["WaitResumedPayload"] | components["schemas"]["WaitTimedOutPayload"] | components["schemas"]["BudgetExceededPayload"] | components["schemas"]["ProgressStalledPayload"] | components["schemas"]["LimitReachedPayload"] | components["schemas"]["ArtifactCreatedPayload"] | components["schemas"]["GenericEventPayload"];
+        RunStartedPayload: {
+            loop_id?: string;
+            loop_version_id?: string;
+            source_event_id?: string;
+            trigger_id?: string;
+        } & {
+            [key: string]: unknown;
         };
-        /**
-         * @example {
-         *       "name": "GitHub review",
-         *       "description": "GitHub actions needed for pull-request review.",
-         *       "actions": [
-         *         {
-         *           "selector_type": "exact",
-         *           "selector": "github.create_review_comment"
-         *         }
-         *       ],
-         *       "tags": {
-         *         "owner": "product"
-         *       }
-         *     }
-         */
-        ToolkitRequest: {
-            /** @description Human-readable toolkit name. */
-            name: string;
-            /** @description Markdown description of the toolkit's purpose. */
-            description?: string;
-            /** @description Action selectors provided by this toolkit. */
-            actions?: components["schemas"]["ToolkitAction"][];
-            /** @description Labels to apply to the toolkit. */
-            tags?: components["schemas"]["TagMap"];
+        RunResumedPayload: {
+            step?: string;
+            reason?: string;
+        } & {
+            [key: string]: unknown;
         };
-        ToolkitListResponse: {
-            /** @description The list of results for this page. */
-            items: components["schemas"]["Toolkit"][];
+        RunCompletedPayload: {
+            output?: {
+                [key: string]: unknown;
+            };
+        } & {
+            [key: string]: unknown;
         };
-        /**
-         * @example {
-         *       "name": "Pull request review",
-         *       "description": "Review pull requests for correctness and risk.",
-         *       "instructions": "Check the diff and leave concise findings.",
-         *       "allowed_tools": [
-         *         "github.create_review_comment"
-         *       ],
-         *       "tags": {
-         *         "owner": "product"
-         *       }
-         *     }
-         */
-        SkillRequest: {
-            /** @description Human-readable skill name. */
-            name: string;
-            /** @description Markdown description of the skill's purpose. */
-            description?: string;
-            /** @description Markdown instructions loaded when the skill is active. */
-            instructions: string;
-            /**
-             * @description Tool selectors that narrow the agent's effective tool set while this skill is active.
-             * @default []
-             */
-            allowed_tools: string[];
-            /** @description Labels to apply to the skill. */
-            tags?: components["schemas"]["TagMap"];
+        RunFailedPayload: {
+            error?: string;
+            error_type?: string;
+            step?: string;
+        } & {
+            [key: string]: unknown;
         };
-        ImportSkillRequest: {
-            /** @description Full skill document, optionally with YAML frontmatter. */
-            content: string;
-            /** @description Optional name override. */
-            name?: string;
+        RunCancelledPayload: {
+            reason?: string;
+        } & {
+            [key: string]: unknown;
         };
-        SkillListResponse: {
-            /** @description The list of results for this page. */
-            items: components["schemas"]["Skill"][];
+        StepStartedPayload: {
+            step?: string;
+            kind?: string;
+            agent_id?: string;
+        } & {
+            [key: string]: unknown;
         };
-        /**
-         * @description Column value type: `string`, `number`, `boolean`, `date`, `object`, `array`, or `any`.
-         * @enum {string}
-         */
-        ColumnType: "string" | "number" | "boolean" | "date" | "object" | "array" | "any";
-        /** @description One typed column in a table schema. */
-        ColumnDef: {
-            /** @description Column name used as the key inside row `data`. */
-            name: string;
-            /** @description JSON-compatible value type accepted for this column. */
+        StepCompletedPayload: {
+            step?: string;
+            output?: {
+                [key: string]: unknown;
+            };
+        } & {
+            [key: string]: unknown;
+        };
+        StepFailedPayload: {
+            step?: string;
+            error?: string;
+            error_type?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        StepRetriedPayload: {
+            step?: string;
+            attempt?: number;
+            max_attempts?: number;
+            error?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        StepResumedPayload: {
+            step?: string;
+            kind?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        StepSkippedPayload: {
+            step?: string;
+            kind?: string;
+            reason?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        ActionCalledPayload: {
+            action?: string;
+            step?: string;
+            parameters?: {
+                [key: string]: unknown;
+            };
+        } & {
+            [key: string]: unknown;
+        };
+        ActionCompletedPayload: {
+            action?: string;
+            step?: string;
+            result?: {
+                [key: string]: unknown;
+            };
+        } & {
+            [key: string]: unknown;
+        };
+        ActionFailedPayload: {
+            action?: string;
+            step?: string;
+            error?: string;
+            error_type?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        ActionRetriedPayload: {
+            action?: string;
+            attempt?: number;
+            max_attempts?: number;
+        } & {
+            [key: string]: unknown;
+        };
+        ActionResultPayload: {
+            action?: string;
+            result?: {
+                [key: string]: unknown;
+            };
+        } & {
+            [key: string]: unknown;
+        };
+        CheckVerdictPayload: {
+            step?: string;
+            verdict?: string;
+            on_fail?: string;
+            failed?: string[];
+        } & {
+            [key: string]: unknown;
+        };
+        InteractionRespondedPayload: {
+            interaction_id?: string;
+            response?: {
+                [key: string]: unknown;
+            };
+            responder?: {
+                [key: string]: unknown;
+            };
+        } & {
+            [key: string]: unknown;
+        };
+        WaitPayload: {
+            step?: string;
+            /** @description Source event type or pattern this wait is listening for. */
+            event_type?: string;
+            /** @description Optional source identifier that scopes event matching. */
+            source_id?: string;
+            /** @description Optional matcher fields required on the source event. */
+            match?: {
+                [key: string]: unknown;
+            };
+            wait_id?: string;
+            wait_kind?: string;
+            /**
+             * Format: date-time
+             * @description Wall-clock expiry for the wait, when bounded.
+             */
+            expires_at?: string;
+            /** Format: date-time */
+            deadline?: string;
+            subject?: {
+                [key: string]: unknown;
+            };
+        } & {
+            [key: string]: unknown;
+        };
+        WaitResumedPayload: {
+            step?: string;
+            wait_id?: string;
+            payload?: {
+                [key: string]: unknown;
+            };
+        } & {
+            [key: string]: unknown;
+        };
+        WaitTimedOutPayload: {
+            step?: string;
+            wait_id?: string;
+            reason?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        BudgetExceededPayload: {
+            step?: string;
+            credit_spent?: number;
+            credit_budget?: number;
+            percent_used?: number;
+        } & {
+            [key: string]: unknown;
+        };
+        ProgressStalledPayload: {
+            step?: string;
+            tool?: string;
+            duplicate_calls?: number;
+            limit?: number;
+        } & {
+            [key: string]: unknown;
+        };
+        LimitReachedPayload: {
+            step?: string;
+            limit_kind?: string;
+            used?: number;
+            limit?: number;
+        } & {
+            [key: string]: unknown;
+        };
+        ArtifactCreatedPayload: {
+            artifact_id?: string;
+            name?: string;
+            content_type?: string;
+            step?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        LoopRunEventListResponse: {
+            /** @description Run events in this page, ordered by `sequence` ascending. */
+            items: components["schemas"]["LoopRunEvent"][];
+            /**
+             * Format: int64
+             * @description Sequence number of the most recent event in `items`; clients can pass this back as `after_sequence` on the next poll.
+             */
+            next_sequence?: number;
+            /** @description True when more events exist after the returned page. */
+            has_more?: boolean;
+        };
+        /**
+         * @example {
+         *       "name": "GitHub review",
+         *       "description": "GitHub actions needed for pull-request review.",
+         *       "actions": [
+         *         {
+         *           "selector_type": "exact",
+         *           "selector": "github.create_review_comment"
+         *         }
+         *       ],
+         *       "tags": {
+         *         "owner": "product"
+         *       }
+         *     }
+         */
+        ToolkitRequest: {
+            /** @description Human-readable toolkit name. */
+            name: string;
+            /** @description Markdown description of the toolkit's purpose. */
+            description?: string;
+            /** @description Action selectors provided by this toolkit. */
+            actions?: components["schemas"]["ToolkitAction"][];
+            /** @description Labels to apply to the toolkit. */
+            tags?: components["schemas"]["TagMap"];
+        };
+        ToolkitListResponse: {
+            /** @description The list of results for this page. */
+            items: components["schemas"]["Toolkit"][];
+        };
+        /**
+         * @example {
+         *       "name": "Pull request review",
+         *       "description": "Review pull requests for correctness and risk.",
+         *       "instructions": "Check the diff and leave concise findings.",
+         *       "allowed_tools": [
+         *         "github.create_review_comment"
+         *       ],
+         *       "tags": {
+         *         "owner": "product"
+         *       }
+         *     }
+         */
+        SkillRequest: {
+            /** @description Human-readable skill name. */
+            name: string;
+            /** @description Markdown description of the skill's purpose. */
+            description?: string;
+            /** @description Markdown instructions loaded when the skill is active. */
+            instructions: string;
+            /**
+             * @description Tool selectors that narrow the agent's effective tool set while this skill is active.
+             * @default []
+             */
+            allowed_tools: string[];
+            /** @description Labels to apply to the skill. */
+            tags?: components["schemas"]["TagMap"];
+        };
+        ImportSkillRequest: {
+            /** @description Full skill document, optionally with YAML frontmatter. */
+            content: string;
+            /** @description Optional name override. */
+            name?: string;
+        };
+        SkillListResponse: {
+            /** @description The list of results for this page. */
+            items: components["schemas"]["Skill"][];
+        };
+        /**
+         * @description Column value type: `string`, `number`, `boolean`, `date`, `object`, `array`, or `any`.
+         * @enum {string}
+         */
+        ColumnType: "string" | "number" | "boolean" | "date" | "object" | "array" | "any";
+        /** @description One typed column in a table schema. */
+        ColumnDef: {
+            /** @description Column name used as the key inside row `data`. */
+            name: string;
+            /** @description JSON-compatible value type accepted for this column. */
             type: components["schemas"]["ColumnType"];
             /**
              * @description Whether inserts must include a non-null value for this column.
@@ -4764,7 +6083,8 @@ export interface components {
              */
             required: boolean;
             /**
-             * @description Marks the column as an expected filter/sort field so backends can maintain efficient indexes.
+             * @deprecated
+             * @description Compatibility hint retained for older schemas. It does not create a physical database index.
              * @default false
              */
             indexed: boolean;
@@ -4778,21 +6098,31 @@ export interface components {
              */
             deprecated: boolean;
         };
-        /** @description Declared index over one or more table columns. */
+        /** @description Compatibility metadata for older table schemas. Declared indexes do not create physical database indexes. */
         IndexDef: {
             /** @description Stable index name unique within the table schema. */
             name: string;
             /** @description Column names included in the index, in order. */
             columns: string[];
         };
-        /** @description Column and index definition for a table. Each table has exactly one required string identity column. */
+        /** @description Column definition for a virtual table. Each table has exactly one required string identity column and may nominate one optional string secondary key column. */
         TableSchema: {
             /** @description Name of the required string column that uniquely identifies one row in this table. */
             identity_column: string;
+            /** @description Optional string column projected into the fixed physical `sk` column for efficient secondary lookups. It cannot be changed after creation. */
+            secondary_key_column?: string;
             /** @description Ordered list of columns accepted in row data. */
             columns: components["schemas"]["ColumnDef"][];
-            /** @description Optional declared indexes maintained by the backend. */
+            /**
+             * @deprecated
+             * @description Compatibility metadata retained for older schemas. Index declarations do not create physical database indexes.
+             */
             indexes?: components["schemas"]["IndexDef"][];
+            /**
+             * @description Allows rows to include undeclared keys while declared columns continue to be validated.
+             * @default false
+             */
+            open: boolean;
         };
         /**
          * @description Project table metadata and schema.
@@ -4903,14 +6233,14 @@ export interface components {
             approx_data_bytes: number;
             /**
              * Format: int64
-             * @description Approximate bytes used by table indexes.
+             * @description Approximate proportional share of fixed table_rows index bytes.
              */
             approx_index_bytes: number;
-            /** @description Number of columns with backend-maintained indexes. */
+            /** @description Number of schema columns projected into fixed physical keys. */
             indexed_column_count: number;
-            /** @description Number of indexes declared in the table schema. */
+            /** @description Number of compatibility index declarations stored in the table schema. */
             declared_index_count: number;
-            /** @description Whether a full-text search index is present for the table. */
+            /** @description Whether the fixed shared full-text search index is present. */
             search_index_present: boolean;
             /**
              * Format: date-time
@@ -4969,13 +6299,13 @@ export interface components {
             description?: string;
             /** @description Optional author guidance for how this table should be used (e.g. surfaced to agents). */
             instructions?: string;
-            /** @description Replacement column and index definition. */
+            /** @description Replacement column and index definition. The identity column and required column settings are immutable after creation; newly added columns must be optional. */
             schema?: components["schemas"]["TableSchema"];
         };
         /**
          * @description One stored row in a project table.
          * @example {
-         *       "id": "tablerow_5p9x2q7m4n8v3r6t",
+         *       "id": "row_5p9x2q7m4n8v3r6t",
          *       "table_id": "table_2x7q5m9v3p8r4n6t",
          *       "data": {
          *         "pull_request_url": "https://github.com/deepnoodle-ai/mobius-cloud/pull/123",
@@ -5068,9 +6398,15 @@ export interface components {
             next_cursor?: string;
         };
         SearchRowsRequest: {
-            /** @description Token-prefix search query. Hyphens and other punctuation split terms. */
+            /** @description Search query. Hyphens and other punctuation split terms for keyword matching. */
             query: string;
-            /** @description Optional column equality or operator filter applied before text search. */
+            /**
+             * @description Search mode. `keyword` uses token-prefix full-text search, `semantic` uses sidecar embedding similarity, and `hybrid` combines both.
+             * @default keyword
+             * @enum {string}
+             */
+            mode: "keyword" | "semantic" | "hybrid";
+            /** @description Optional column equality or operator filter applied before search. */
             filter?: {
                 [key: string]: unknown;
             };
@@ -5362,6 +6698,10 @@ export interface components {
         ProjectHandleParam: string;
         /** @description Resource ID. */
         IDParam: string;
+        /** @description Identifier of the conversation session. */
+        SessionIdParam: string;
+        /** @description Identifier of a turn within a session. */
+        TurnIdParam: string;
         /** @description Action name used in loop step definitions. */
         ActionNameParam: string;
         /** @description Principal ID. */
@@ -5370,6 +6710,14 @@ export interface components {
         CursorParam: string;
         /** @description Maximum number of items to return */
         LimitParam: number;
+        /** @description Continuation cursor for sequence-ordered lists. Only include rows whose monotonic per-resource sequence is strictly greater than this value. Pass the `next_sequence` from the previous response to fetch the next page. */
+        AfterSequenceParam: number;
+        /** @description Backward continuation cursor for sequence-ordered lists. Only include rows whose monotonic per-resource sequence is strictly less than this value. Combine with `order=desc` to page toward older rows from a known position; pass the `prev_sequence` from the previous response to fetch the next older page. */
+        BeforeSequenceParam: number;
+        /** @description Scan direction for the page. `asc` (the default) returns oldest-first; `desc` returns newest-first — the way to fetch the latest rows of a long list (the tail) in a single request. Items in the response are always ordered ascending regardless of this value; `order` only selects which end of the list the page is taken from. */
+        OrderParam: "asc" | "desc";
+        /** @description SSE reconnect cursor. The browser EventSource API replays the last event's `id` in this header on automatic reconnect; the server resumes the stream after that sequence number. When both this header and the `after_sequence` query parameter are supplied, the larger sequence wins, so an explicit `after_sequence` never rewinds a live reconnect. Ignored for non-streaming (JSON) requests. */
+        LastEventIDParam: number;
         /** @description ID of the target organization for the admin operation. */
         AdminOrgIDParam: string;
         /** @description Environment ID. */
@@ -5386,6 +6734,8 @@ export interface components {
         IntegrationEventIDParam: string;
         /** @description Framework provider identifier from the integration provider catalog. */
         IntegrationProviderParam: string;
+        /** @description The key identifying a memory entry. Restricted to a path-safe character set (letters, numbers, and `. _ : -`) so it stays reliably addressable. */
+        MemoryKeyParam: string;
         /** @description Table ID. */
         TableIDParam: string;
         /** @description Filter tables by name. Table names are unique within a project; use this as a discovery filter and use the returned table `id` for follow-up operations. */
@@ -5944,6 +7294,32 @@ export interface operations {
             404: components["responses"]["NotFound"];
         };
     };
+    listCatalogWorkerModels: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Project handle */
+                project_handle: components["parameters"]["ProjectHandleParam"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WorkerModelCatalogResponse"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
     listEnvironments: {
         parameters: {
             query?: {
@@ -6676,13 +8052,21 @@ export interface operations {
             404: components["responses"]["NotFound"];
         };
     };
-    listAgents: {
+    listInteractions: {
         parameters: {
             query?: {
-                /** @description Filter to the agent backed by this principal. */
-                principal_id?: string;
-                /** @description Filter by administrative status (active/inactive), independent of presence. */
-                status?: components["schemas"]["AgentStatus"];
+                /** @description Filter by status */
+                status?: "pending" | "completed" | "expired" | "cancelled";
+                /** @description Filter by interaction protocol kind */
+                kind?: components["schemas"]["InteractionKind"];
+                /** @description Filter by originating run ID */
+                run_id?: string;
+                /** @description Filter by resolved target user ID. */
+                target_user_id?: string;
+                /** @description When true, returns only interactions visible to the authenticated user. */
+                inbox?: boolean;
+                /** @description Cursor for pagination (opaque string from previous response) */
+                cursor?: components["parameters"]["CursorParam"];
                 /** @description Maximum number of items to return */
                 limit?: components["parameters"]["LimitParam"];
             };
@@ -6701,15 +8085,14 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["AgentListResponse"];
+                    "application/json": components["schemas"]["InteractionListResponse"];
                 };
             };
             401: components["responses"]["Unauthorized"];
             403: components["responses"]["Forbidden"];
-            404: components["responses"]["NotFound"];
         };
     };
-    createAgent: {
+    createInteraction: {
         parameters: {
             query?: never;
             header?: never;
@@ -6723,18 +8106,26 @@ export interface operations {
             content: {
                 /**
                  * @example {
-                 *       "name": "PR reviewer",
-                 *       "description": "Reviews pull requests for risky changes.",
-                 *       "kind": "llm",
-                 *       "color": "teal",
-                 *       "model": "claude-sonnet-4-6",
-                 *       "tool_presentation": "meta",
-                 *       "tags": {
-                 *         "owner": "product"
-                 *       }
+                 *       "run_id": "run_8q5m2x9v7p3n4r6t",
+                 *       "signal_name": "manager_approval",
+                 *       "target_user_ids": [
+                 *         "user_2f9s3k4m5n6p7q8r"
+                 *       ],
+                 *       "kind": "request_approval",
+                 *       "title": "Approve publishing the April billing report?",
+                 *       "context": {
+                 *         "report_id": "rpt_2026_04",
+                 *         "amount_usd": 12850
+                 *       },
+                 *       "spec": {
+                 *         "mode": "confirm",
+                 *         "default_confirmed": false
+                 *       },
+                 *       "require_all": false,
+                 *       "expires_at": "2026-04-25T14:30:00Z"
                  *     }
                  */
-                "application/json": components["schemas"]["CreateAgentRequest"];
+                "application/json": components["schemas"]["CreateInteractionRequest"];
             };
         };
         responses: {
@@ -6746,9 +8137,284 @@ export interface operations {
                 content: {
                     /**
                      * @example {
-                     *       "id": "agent_5n8p2q7m4x9r3v6t",
-                     *       "principal_id": "agent_5n8p2q7m4x9r3v6t",
-                     *       "name": "PR reviewer",
+                     *       "id": "iact_6x2m8q5v9p3n7r4t",
+                     *       "run_id": "run_8q5m2x9v7p3n4r6t",
+                     *       "signal_name": "manager_approval",
+                     *       "kind": "request_approval",
+                     *       "status": "pending",
+                     *       "title": "Approve publishing the April billing report?",
+                     *       "context": {
+                     *         "report_id": "rpt_2026_04",
+                     *         "amount_usd": 12850
+                     *       },
+                     *       "spec": {
+                     *         "mode": "confirm",
+                     *         "default_confirmed": false
+                     *       },
+                     *       "target_user_ids": [
+                     *         "user_2f9s3k4m5n6p7q8r"
+                     *       ],
+                     *       "expires_at": "2026-04-25T14:30:00Z",
+                     *       "created_at": "2026-04-24T14:30:00Z",
+                     *       "updated_at": "2026-04-24T14:30:00Z",
+                     *       "require_all": false
+                     *     }
+                     */
+                    "application/json": components["schemas"]["Interaction"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    getInteraction: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Project handle */
+                project_handle: components["parameters"]["ProjectHandleParam"];
+                /** @description Resource ID. */
+                resource_id: components["parameters"]["IDParam"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Interaction"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    deleteInteraction: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Project handle */
+                project_handle: components["parameters"]["ProjectHandleParam"];
+                /** @description Resource ID. */
+                resource_id: components["parameters"]["IDParam"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description No Content */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    respondToInteraction: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Project handle */
+                project_handle: components["parameters"]["ProjectHandleParam"];
+                /** @description Resource ID. */
+                resource_id: components["parameters"]["IDParam"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RespondToInteractionRequest"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "id": "iact_6x2m8q5v9p3n7r4t",
+                     *       "run_id": "run_8q5m2x9v7p3n4r6t",
+                     *       "signal_name": "manager_approval",
+                     *       "kind": "request_approval",
+                     *       "status": "completed",
+                     *       "title": "Approve publishing the April billing report?",
+                     *       "context": {
+                     *         "report_id": "rpt_2026_04",
+                     *         "amount_usd": 12850
+                     *       },
+                     *       "spec": {
+                     *         "mode": "confirm",
+                     *         "default_confirmed": false
+                     *       },
+                     *       "target_user_ids": [
+                     *         "user_2f9s3k4m5n6p7q8r"
+                     *       ],
+                     *       "responder": {
+                     *         "user_id": "user_2f9s3k4m5n6p7q8r"
+                     *       },
+                     *       "resolving_response_id": "iresp_3v7q2m9x5p8n4r6t",
+                     *       "responses": [
+                     *         {
+                     *           "id": "iresp_3v7q2m9x5p8n4r6t",
+                     *           "interaction_id": "iact_6x2m8q5v9p3n7r4t",
+                     *           "response_kind": "response",
+                     *           "state": "submitted",
+                     *           "responder_user_id": "user_2f9s3k4m5n6p7q8r",
+                     *           "value": true,
+                     *           "comment": "Approved for publication.",
+                     *           "responded_at": "2026-04-24T14:42:00Z",
+                     *           "created_at": "2026-04-24T14:42:00Z",
+                     *           "updated_at": "2026-04-24T14:42:00Z"
+                     *         }
+                     *       ],
+                     *       "outcome": true,
+                     *       "resolved_by": "any_of",
+                     *       "expires_at": "2026-04-25T14:30:00Z",
+                     *       "completed_at": "2026-04-24T14:42:00Z",
+                     *       "created_at": "2026-04-24T14:30:00Z",
+                     *       "updated_at": "2026-04-24T14:42:00Z",
+                     *       "require_all": false
+                     *     }
+                     */
+                    "application/json": components["schemas"]["Interaction"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+        };
+    };
+    cancelInteraction: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Project handle */
+                project_handle: components["parameters"]["ProjectHandleParam"];
+                /** @description Resource ID. */
+                resource_id: components["parameters"]["IDParam"];
+            };
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                /**
+                 * @example {
+                 *       "reason": "Superseded by a revised approval request."
+                 *     }
+                 */
+                "application/json": components["schemas"]["CancelInteractionRequest"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Interaction"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    listAgents: {
+        parameters: {
+            query?: {
+                /** @description Filter to the agent backed by this principal. */
+                principal_id?: string;
+                /** @description Filter by administrative status (active/inactive), independent of presence. */
+                status?: components["schemas"]["AgentStatus"];
+                /** @description Maximum number of items to return */
+                limit?: components["parameters"]["LimitParam"];
+            };
+            header?: never;
+            path: {
+                /** @description Project handle */
+                project_handle: components["parameters"]["ProjectHandleParam"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AgentListResponse"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    createAgent: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Project handle */
+                project_handle: components["parameters"]["ProjectHandleParam"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                /**
+                 * @example {
+                 *       "name": "PR reviewer",
+                 *       "description": "Reviews pull requests for risky changes.",
+                 *       "kind": "llm",
+                 *       "color": "teal",
+                 *       "model": "claude-sonnet-4-6",
+                 *       "tool_presentation": "meta",
+                 *       "tags": {
+                 *         "owner": "product"
+                 *       }
+                 *     }
+                 */
+                "application/json": components["schemas"]["CreateAgentRequest"];
+            };
+        };
+        responses: {
+            /** @description Created */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example {
+                     *       "id": "agent_5n8p2q7m4x9r3v6t",
+                     *       "principal_id": "agent_5n8p2q7m4x9r3v6t",
+                     *       "name": "PR reviewer",
                      *       "description": "Reviews pull requests for risky changes.",
                      *       "kind": "llm",
                      *       "color": "teal",
@@ -6906,8 +8572,8 @@ export interface operations {
     listTurnMessages: {
         parameters: {
             query?: {
-                /** @description Only include messages with sequence greater than this value. */
-                after_sequence?: number;
+                /** @description Continuation cursor for sequence-ordered lists. Only include rows whose monotonic per-resource sequence is strictly greater than this value. Pass the `next_sequence` from the previous response to fetch the next page. */
+                after_sequence?: components["parameters"]["AfterSequenceParam"];
                 /** @description Maximum number of items to return */
                 limit?: components["parameters"]["LimitParam"];
             };
@@ -6915,8 +8581,8 @@ export interface operations {
             path: {
                 /** @description Project handle */
                 project_handle: components["parameters"]["ProjectHandleParam"];
-                /** @description Resource ID. */
-                resource_id: components["parameters"]["IDParam"];
+                /** @description Identifier of a turn within a session. */
+                turn_id: components["parameters"]["TurnIdParam"];
             };
             cookie?: never;
         };
@@ -7096,23 +8762,237 @@ export interface operations {
             };
         };
         responses: {
-            /** @description OK */
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ToolkitAssignmentListResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            429: components["responses"]["TooManyRequests"];
+        };
+    };
+    listAgentSkillAssignments: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Project handle */
+                project_handle: components["parameters"]["ProjectHandleParam"];
+                /** @description Resource ID. */
+                resource_id: components["parameters"]["IDParam"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SkillAssignmentListResponse"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    replaceAgentSkillAssignments: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Project handle */
+                project_handle: components["parameters"]["ProjectHandleParam"];
+                /** @description Resource ID. */
+                resource_id: components["parameters"]["IDParam"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                /**
+                 * @example {
+                 *       "skill_ids": [
+                 *         "skill_7n4q8x2m9p5v3r6t"
+                 *       ]
+                 *     }
+                 */
+                "application/json": components["schemas"]["ReplaceSkillsRequest"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SkillAssignmentListResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            429: components["responses"]["TooManyRequests"];
+        };
+    };
+    getAgentTools: {
+        parameters: {
+            query?: {
+                /** @description Optional comma-separated toolkit subset to apply. */
+                toolkit_ids?: string;
+                /** @description Optional assigned skill name to preselect as active. */
+                skill_name?: string;
+                /** @description Optional comma-separated canonical action names, wildcard selectors, or group references to apply as a per-invocation filter against the resolved tool set. */
+                allowed_tools?: string;
+            };
+            header?: never;
+            path: {
+                /** @description Project handle */
+                project_handle: components["parameters"]["ProjectHandleParam"];
+                /** @description Resource ID. */
+                resource_id: components["parameters"]["IDParam"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AgentToolManifest"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    getAgentMemory: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Project handle */
+                project_handle: components["parameters"]["ProjectHandleParam"];
+                /** @description Resource ID. */
+                resource_id: components["parameters"]["IDParam"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AgentMemory"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    listAgentMemoryEntries: {
+        parameters: {
+            query?: {
+                /** @description Optional keyword search over entry keys and content. Omit to list. */
+                query?: string;
+                /** @description Optional filter to a single memory kind. */
+                kind?: components["schemas"]["MemoryKind"];
+                /** @description Cursor for pagination (opaque string from previous response) */
+                cursor?: components["parameters"]["CursorParam"];
+                /** @description Maximum number of items to return */
+                limit?: components["parameters"]["LimitParam"];
+            };
+            header?: never;
+            path: {
+                /** @description Project handle */
+                project_handle: components["parameters"]["ProjectHandleParam"];
+                /** @description Resource ID. */
+                resource_id: components["parameters"]["IDParam"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AgentMemoryEntryListResponse"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    putAgentMemoryEntry: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Project handle */
+                project_handle: components["parameters"]["ProjectHandleParam"];
+                /** @description Resource ID. */
+                resource_id: components["parameters"]["IDParam"];
+                /** @description The key identifying a memory entry. Restricted to a path-safe character set (letters, numbers, and `. _ : -`) so it stays reliably addressable. */
+                memory_key: components["parameters"]["MemoryKeyParam"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["PutAgentMemoryEntryRequest"];
+            };
+        };
+        responses: {
+            /** @description Updated */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["ToolkitAssignmentListResponse"];
+                    "application/json": components["schemas"]["AgentMemoryEntry"];
+                };
+            };
+            /** @description Created */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AgentMemoryEntry"];
                 };
             };
             400: components["responses"]["BadRequest"];
             401: components["responses"]["Unauthorized"];
             403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
-            429: components["responses"]["TooManyRequests"];
         };
     };
-    listAgentSkillAssignments: {
+    deleteAgentMemoryEntry: {
         parameters: {
             query?: never;
             header?: never;
@@ -7121,34 +9001,32 @@ export interface operations {
                 project_handle: components["parameters"]["ProjectHandleParam"];
                 /** @description Resource ID. */
                 resource_id: components["parameters"]["IDParam"];
+                /** @description The key identifying a memory entry. Restricted to a path-safe character set (letters, numbers, and `. _ : -`) so it stays reliably addressable. */
+                memory_key: components["parameters"]["MemoryKeyParam"];
             };
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description OK */
-            200: {
+            /** @description Deleted */
+            204: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content: {
-                    "application/json": components["schemas"]["SkillAssignmentListResponse"];
-                };
+                content?: never;
             };
             401: components["responses"]["Unauthorized"];
             403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
         };
     };
-    replaceAgentSkillAssignments: {
+    invokeAgent: {
         parameters: {
             query?: never;
             header?: never;
             path: {
                 /** @description Project handle */
                 project_handle: components["parameters"]["ProjectHandleParam"];
-                /** @description Resource ID. */
-                resource_id: components["parameters"]["IDParam"];
             };
             cookie?: never;
         };
@@ -7156,65 +9034,63 @@ export interface operations {
             content: {
                 /**
                  * @example {
-                 *       "skill_ids": [
-                 *         "skill_7n4q8x2m9p5v3r6t"
-                 *       ]
+                 *       "agent_ref": {
+                 *         "id": "agent_5n8p2q7m4x9r3v6t"
+                 *       },
+                 *       "session": {
+                 *         "mode": "continue_or_create",
+                 *         "session_key": "app:acct_123:user_456:slack:support:thread_789",
+                 *         "title": "Support in Slack",
+                 *         "metadata": {
+                 *           "account_id": "acct_123",
+                 *           "user_id": "user_456"
+                 *         }
+                 *       },
+                 *       "input": {
+                 *         "content": [
+                 *           {
+                 *             "type": "text",
+                 *             "text": "Can you summarize my open tickets?"
+                 *           }
+                 *         ],
+                 *         "idempotency_key": "slack:evt_0a1b2c3d"
+                 *       },
+                 *       "channel_context": {
+                 *         "provider": "slack",
+                 *         "workspace_id": "T123",
+                 *         "channel_id": "C123",
+                 *         "thread_id": "1700000000.123"
+                 *       }
                  *     }
                  */
-                "application/json": components["schemas"]["ReplaceSkillsRequest"];
+                "application/json": components["schemas"]["InvokeAgentRequest"];
             };
         };
         responses: {
-            /** @description OK */
+            /** @description Server-sent event stream of the turn's activity, returned when the request sets `Accept: text/event-stream`. Framing matches `GET /v1/projects/{project_handle}/sessions/{session_id}/stream`. */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["SkillAssignmentListResponse"];
+                    "text/event-stream": components["schemas"]["SessionStreamFrame"];
                 };
             };
-            400: components["responses"]["BadRequest"];
-            401: components["responses"]["Unauthorized"];
-            403: components["responses"]["Forbidden"];
-            404: components["responses"]["NotFound"];
-            429: components["responses"]["TooManyRequests"];
-        };
-    };
-    getAgentTools: {
-        parameters: {
-            query?: {
-                /** @description Optional comma-separated toolkit subset to apply. */
-                toolkit_ids?: string;
-                /** @description Optional assigned skill name to preselect as active. */
-                skill_name?: string;
-                /** @description Optional comma-separated canonical action names, wildcard selectors, or group references to apply as a per-invocation filter against the resolved tool set. */
-                allowed_tools?: string;
-            };
-            header?: never;
-            path: {
-                /** @description Project handle */
-                project_handle: components["parameters"]["ProjectHandleParam"];
-                /** @description Resource ID. */
-                resource_id: components["parameters"]["IDParam"];
-            };
-            cookie?: never;
-        };
-        requestBody?: never;
-        responses: {
-            /** @description OK */
-            200: {
+            /** @description The turn was accepted and is running. */
+            202: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["AgentToolManifest"];
+                    "application/json": components["schemas"]["TurnAck"];
                 };
             };
             400: components["responses"]["BadRequest"];
             401: components["responses"]["Unauthorized"];
             403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            429: components["responses"]["TooManyRequests"];
         };
     };
     listSessions: {
@@ -7222,6 +9098,8 @@ export interface operations {
             query?: {
                 /** @description Filter to sessions owned by this agent. */
                 agent_id?: string;
+                /** @description Look up the session with this exact routing key — a read-only deterministic lookup that avoids a create-or-resolve round trip, returning the one matching session or an empty list. Requires `agent_id`, since session keys are scoped to an agent. */
+                session_key?: string;
                 /** @description Filter by session status. */
                 status?: components["schemas"]["SessionStatus"];
                 /** @description Filter by session scope. */
@@ -7232,6 +9110,8 @@ export interface operations {
                 integration_id?: string;
                 /** @description Only include sessions with activity after this timestamp. */
                 since?: string;
+                /** @description Cursor for pagination (opaque string from previous response) */
+                cursor?: components["parameters"]["CursorParam"];
                 /** @description Maximum number of items to return */
                 limit?: components["parameters"]["LimitParam"];
             };
@@ -7296,8 +9176,8 @@ export interface operations {
             path: {
                 /** @description Project handle */
                 project_handle: components["parameters"]["ProjectHandleParam"];
-                /** @description Resource ID. */
-                resource_id: components["parameters"]["IDParam"];
+                /** @description Identifier of the conversation session. */
+                session_id: components["parameters"]["SessionIdParam"];
             };
             cookie?: never;
         };
@@ -7324,8 +9204,8 @@ export interface operations {
             path: {
                 /** @description Project handle */
                 project_handle: components["parameters"]["ProjectHandleParam"];
-                /** @description Resource ID. */
-                resource_id: components["parameters"]["IDParam"];
+                /** @description Identifier of the conversation session. */
+                session_id: components["parameters"]["SessionIdParam"];
             };
             cookie?: never;
         };
@@ -7352,8 +9232,8 @@ export interface operations {
             path: {
                 /** @description Project handle */
                 project_handle: components["parameters"]["ProjectHandleParam"];
-                /** @description Resource ID. */
-                resource_id: components["parameters"]["IDParam"];
+                /** @description Identifier of the conversation session. */
+                session_id: components["parameters"]["SessionIdParam"];
             };
             cookie?: never;
         };
@@ -7383,8 +9263,12 @@ export interface operations {
     listSessionMessages: {
         parameters: {
             query?: {
-                /** @description Only include messages with sequence greater than this value. */
-                after_sequence?: number;
+                /** @description Continuation cursor for sequence-ordered lists. Only include rows whose monotonic per-resource sequence is strictly greater than this value. Pass the `next_sequence` from the previous response to fetch the next page. */
+                after_sequence?: components["parameters"]["AfterSequenceParam"];
+                /** @description Backward continuation cursor for sequence-ordered lists. Only include rows whose monotonic per-resource sequence is strictly less than this value. Combine with `order=desc` to page toward older rows from a known position; pass the `prev_sequence` from the previous response to fetch the next older page. */
+                before_sequence?: components["parameters"]["BeforeSequenceParam"];
+                /** @description Scan direction for the page. `asc` (the default) returns oldest-first; `desc` returns newest-first — the way to fetch the latest rows of a long list (the tail) in a single request. Items in the response are always ordered ascending regardless of this value; `order` only selects which end of the list the page is taken from. */
+                order?: components["parameters"]["OrderParam"];
                 /** @description Maximum number of items to return */
                 limit?: components["parameters"]["LimitParam"];
             };
@@ -7392,8 +9276,8 @@ export interface operations {
             path: {
                 /** @description Project handle */
                 project_handle: components["parameters"]["ProjectHandleParam"];
-                /** @description Resource ID. */
-                resource_id: components["parameters"]["IDParam"];
+                /** @description Identifier of the conversation session. */
+                session_id: components["parameters"]["SessionIdParam"];
             };
             cookie?: never;
         };
@@ -7420,8 +9304,8 @@ export interface operations {
             path: {
                 /** @description Project handle */
                 project_handle: components["parameters"]["ProjectHandleParam"];
-                /** @description Resource ID. */
-                resource_id: components["parameters"]["IDParam"];
+                /** @description Identifier of the conversation session. */
+                session_id: components["parameters"]["SessionIdParam"];
             };
             cookie?: never;
         };
@@ -7449,13 +9333,22 @@ export interface operations {
     };
     listSessionTurns: {
         parameters: {
-            query?: never;
+            query?: {
+                /** @description Return exactly the turns with these ids (the transcript-join primitive). When set, pagination and ordering are ignored and the named turns are returned in chronological order. */
+                ids?: string[];
+                /** @description Scan direction for the page. `asc` (the default) returns oldest-first; `desc` returns newest-first — the way to fetch the latest rows of a long list (the tail) in a single request. Items in the response are always ordered ascending regardless of this value; `order` only selects which end of the list the page is taken from. */
+                order?: components["parameters"]["OrderParam"];
+                /** @description Cursor for pagination (opaque string from previous response) */
+                cursor?: components["parameters"]["CursorParam"];
+                /** @description Maximum number of items to return */
+                limit?: components["parameters"]["LimitParam"];
+            };
             header?: never;
             path: {
                 /** @description Project handle */
                 project_handle: components["parameters"]["ProjectHandleParam"];
-                /** @description Resource ID. */
-                resource_id: components["parameters"]["IDParam"];
+                /** @description Identifier of the conversation session. */
+                session_id: components["parameters"]["SessionIdParam"];
             };
             cookie?: never;
         };
@@ -7475,30 +9368,103 @@ export interface operations {
             404: components["responses"]["NotFound"];
         };
     };
-    streamSessionEvents: {
+    startTurn: {
         parameters: {
-            query?: {
-                /** @description Resume the stream after this durable event sequence number. */
-                after_sequence?: number;
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Project handle */
+                project_handle: components["parameters"]["ProjectHandleParam"];
+                /** @description Identifier of the conversation session. */
+                session_id: components["parameters"]["SessionIdParam"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["StartTurnRequest"];
+            };
+        };
+        responses: {
+            /** @description Server-sent event stream of the turn's activity, returned when the request sets `Accept: text/event-stream`. Framing matches `GET .../stream`. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/event-stream": components["schemas"]["SessionStreamFrame"];
+                };
+            };
+            /** @description The turn was accepted and is running. */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TurnAck"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            429: components["responses"]["TooManyRequests"];
+        };
+    };
+    getSessionTurn: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Project handle */
+                project_handle: components["parameters"]["ProjectHandleParam"];
+                /** @description Identifier of the conversation session. */
+                session_id: components["parameters"]["SessionIdParam"];
+                /** @description Identifier of a turn within a session. */
+                turn_id: components["parameters"]["TurnIdParam"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AgentTurn"];
+                };
             };
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    getSessionTurnLive: {
+        parameters: {
+            query?: never;
             header?: never;
             path: {
                 /** @description Project handle */
                 project_handle: components["parameters"]["ProjectHandleParam"];
-                /** @description Resource ID. */
-                resource_id: components["parameters"]["IDParam"];
+                /** @description Identifier of the conversation session. */
+                session_id: components["parameters"]["SessionIdParam"];
+                /** @description Identifier of a turn within a session. */
+                turn_id: components["parameters"]["TurnIdParam"];
             };
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description Server-sent event stream of session activity. Each message is framed as `event: <event type>` followed by a `data:` line carrying the JSON-encoded event payload (the `SessionStreamEvent` shape, always including `session_id`). Durable events also carry an `id:` line with the event sequence number for `Last-Event-ID` resume. */
+            /** @description OK */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "text/event-stream": components["schemas"]["SessionStreamEvent"];
+                    "application/json": components["schemas"]["SessionLiveSnapshot"];
                 };
             };
             401: components["responses"]["Unauthorized"];
@@ -7506,39 +9472,68 @@ export interface operations {
             404: components["responses"]["NotFound"];
         };
     };
-    sendSessionEvents: {
+    cancelTurn: {
         parameters: {
             query?: never;
             header?: never;
             path: {
                 /** @description Project handle */
                 project_handle: components["parameters"]["ProjectHandleParam"];
-                /** @description Resource ID. */
-                resource_id: components["parameters"]["IDParam"];
+                /** @description Identifier of the conversation session. */
+                session_id: components["parameters"]["SessionIdParam"];
+                /** @description Identifier of a turn within a session. */
+                turn_id: components["parameters"]["TurnIdParam"];
             };
             cookie?: never;
         };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["SendSessionEventsRequest"];
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AgentTurn"];
+                };
             };
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    streamSession: {
+        parameters: {
+            query?: {
+                /** @description Continuation cursor for sequence-ordered lists. Only include rows whose monotonic per-resource sequence is strictly greater than this value. Pass the `next_sequence` from the previous response to fetch the next page. */
+                after_sequence?: components["parameters"]["AfterSequenceParam"];
+            };
+            header?: {
+                /** @description SSE reconnect cursor. The browser EventSource API replays the last event's `id` in this header on automatic reconnect; the server resumes the stream after that sequence number. When both this header and the `after_sequence` query parameter are supplied, the larger sequence wins, so an explicit `after_sequence` never rewinds a live reconnect. Ignored for non-streaming (JSON) requests. */
+                "Last-Event-ID"?: components["parameters"]["LastEventIDParam"];
+            };
+            path: {
+                /** @description Project handle */
+                project_handle: components["parameters"]["ProjectHandleParam"];
+                /** @description Identifier of the conversation session. */
+                session_id: components["parameters"]["SessionIdParam"];
+            };
+            cookie?: never;
         };
+        requestBody?: never;
         responses: {
-            /** @description The invocation was accepted and is running. */
-            202: {
+            /** @description A Server-Sent Events stream of session activity. Each frame is `event: <event type>` followed by a `data:` line carrying the JSON-encoded payload. Durable message frames carry an `id:` line with the message `sequence` for `Last-Event-ID` resume; live-only frames (`generation.delta`, `session.message.preview`, `session.resync`, `tool.call`, `tool.result`) do not carry `id:` and cannot be replayed. */
+            200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["SessionInvocationAck"];
+                    "text/event-stream": components["schemas"]["SessionStreamFrame"];
                 };
             };
-            400: components["responses"]["BadRequest"];
             401: components["responses"]["Unauthorized"];
             403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
-            409: components["responses"]["Conflict"];
-            429: components["responses"]["TooManyRequests"];
         };
     };
     cancelSession: {
@@ -7548,8 +9543,36 @@ export interface operations {
             path: {
                 /** @description Project handle */
                 project_handle: components["parameters"]["ProjectHandleParam"];
-                /** @description Resource ID. */
-                resource_id: components["parameters"]["IDParam"];
+                /** @description Identifier of the conversation session. */
+                session_id: components["parameters"]["SessionIdParam"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Session"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    compactSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Project handle */
+                project_handle: components["parameters"]["ProjectHandleParam"];
+                /** @description Identifier of the conversation session. */
+                session_id: components["parameters"]["SessionIdParam"];
             };
             cookie?: never;
         };
@@ -7567,6 +9590,7 @@ export interface operations {
             401: components["responses"]["Unauthorized"];
             403: components["responses"]["Forbidden"];
             404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
         };
     };
     listLoops: {
@@ -8101,38 +10125,10 @@ export interface operations {
                 /** @description Maximum number of items to return */
                 limit?: components["parameters"]["LimitParam"];
             };
-            header?: never;
-            path: {
-                /** @description Project handle */
-                project_handle: components["parameters"]["ProjectHandleParam"];
-                /** @description Resource ID. */
-                resource_id: components["parameters"]["IDParam"];
-            };
-            cookie?: never;
-        };
-        requestBody?: never;
-        responses: {
-            /** @description OK */
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["LoopRunEventListResponse"];
-                };
-            };
-            401: components["responses"]["Unauthorized"];
-            403: components["responses"]["Forbidden"];
-            404: components["responses"]["NotFound"];
-        };
-    };
-    streamRunEvents: {
-        parameters: {
-            query?: {
-                /** @description Stream events with sequence > after_sequence. */
-                after_sequence?: number;
+            header?: {
+                /** @description SSE reconnect cursor. The browser EventSource API replays the last event's `id` in this header on automatic reconnect; the server resumes the stream after that sequence number. When both this header and the `after_sequence` query parameter are supplied, the larger sequence wins, so an explicit `after_sequence` never rewinds a live reconnect. Ignored for non-streaming (JSON) requests. */
+                "Last-Event-ID"?: components["parameters"]["LastEventIDParam"];
             };
-            header?: never;
             path: {
                 /** @description Project handle */
                 project_handle: components["parameters"]["ProjectHandleParam"];
@@ -8143,13 +10139,14 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description Server-sent event stream. Each message is framed as `event: <run-event type>` followed by a `data:` line carrying the JSON-encoded run event (the `LoopRunEvent` shape). The stream ends when the run reaches a terminal status; reconnect with `after_sequence` (or the `Last-Event-ID` header) to resume. */
+            /** @description A JSON page of run events, or, when the request sets `Accept: text/event-stream`, a Server-Sent Events stream where each durable message is framed as `id: <sequence>`, `event: <run-event type>`, and a `data:` line carrying the JSON-encoded `LoopRunEvent`. Agent transcript content and token previews are streamed on the referenced session stream, not on the run stream. */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "text/event-stream": components["schemas"]["LoopRunEvent"];
+                    "application/json": components["schemas"]["LoopRunEventListResponse"];
+                    "text/event-stream": components["schemas"]["LoopRunStreamFrame"];
                 };
             };
             401: components["responses"]["Unauthorized"];
@@ -8962,7 +10959,7 @@ export interface operations {
                 content: {
                     /**
                      * @example {
-                     *       "id": "tablerow_5p9x2q7m4n8v3r6t",
+                     *       "id": "row_5p9x2q7m4n8v3r6t",
                      *       "table_id": "table_2x7q5m9v3p8r4n6t",
                      *       "data": {
                      *         "pull_request_url": "https://github.com/deepnoodle-ai/mobius-cloud/pull/123",
@@ -9031,7 +11028,7 @@ export interface operations {
                      * @example {
                      *       "items": [
                      *         {
-                     *           "id": "tablerow_5p9x2q7m4n8v3r6t",
+                     *           "id": "row_5p9x2q7m4n8v3r6t",
                      *           "table_id": "table_2x7q5m9v3p8r4n6t",
                      *           "data": {
                      *             "pull_request_url": "https://github.com/deepnoodle-ai/mobius-cloud/pull/123",
@@ -9094,7 +11091,7 @@ export interface operations {
                      * @example {
                      *       "items": [
                      *         {
-                     *           "id": "tablerow_5p9x2q7m4n8v3r6t",
+                     *           "id": "row_5p9x2q7m4n8v3r6t",
                      *           "table_id": "table_2x7q5m9v3p8r4n6t",
                      *           "data": {
                      *             "pull_request_url": "https://github.com/deepnoodle-ai/mobius-cloud/pull/123",
@@ -9156,7 +11153,7 @@ export interface operations {
                     /**
                      * @example {
                      *       "row": {
-                     *         "id": "tablerow_5p9x2q7m4n8v3r6t",
+                     *         "id": "row_5p9x2q7m4n8v3r6t",
                      *         "table_id": "table_2x7q5m9v3p8r4n6t",
                      *         "data": {
                      *           "pull_request_url": "https://github.com/deepnoodle-ai/mobius-cloud/pull/123",
@@ -9182,7 +11179,7 @@ export interface operations {
                     /**
                      * @example {
                      *       "row": {
-                     *         "id": "tablerow_6n3r8v4m7q2x9p5t",
+                     *         "id": "row_6n3r8v4m7q2x9p5t",
                      *         "table_id": "table_2x7q5m9v3p8r4n6t",
                      *         "data": {
                      *           "pull_request_url": "https://github.com/deepnoodle-ai/mobius-cloud/pull/124",
@@ -9252,7 +11249,7 @@ export interface operations {
                      *       "inserted": 2,
                      *       "items": [
                      *         {
-                     *           "id": "tablerow_5p9x2q7m4n8v3r6t",
+                     *           "id": "row_5p9x2q7m4n8v3r6t",
                      *           "table_id": "table_2x7q5m9v3p8r4n6t",
                      *           "data": {
                      *             "pull_request_url": "https://github.com/deepnoodle-ai/mobius-cloud/pull/123",
@@ -9300,7 +11297,7 @@ export interface operations {
                 content: {
                     /**
                      * @example {
-                     *       "id": "tablerow_5p9x2q7m4n8v3r6t",
+                     *       "id": "row_5p9x2q7m4n8v3r6t",
                      *       "table_id": "table_2x7q5m9v3p8r4n6t",
                      *       "data": {
                      *         "pull_request_url": "https://github.com/deepnoodle-ai/mobius-cloud/pull/123",
@@ -9385,7 +11382,7 @@ export interface operations {
                 content: {
                     /**
                      * @example {
-                     *       "id": "tablerow_5p9x2q7m4n8v3r6t",
+                     *       "id": "row_5p9x2q7m4n8v3r6t",
                      *       "table_id": "table_2x7q5m9v3p8r4n6t",
                      *       "data": {
                      *         "pull_request_url": "https://github.com/deepnoodle-ai/mobius-cloud/pull/123",