@managoat/fountain-sdk 6.2.0 → 6.3.0

package/CHANGELOG.md

@@ -11,6 +11,19 @@ server releases.
 
 ---
 
+## [6.3.0] - 2026-09-30
+
+### Added
+
+- The generated types carry ACP session config options (#2537, ADR 0062):
+  - `session_config` on agents, conversations, `ConversationCreateRequest`,
+    `ConversationReapplyRequest` and `PromptRequest`;
+  - the conversation's `session_config_options`;
+  - the turn's `config_selection`.
+
+  Pass `session_config` through `runRequest` or a raw request body, for
+  example `{ effort: "high", fast: true }`.
+
 ## [6.2.0] - 2026-09-26
 
 ### Added

package/dist/generated/openapi.d.ts

@@ -1353,7 +1353,7 @@ export interface paths {
         };
         /**
          * List a conversation's log events
-         * @description The read-model behind the SSE stream. Same rows, same fields, as JSON — fetching or archiving a conversation's output no longer requires an SSE parser. Oldest first, cursor-paginated: pass the previous page's `meta.next_cursor` as `after`. SSE remains the tail/follow mechanism.
+         * @description The read-model behind the SSE stream. Same rows, same fields, as JSON — fetching or archiving a conversation's output no longer requires an SSE parser. Oldest first, cursor-paginated: pass the previous page's `meta.next_cursor` as `after`. SSE remains the tail/follow mechanism. With `order=desc` the page is the newest events instead, newest first, and `meta.next_cursor` is the page's oldest id, to pass as `before` for the page older than it; add `whole_turns=true` so no page ends inside a turn. `page.newest_cursor` of the first such page is where an SSE follow resumes (`Last-Event-ID`).
          */
         get: operations["FountainWeb.ConversationController.events"];
         put?: never;
@@ -1465,7 +1465,7 @@ export interface paths {
          *
          *     `model` changes the model this conversation runs from its next turn (ADR 0061), continuing the same runtime session. It is refused with 422 `model_invalid` when the runtime cannot run it, and with 409 `inference_source_changed` when the conversation's credential does not serve it.
          *
-         *     Refused with 409 `conversation_busy` while a turn runs, 409 `rebuild_required` when the selection would need the machine built again (the `field` says which one forced it), 503 while the machine is still being built, and 410 once the conversation has ended.
+         *     Refused with 409 `conversation_busy` while a turn runs, 409 `rebuild_required` when the selection would need the machine built again (the `field` says which one forced it; for a conversation attached to another agent's sandbox with `sandbox_id`, `shared_sandbox` while another conversation is on it and `guest` once it is alone), 503 while the machine is still being built, and 410 once the conversation has ended.
          */
         post: operations["FountainWeb.ConversationController.reapply"];
         delete?: never;
@@ -2398,6 +2398,26 @@ export interface paths {
         patch: operations["FountainWeb.VaultController.update (2)"];
         trace?: never;
     };
+    "/api/vaults/{id}/copy": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Copy a vault
+         * @description Creates a new vault holding a copy of every secret in the source vault. Values are copied server-side and re-encrypted; no value is ever returned. `name` is required; `description` and `metadata` default to the source's. Atomic: on any failure no new vault exists. A source vault the caller does not own reads as not found.
+         */
+        post: operations["FountainWeb.VaultController.copy"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/vaults/{vault_id}/secrets": {
         parameters: {
             query?: never;
@@ -2819,6 +2839,8 @@ export interface components {
              * @enum {string|null}
              */
             sandbox_provider?: "sprites" | "e2b" | "daytona" | "runner" | null;
+            /** @description ACP session config options every conversation of this agent requests (ADR 0062), such as {"effort": "high"}. A conversation's own session_config overrides these keys, and a prompt's overrides both for that turn. Null or {} requests none. */
+            session_config?: components["schemas"]["SessionConfig"];
             /** @description Each entry is either inline (`{name, content}` — full SKILL.md text written to the sprite) or github (`{source, ref?, name?}` — installed on the sprite via the skills.sh CLI, optionally pinned to a tag/branch/sha via `ref`). Exactly one of `content` or `source` must be set on each entry. */
             skills?: {
                 /** @description Full SKILL.md body for inline entries. */
@@ -2879,6 +2901,8 @@ export interface components {
              * @enum {string|null}
              */
             sandbox_provider?: "sprites" | "e2b" | "daytona" | "runner" | null;
+            /** @description ACP session config options every conversation of this agent requests (ADR 0062), such as {"effort": "high"}. A conversation's own session_config overrides these keys, and a prompt's overrides both for that turn. Null or {} requests none. */
+            session_config?: components["schemas"]["SessionConfig"];
             /** @description Each entry is either inline (`{name, content}` — full SKILL.md text written to the sprite) or github (`{source, ref?, name?}` — installed on the sprite via the skills.sh CLI, optionally pinned to a tag/branch/sha via `ref`). Exactly one of `content` or `source` must be set on each entry. */
             skills?: {
                 /** @description Full SKILL.md body for inline entries. */
@@ -2936,6 +2960,8 @@ export interface components {
              * @enum {string|null}
              */
             sandbox_provider?: "sprites" | "e2b" | "daytona" | "runner" | null;
+            /** @description ACP session config options every conversation of this agent requests (ADR 0062), such as {"effort": "high"}. A conversation's own session_config overrides these keys, and a prompt's overrides both for that turn. Null or {} requests none. */
+            session_config?: components["schemas"]["SessionConfig"];
             /** @description Each entry is either inline (`{name, content}` — full SKILL.md text written to the sprite) or github (`{source, ref?, name?}` — installed on the sprite via the skills.sh CLI, optionally pinned to a tag/branch/sha via `ref`). Exactly one of `content` or `source` must be set on each entry. */
             skills?: {
                 /** @description Full SKILL.md body for inline entries. */
@@ -3780,6 +3806,10 @@ export interface components {
             sandbox_api_access?: "owner" | "none";
             /** Format: uuid */
             sandbox_id?: string | null;
+            /** @description This conversation's ACP session config options (ADR 0062), over its agent's: a key here replaces the agent's value for that key. Set at launch or by reapply. {} follows the agent. */
+            session_config?: components["schemas"]["SessionConfig"];
+            /** @description The config options the adapter advertised before the latest prompt, after the model and the requested options were applied: what the current model offers and what is in force. Null until a turn reports them. */
+            session_config_options?: components["schemas"]["SessionConfigOption"][] | null;
             /** @enum {string} */
             source?: "ui" | "api" | "agent";
             /** @enum {string} */
@@ -3836,7 +3866,7 @@ export interface components {
             sandbox_api_access?: "owner" | "none";
             /**
              * Format: uuid
-             * @description Attach the conversation to a sandbox you already have instead of provisioning one (ADR 0023). The sandbox must be yours (404 sandbox_not_found), ready or suspended (409 sandbox_not_attachable), and built for the same agent, environment and vault as this launch (422 sandbox_identity_mismatch; 422 sandbox_runtime_mismatch if the agent's runtime changed since). The conversation opens idle on that machine; a prompt here wakes it. Several conversations then run on one disk at once, except on opencode and gemini, where a second turn of the same runtime is refused with 409 sandbox_at_capacity while one runs.
+             * @description Attach the conversation to a sandbox you already have instead of provisioning one (ADR 0023). The sandbox must be yours (404 sandbox_not_found), ready or suspended (409 sandbox_not_attachable), and built from the same environment and vault as this launch (422 sandbox_identity_mismatch). It is normally the same agent's (422 sandbox_runtime_mismatch if the agent's runtime changed since). An agent other than the one the sandbox was built for may attach to that agent's persistent sandbox as a guest only to make a claude and codex pair: a codex agent on a claude agent's home, or a claude agent on a codex agent's, where no other agent of either runtime has run. Any other guest is 422 sandbox_identity_mismatch. Attaching a guest needs a full-scope API key; a sandbox's own token, or any key below full scope, is refused with 403 guest_attach_requires_full_scope (reason insufficient_scope), a channel rotation (fresh) of a guest included. The sandbox stays its own agent's, and a guest's reapply is refused with 409 rebuild_required: field shared_sandbox while another conversation is on the sandbox, field guest when the guest is alone there. A claude home created before guests were admitted refuses a codex guest with 409 codex_inference_conflict until it is reset. The conversation opens idle on that machine; a prompt here wakes it. Several conversations then run on one disk at once, except on opencode and gemini, where a second turn of the same runtime is refused with 409 sandbox_at_capacity while one runs.
              */
             sandbox_id?: string | null;
             /**
@@ -3844,6 +3874,8 @@ export interface components {
              * @enum {string|null}
              */
             sandbox_mode?: "ephemeral" | "persistent" | null;
+            /** @description ACP session config options for this conversation (ADR 0062), over the agent's, such as {"reasoning_effort": "high"}. Applied after the model on every turn. The ids and values are the adapter's own; one it does not advertise is skipped, and a value it refuses fails the turn. */
+            session_config?: components["schemas"]["SessionConfig"];
             /** @description Name the conversation's machine instead of taking a generated name. The value is the suffix of an account-scoped name: the server keeps the fountain-<account>- prefix every generated name carries, so a name you choose lands in your own namespace rather than another account's. 1 to 40 characters of letters, digits, - and _, starting with a letter or digit; a name that already carries this account's prefix is taken as it stands, so a name from an earlier launch resolves to the same machine. 422 invalid_sprite_name otherwise. Refused with 422 sprite_name_not_supported on an agent that runs on a self-hosted runner, where the name carries the runner instead. Refused with sandbox_api_access none, which requires a machine no other conversation can reach. */
             sprite_name?: string;
             /** @description Optional display title. The team page names a teammate with it. */
@@ -3870,7 +3902,7 @@ export interface components {
         };
         /**
          * ConversationReapplyRequest
-         * @description A selection of Agent, Environment, Vault and model to apply to the machine an existing conversation already runs on. An omitted field keeps its current selection. An explicit null clears the Environment override, the Vault or the model override. An empty object reapplies the current selection.
+         * @description A selection of Agent, Environment, Vault, model and session config to apply to the machine an existing conversation already runs on. An omitted field keeps its current selection. An explicit null clears the Environment override, the Vault, the model override or the session config. An empty object reapplies the current selection.
          */
         ConversationReapplyRequest: {
             /**
@@ -3885,6 +3917,8 @@ export interface components {
             environment_id?: string | null;
             /** @description Model to run from the next turn (ADR 0061), in canonical provider/model_id form; null returns to the selected Agent's model. Checked against the selected Agent's runtime (422 model_invalid). The conversation keeps its credential: a model that credential does not serve is 409 inference_source_changed and nothing changes. The runtime session is kept, so the next turn continues it on the new model. */
             model?: string | null;
+            /** @description ACP session config options to request from the next turn (ADR 0062), replacing the conversation's current ones; null or {} returns to the Agent's. Only the shape is checked here. The adapter decides which ids and values exist. */
+            session_config?: components["schemas"]["SessionConfig"];
             /**
              * Format: uuid
              * @description Vault to use; null detaches the current Vault.
@@ -4317,11 +4351,26 @@ export interface components {
         LogEventListResponse: {
             data: components["schemas"]["LogEvent"][];
             meta: {
+                /** @description More matching events exist past this page: newer ones for `asc`, older ones for `desc`. */
                 has_more: boolean;
                 limit: number;
-                /** @description Pass as `after` to fetch the next page. null when the page is empty. */
+                /** @description The page's last event id: pass as `after` (`asc`) or `before` (`desc`) to fetch the next page. null when the page is empty. */
                 next_cursor?: number | null;
             };
+            /** @description The window this page covers (#2531). */
+            page?: {
+                /** @description The largest event id on the page; on the first `order=desc` page, the `Last-Event-ID` an SSE follow resumes from. null when the page is empty. */
+                newest_cursor: number | null;
+                /** @description The smallest event id on the page. null when the page is empty. */
+                oldest_cursor: number | null;
+                /**
+                 * @description The order of `data`, as requested.
+                 * @enum {string}
+                 */
+                order: "asc" | "desc";
+                /** @description `whole_turns=true` reached its ceiling inside a turn: the page's oldest turn continues on the next page. Always false otherwise. */
+                turn_split: boolean;
+            };
         };
         /**
          * ManifestResource
@@ -4494,6 +4543,8 @@ export interface components {
             /** @description Optional images to attach to this prompt. */
             images?: components["schemas"]["ImageInput"][] | null;
             prompt: string;
+            /** @description ACP session config options for this turn only (ADR 0062), over the conversation's and the agent's, such as {"effort": "high", "fast": true}. The next turn goes back to the conversation's. The turn's config_selection records what was requested, applied and skipped. */
+            session_config?: components["schemas"]["SessionConfig"];
         };
         /** PromptResponse */
         PromptResponse: {
@@ -4580,7 +4631,7 @@ export interface components {
         Sandbox: {
             /**
              * Format: uuid
-             * @description The agent the machine was built for. With environment_id and vault_id it is the identity a conversation must match to attach (sandbox_id on create).
+             * @description The agent the machine was built for. With environment_id and vault_id it is the identity a conversation must match to attach (sandbox_id on create); an agent of another runtime may attach to a persistent machine as a guest, which leaves this field unchanged.
              */
             agent_id?: string | null;
             /** @description The checkpoint Fountain took of this home the last time it parked (ADR 0023). It is scoped to this machine: it can roll the machine back, not rebuild a machine that is gone. Null for an ephemeral sandbox, a provider without checkpoints, or a home that has not parked yet. */
@@ -4666,7 +4717,7 @@ export interface components {
         SandboxDetail: {
             /**
              * Format: uuid
-             * @description The agent the machine was built for. With environment_id and vault_id it is the identity a conversation must match to attach (sandbox_id on create).
+             * @description The agent the machine was built for. With environment_id and vault_id it is the identity a conversation must match to attach (sandbox_id on create); an agent of another runtime may attach to a persistent machine as a guest, which leaves this field unchanged.
              */
             agent_id?: string | null;
             /** @description The checkpoint Fountain took of this home the last time it parked (ADR 0023). It is scoped to this machine: it can roll the machine back, not rebuild a machine that is gone. Null for an ephemeral sandbox, a provider without checkpoints, or a home that has not parked yet. */
@@ -4989,6 +5040,35 @@ export interface components {
         SecretResponse: {
             data: components["schemas"]["Secret"];
         };
+        /**
+         * SessionConfig
+         * @description ACP session config options to request (ADR 0062): a map of the adapter's option id to a value, a string or a boolean. The ids and values are the adapter's own and are not checked against a list: claude-agent-acp offers `effort` and `fast`, codex-acp `reasoning_effort` and `fast-mode`, and which exist depends on the model. They are applied after the model and before each prompt. An id the adapter does not advertise is skipped, and a `config` stage event reports it (`done`, outcome `skipped`). A value it refuses fails the turn. `model` is refused here; use the model field. `session_config_options` on the conversation lists what the adapter offers.
+         * @example {
+         *       "effort": "high",
+         *       "fast": true
+         *     }
+         */
+        SessionConfig: {
+            [key: string]: string | boolean;
+        } | null;
+        /**
+         * SessionConfigOption
+         * @description One config option as the adapter advertised it (ACP `SessionConfigOption`), passed through unchanged. `category` is `thought_level` for reasoning effort and `model_config` for fast mode on the pinned adapters. `options` lists a select's values, possibly in groups. `currentValue` is the value in force.
+         */
+        SessionConfigOption: {
+            category?: string | null;
+            currentValue?: string | boolean;
+            description?: string | null;
+            id: string;
+            name?: string;
+            options?: {
+                [key: string]: unknown;
+            }[];
+            /** @description `select` or `boolean`. */
+            type?: string;
+        } & {
+            [key: string]: unknown;
+        };
         /**
          * StreamLogEvent
          * @description One frame of the conversation, events or team SSE log stream (#2297). Same fields as `LogEvent` minus `id` — the frame's id travels in the SSE `id:` line, never the JSON body — plus `conversation_id` and `agent_id`, which the REST log feed never sends because its URL or list item already names the conversation.
@@ -5274,6 +5354,10 @@ export interface components {
         Turn: {
             /** @description The `client_request_id` of the prompt that opened this turn (#1406), or null: the caller sent none, or the turn is `autonomous`. Not unique. This is the value the caller sent, byte for byte, and it is the one to compare against: the copy on the turn's `started` stage event has been through event redaction, which rewrites any registered environment value it contains. */
             client_request_id?: string | null;
+            /** @description The ACP session config options of this turn (ADR 0062). `requested` is what the turn asked for (agent, then conversation, then prompt). `applied` maps each id the adapter took to the value it confirmed. `skipped` lists ids the adapter did not advertise. On a refusal, `status` is `failed` with `error`. Null on a turn that requested none. */
+            config_selection?: {
+                [key: string]: unknown;
+            } | null;
             /** Format: date-time */
             ended_at?: string | null;
             exit_code?: number | null;
@@ -11806,7 +11890,7 @@ export interface operations {
                     "application/json": components["schemas"]["Error"];
                 };
             };
-            /** @description A sandbox token labelling the conversation a resume landed on */
+            /** @description A sandbox token labelling the conversation a resume landed on, or a key below full scope attaching another agent's conversation to a sandbox (guest_attach_requires_full_scope) */
             403: {
                 headers: {
                     [name: string]: unknown;
@@ -11959,7 +12043,13 @@ export interface operations {
                 streams?: string;
                 /** @description Return events with an id greater than this. Defaults to 0. */
                 after?: number;
-                /** @description Page size, 1..1000. Defaults to 100. */
+                /** @description Return events with an id less than this: the previous `order=desc` page's `meta.next_cursor`. Applies in either order; omitted means no upper bound. */
+                before?: number;
+                /** @description `asc` (the default) pages forward from `after`, oldest first. `desc` pages backward from `before` (or from the newest event), and `data` is newest first. */
+                order?: "asc" | "desc";
+                /** @description With `order=desc`, never end a page inside a turn: when the `limit`th event belongs to a turn that began earlier, the page extends past `limit` to that turn's first event, keeping any events interleaved with it, so a client renders complete turns and `before=<meta.next_cursor>` returns only earlier ones. At most 5000 events: a turn larger than that is cut there, with `page.turn_split: true`, and continues on the next page. Turn-less events (the setup before turn 1) page by `limit` alone. Refused with 422 without `order=desc`. Defaults to false. */
+                whole_turns?: boolean;
+                /** @description Page size, 1..1000. Defaults to 100. `whole_turns=true` can return more. */
                 limit?: number;
                 /** @description Add `blocks` to each event: its `data` parsed server-side into the structured blocks a transcript renders (text, thinking, tool_use, tool_result, init, result, error, raw) — the same parse the web UI uses, so no client re-implements a runtime's dialect. Defaults to false. */
                 blocks?: boolean;
@@ -17492,6 +17582,88 @@ export interface operations {
             };
         };
     };
+    "FountainWeb.VaultController.copy": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Source vault. */
+                id: string;
+            };
+            cookie?: never;
+        };
+        /** @description New vault attributes */
+        requestBody?: {
+            content: {
+                "application/json": components["schemas"]["VaultRequest"];
+            };
+        };
+        responses: {
+            /** @description Vault */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["VaultResponse"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Forbidden */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No acceptable representation */
+            406: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["NegotiationError"];
+                };
+            };
+            /** @description Validation error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Too Many Requests */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
     "FountainWeb.VaultSecretController.index": {
         parameters: {
             query?: never;

package/dist/http.d.ts

@@ -15,7 +15,7 @@ export interface RequestOptions {
  * this string is already what Fountain's request logs are keyed on. The
  * version half is asserted against `package.json` by a test.
  */
-export declare const USER_AGENT = "fountain-sdk-js/6.2.0";
+export declare const USER_AGENT = "fountain-sdk-js/6.3.0";
 export declare class HttpClient {
     readonly config: ResolvedConfig;
     private readonly fetchImpl;

package/dist/http.js

@@ -5,7 +5,7 @@ import { AuthError, ConnectionError, FountainError, errorForStatus } from "./err
  * this string is already what Fountain's request logs are keyed on. The
  * version half is asserted against `package.json` by a test.
  */
-export const USER_AGENT = "fountain-sdk-js/6.2.0";
+export const USER_AGENT = "fountain-sdk-js/6.3.0";
 /**
  * The thin layer everything else is built on: one bearer token, JSON in and
  * out, and errors that say which call failed. `Fountain#api` exposes it

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@managoat/fountain-sdk",
-  "version": "6.2.0",
+  "version": "6.3.0",
   "description": "Run a coding agent on a real computer, with your repos and your credentials, in one call.",
   "license": "Apache-2.0",
   "publishConfig": {