@runtypelabs/sdk 9.9.1 → 9.10.1

package/dist/index.d.cts

@@ -536,6 +536,8 @@ interface paths {
                     agentType?: "runtype" | "external" | "claude_managed";
                     /** @description Deprecated alias for `agentType`. */
                     agent_type?: "runtype" | "external" | "claude_managed";
+                    /** @description Filter by code provenance. `true` returns only agents whose `lastModifiedSource` is `sdk` or `terraform`; `false` returns every other agent, including one with no recorded source. */
+                    managedInCode?: "true" | "false";
                     /** @description Response representation. `full` (default) preserves complete values; `compact` shortens every string value longer than 100 characters to a 100-character preview followed by `…`. */
                     view?: "full" | "compact";
                 };
@@ -562,8 +564,18 @@ interface paths {
                                 description: string | null;
                                 icon: string | null;
                                 id: string;
+                                /** @description Which surface last wrote this agent (`sdk`, `terraform`, `dashboard`, `api`, `mcp`). `sdk` and `terraform` mean the agent is managed in code. `null` on an agent last written before provenance was recorded. */
+                                lastModifiedSource: string | null;
                                 lastRunAt?: string | null;
                                 name: string;
+                                sandboxCapabilityIssues?: {
+                                    /** @enum {string} */
+                                    code: "unsupported_sandbox_capability";
+                                    message: string;
+                                    path: string;
+                                    requested: string;
+                                    supported: string[];
+                                }[];
                                 status: string;
                                 updatedAt: string;
                             }[];
@@ -782,16 +794,25 @@ interface paths {
                             };
                             sandbox?: {
                                 enabled: boolean;
-                                /** @enum {string} */
+                                /**
+                                 * @description Only standard-4 is supported on the hosted Agent Sandbox path; other sizes cannot be enabled.
+                                 * @enum {string}
+                                 */
                                 instanceType?: "standard-1" | "standard-2" | "standard-3" | "standard-4";
                                 networkAccess?: ("none" | "essentials" | "open") | {
                                     allow?: string[];
                                     /** @enum {string} */
                                     profile?: "none" | "essentials" | "open";
                                 };
-                                /** @enum {string} */
+                                /**
+                                 * @description Supported: ephemeral or conversation. Named remains parseable for stored configs but cannot be enabled.
+                                 * @enum {string}
+                                 */
                                 persistence?: "ephemeral" | "conversation" | "named";
-                                /** @enum {string} */
+                                /**
+                                 * @description Only runtype-sandbox is currently supported. Daytona is retained for stored-config parsing but rejected at authoring/execution.
+                                 * @enum {string}
+                                 */
                                 provider?: "runtype-sandbox" | "daytona";
                                 secretEnv?: {
                                     [key: string]: string;
@@ -1090,6 +1111,14 @@ interface paths {
                             name: string;
                             organizationId: string | null;
                             publishedVersionId: string | null;
+                            sandboxCapabilityIssues?: {
+                                /** @enum {string} */
+                                code: "unsupported_sandbox_capability";
+                                message: string;
+                                path: string;
+                                requested: string;
+                                supported: string[];
+                            }[];
                             status: string;
                             updatedAt: string;
                             userId: string;
@@ -1169,7 +1198,7 @@ interface paths {
         put?: never;
         /**
          * Ensure agent (config-as-code converge)
-         * @description Idempotently converge a repo-defined agent definition onto the platform. Identity is name + account scope. Hash-only probes skip the payload in the steady state (a miss is a normal 200 `definitionRequired` response, not an error); full requests create the agent or append a new version when the canonical content hash differs. Non-executing: never touches the execution pipeline. The response always carries the server-computed canonical hash. Set dryRun to plan without writing (CI drift gate), onConflict: "overwrite" to converge over dashboard/API edits, and release: "publish" to also re-aim the published-version pointer.
+         * @description Idempotently converge a repo-defined agent definition onto the platform. Identity is name + account scope. Hash-only probes skip the payload in the steady state (a miss is a normal 200 `definitionRequired` response, not an error); full requests create the agent or append a new version when the canonical content hash differs. Non-executing: never touches the execution pipeline. The response always carries the server-computed canonical hash. Set dryRun to plan without writing (CI drift gate), onConflict: "overwrite" to converge over dashboard/API edits, and deploy: { alias } to atomically save and activate the definition at a release alias (release: "publish" / "none" remain compatibility spellings of deploy live / save-only, and mixing the two is a 400). A non-live deploy is alias-scoped: it appends a candidate version and moves that one pointer, and never writes the agent row, its config hash, its capabilities, its draft pointer or its live pointer, so "unchanged" is decided against the hash stored on the alias rather than against the live row. onConflict, expectedRemoteHash and managed-by-code provenance describe live-row writes and therefore do not apply to a non-live deploy; remoteHash in the response is the hash the alias carried before. The one exception is an agent name that does not exist yet: the create is the live row (there is nothing to preview against), and live is still not aimed. Optional version.label / version.notes stamp provenance (a git SHA, a release tag) on the appended version row.
          */
         post: {
             parameters: {
@@ -1276,16 +1305,25 @@ interface paths {
                                 };
                                 sandbox?: {
                                     enabled: boolean;
-                                    /** @enum {string} */
+                                    /**
+                                     * @description Only standard-4 is supported on the hosted Agent Sandbox path; other sizes cannot be enabled.
+                                     * @enum {string}
+                                     */
                                     instanceType?: "standard-1" | "standard-2" | "standard-3" | "standard-4";
                                     networkAccess?: ("none" | "essentials" | "open") | {
                                         allow?: string[];
                                         /** @enum {string} */
                                         profile?: "none" | "essentials" | "open";
                                     };
-                                    /** @enum {string} */
+                                    /**
+                                     * @description Supported: ephemeral or conversation. Named remains parseable for stored configs but cannot be enabled.
+                                     * @enum {string}
+                                     */
                                     persistence?: "ephemeral" | "conversation" | "named";
-                                    /** @enum {string} */
+                                    /**
+                                     * @description Only runtype-sandbox is currently supported. Daytona is retained for stored-config parsing but rejected at authoring/execution.
+                                     * @enum {string}
+                                     */
                                     provider?: "runtype-sandbox" | "daytona";
                                     secretEnv?: {
                                         [key: string]: string;
@@ -1456,13 +1494,18 @@ interface paths {
                             icon?: string;
                             name: string;
                         };
+                        deploy?: components["schemas"]["AgentEnsureDeployTarget"];
                         dryRun?: boolean;
                         expectedRemoteHash?: string;
                         name: string;
                         /** @enum {string} */
                         onConflict?: "error" | "overwrite";
-                        /** @enum {string} */
+                        /**
+                         * @description Compatibility input, translated to a deploy: "publish" activates live, "none" saves without activating. Prefer deploy.
+                         * @enum {string}
+                         */
                         release?: "none" | "publish";
+                        version?: components["schemas"]["EnsureVersionMetadata"];
                     };
                 };
             };
@@ -1476,13 +1519,13 @@ interface paths {
                         "application/json": components["schemas"]["AgentEnsureResponse"];
                     };
                 };
-                /** @description Validation error (or unsupported agent type for ensure) */
+                /** @description Validation error, unsupported agent type, or code alias_requires_organization when a non-live deploy targets a personal-scope agent */
                 400: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["Error"];
+                        "application/json": components["schemas"]["AgentEnsureBadRequest"];
                     };
                 };
                 /** @description Unauthorized */
@@ -1521,13 +1564,13 @@ interface paths {
                         "application/json": components["schemas"]["AgentEnsureHashMismatch"];
                     };
                 };
-                /** @description Internal server error */
+                /** @description Internal server error, or code alias_activation_failed when a non-live activation could not be applied (nothing was written) */
                 500: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["Error"];
+                        "application/json": components["schemas"]["AgentEnsureServerError"];
                     };
                 };
             };
@@ -1822,6 +1865,14 @@ interface paths {
                             name: string;
                             organizationId: string | null;
                             publishedVersionId: string | null;
+                            sandboxCapabilityIssues?: {
+                                /** @enum {string} */
+                                code: "unsupported_sandbox_capability";
+                                message: string;
+                                path: string;
+                                requested: string;
+                                supported: string[];
+                            }[];
                             status: string;
                             updatedAt: string;
                             userId: string;
@@ -2030,16 +2081,25 @@ interface paths {
                             };
                             sandbox?: {
                                 enabled: boolean;
-                                /** @enum {string} */
+                                /**
+                                 * @description Only standard-4 is supported on the hosted Agent Sandbox path; other sizes cannot be enabled.
+                                 * @enum {string}
+                                 */
                                 instanceType?: "standard-1" | "standard-2" | "standard-3" | "standard-4";
                                 networkAccess?: ("none" | "essentials" | "open") | {
                                     allow?: string[];
                                     /** @enum {string} */
                                     profile?: "none" | "essentials" | "open";
                                 };
-                                /** @enum {string} */
+                                /**
+                                 * @description Supported: ephemeral or conversation. Named remains parseable for stored configs but cannot be enabled.
+                                 * @enum {string}
+                                 */
                                 persistence?: "ephemeral" | "conversation" | "named";
-                                /** @enum {string} */
+                                /**
+                                 * @description Only runtype-sandbox is currently supported. Daytona is retained for stored-config parsing but rejected at authoring/execution.
+                                 * @enum {string}
+                                 */
                                 provider?: "runtype-sandbox" | "daytona";
                                 secretEnv?: {
                                     [key: string]: string;
@@ -2325,6 +2385,14 @@ interface paths {
                             name: string;
                             organizationId: string | null;
                             publishedVersionId: string | null;
+                            sandboxCapabilityIssues?: {
+                                /** @enum {string} */
+                                code: "unsupported_sandbox_capability";
+                                message: string;
+                                path: string;
+                                requested: string;
+                                supported: string[];
+                            }[];
                             status: string;
                             updatedAt: string;
                             userId: string;
@@ -2466,45 +2534,59 @@ interface paths {
         patch?: never;
         trace?: never;
     };
-    "/v1/agents/{id}/approve": {
+    "/v1/agents/{id}/aliases": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        get?: never;
-        put?: never;
         /**
-         * Resolve a pending agent tool approval
-         * @description Resolve a pending tool approval on a paused agent execution (approved/denied). Streams a Server-Sent Events response when streamResponse is true (default); otherwise returns a JSON result.
+         * List release aliases for an agent
+         * @description List the named pointers that select which immutable version of this agent runs. `live` sorts first, then the preview aliases by name. Archived aliases are omitted unless `includeArchived=true`. Omitting `limit` returns every pointer; supplying it pages through the same order with `cursor`.
          */
-        post: {
+        get: {
             parameters: {
-                query?: never;
+                query?: {
+                    /** @description Pass `true` to include archived aliases, which never resolve for execution. */
+                    includeArchived?: string;
+                    /** @description Maximum aliases to return. Omit for the full set. */
+                    limit?: string;
+                    /** @description The `nextCursor` from a previous page of this same order. */
+                    cursor?: string;
+                };
                 header?: never;
                 path: {
                     id: string;
                 };
                 cookie?: never;
             };
-            requestBody?: {
-                content: {
-                    "application/json": components["schemas"]["AgentApproveRequest"];
-                };
-            };
+            requestBody?: never;
             responses: {
-                /** @description Server-Sent Events stream of agent execution events (or a JSON result when streamResponse is false) */
+                /** @description Release aliases */
                 200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["AgentApproveContinuationJsonResponse"];
-                        "text/event-stream": unknown;
+                        "application/json": {
+                            data: {
+                                alias: string;
+                                archivedAt: string | null;
+                                contentHash: string | null;
+                                createdAt: string;
+                                expiresAt: string | null;
+                                label: string | null;
+                                revision: number;
+                                updatedAt: string;
+                                versionId: string;
+                                versionNumber: number | null;
+                            }[];
+                            nextCursor: string | null;
+                        };
                     };
                 };
-                /** @description Invalid request body */
+                /** @description Invalid request */
                 400: {
                     headers: {
                         [name: string]: unknown;
@@ -2522,15 +2604,6 @@ interface paths {
                         "application/json": components["schemas"]["Error"];
                     };
                 };
-                /** @description Platform-key spend limit exceeded during a buffered continuation */
-                402: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["AgentApprovalContinuationJsonResponse"];
-                    };
-                };
                 /** @description Insufficient permissions */
                 403: {
                     headers: {
@@ -2540,7 +2613,7 @@ interface paths {
                         "application/json": components["schemas"]["Error"];
                     };
                 };
-                /** @description Agent or execution not found */
+                /** @description Agent not found */
                 404: {
                     headers: {
                         [name: string]: unknown;
@@ -2549,24 +2622,6 @@ interface paths {
                         "application/json": components["schemas"]["Error"];
                     };
                 };
-                /** @description Execution is not awaiting this approval or cannot be resumed here */
-                409: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["Error"];
-                    };
-                };
-                /** @description The paused execution was armed by the retired legacy flow engine and cannot be resumed (LEGACY_PAUSE_UNRESUMABLE); re-run the flow */
-                410: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["Error"];
-                    };
-                };
                 /** @description Internal server error */
                 500: {
                     headers: {
@@ -2578,70 +2633,60 @@ interface paths {
                 };
             };
         };
+        put?: never;
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/v1/agents/{id}/capabilities": {
+    "/v1/agents/{id}/aliases/{alias}": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        get?: never;
-        put?: never;
         /**
-         * Add capability to agent
-         * @description Add a capability (flow, sub-agent, or tool binding) to an agent.
+         * Get one release alias
+         * @description Read one pointer. A missing or archived alias answers a structured 404 naming the alias; it never falls back to live.
          */
-        post: {
+        get: {
             parameters: {
-                query?: never;
+                query?: {
+                    includeArchived?: string;
+                };
                 header?: never;
                 path: {
                     id: string;
+                    alias: string;
                 };
                 cookie?: never;
             };
-            requestBody?: {
-                content: {
-                    "application/json": {
-                        enabled?: boolean;
-                        flowId?: string;
-                        parametersSchema?: unknown;
-                        subAgentId?: string;
-                        toolDescription?: string;
-                        toolId?: string;
-                        toolName: string;
-                    };
-                };
-            };
+            requestBody?: never;
             responses: {
-                /** @description Capability added */
-                201: {
+                /** @description Release alias */
+                200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
                         "application/json": {
-                            agentId?: string;
-                            createdAt?: string;
-                            displayOrder: number | null;
-                            enabled: boolean;
-                            flowId: string | null;
-                            id: string;
-                            parametersSchema?: unknown;
-                            subAgentId: string | null;
-                            toolDescription: string | null;
-                            toolId: string | null;
-                            toolName: string;
+                            alias: string;
+                            archivedAt: string | null;
+                            contentHash: string | null;
+                            createdAt: string;
+                            expiresAt: string | null;
+                            label: string | null;
+                            revision: number;
+                            updatedAt: string;
+                            versionId: string;
+                            versionNumber: number | null;
                         };
                     };
                 };
-                /** @description Validation error */
+                /** @description Invalid request */
                 400: {
                     headers: {
                         [name: string]: unknown;
@@ -2668,22 +2713,18 @@ interface paths {
                         "application/json": components["schemas"]["Error"];
                     };
                 };
-                /** @description Agent not found */
+                /** @description Alias or agent not found */
                 404: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["Error"];
-                    };
-                };
-                /** @description Tool name already exists for this agent */
-                409: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["Error"];
+                        "application/json": components["schemas"]["Error"] & {
+                            agentId: string;
+                            alias: string;
+                            /** @enum {string} */
+                            code: "alias_not_found";
+                        };
                     };
                 };
                 /** @description Internal server error */
@@ -2697,138 +2738,887 @@ interface paths {
                 };
             };
         };
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
-    "/v1/agents/{id}/capabilities/{capabilityId}": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        get?: never;
-        put?: never;
-        post?: never;
         /**
-         * Remove capability from agent
-         * @description Remove a capability (flow, sub-agent, or tool binding) from an agent.
+         * Activate a version at a release alias
+         * @description Aim one alias at one immutable version of the same agent, appending a deployment receipt in the same transaction. Moving an existing `live` pointer requires the AGENTS:DEPLOY:LIVE scope and an `If-Match` revision; preview aliases require AGENTS:DEPLOY:PREVIEW. Dependency references the version names are fingerprinted first, and an unresolvable reference refuses the activation.
          */
-        delete: {
+        put: {
             parameters: {
                 query?: never;
-                header?: never;
+                header?: {
+                    /** @description The alias revision this write expects. Required on a `live` alias that already exists (428 without it) and refused with 412 when the stored revision has moved on. Optional on preview aliases and on the first `live` deployment, which has no revision yet. */
+                    "if-match"?: string;
+                    /** @description Replay key. Repeating an activation with the same key returns the receipt the first call produced instead of moving the pointer twice. */
+                    "idempotency-key"?: string;
+                };
                 path: {
                     id: string;
-                    capabilityId: string;
+                    alias: string;
                 };
                 cookie?: never;
             };
-            requestBody?: never;
-            responses: {
-                /** @description Capability removed */
-                200: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": {
-                            success: boolean;
-                        };
-                    };
-                };
-                /** @description Invalid agent or capability ID */
-                400: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["Error"];
-                    };
-                };
-                /** @description Unauthorized */
-                401: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["Error"];
-                    };
-                };
-                /** @description Agent or capability not found */
-                404: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["Error"];
-                    };
-                };
-                /** @description Internal server error */
-                500: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["Error"];
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        /** @description Why this deployment happened, recorded on the receipt for humans. Context only: nothing branches on it. */
+                        reason?: string;
+                        versionId: string;
                     };
                 };
             };
-        };
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
-    "/v1/agents/{id}/conversations/{conversationId}/events": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        /**
-         * List internal agent conversation events
-         * @description List provenance-bearing internal events posted to a saved agent conversation, including detached subagent completion activities. These events are never represented as human messages.
-         */
-        get: {
-            parameters: {
-                query?: {
-                    limit?: string;
-                    after?: string;
-                };
-                header?: never;
-                path: {
-                    id: string;
-                    conversationId: string;
-                };
-                cookie?: never;
-            };
-            requestBody?: never;
             responses: {
-                /** @description Conversation event list in chronological order */
+                /** @description Alias activated */
                 200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
                         "application/json": {
-                            data: {
-                                consumedAt: string | null;
-                                createdAt: string;
-                                eventKind: string;
-                                eventRevision: number;
-                                id: string;
-                                /** @enum {string} */
-                                notificationMode: "narrate" | "react";
-                                payload: {
-                                    [key: string]: unknown;
-                                };
-                                runId: string;
-                            }[];
+                            alias: string;
+                            changed: boolean;
+                            receiptId: string;
+                            revision: number;
+                            versionId: string;
+                            versionNumber: number | null;
+                        };
+                    };
+                };
+                /** @description Invalid request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Insufficient permissions */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Agent or version not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Idempotency key already used for a different activation */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"] & {
+                            /** @enum {string} */
+                            code: "idempotency_key_reused";
+                        };
+                    };
+                };
+                /** @description Alias revision mismatch */
+                412: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"] & {
+                            actual: number | null;
+                            /** @enum {string} */
+                            code: "alias_revision_mismatch";
+                            expected: number;
+                        };
+                    };
+                };
+                /** @description Version references a dependency that no longer resolves */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"] & {
+                            /** @enum {string} */
+                            code: "alias_dependency_unresolved";
+                            refs: string[];
+                        };
+                    };
+                };
+                /** @description If-Match required for the live alias */
+                428: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+            };
+        };
+        post?: never;
+        /**
+         * Archive a release alias
+         * @description Archive a preview alias: it stops resolving for new executions, keeps its deployment history, and does not interrupt admitted runs. The row is never deleted, so a later activation revives the same pointer. `live` cannot be archived.
+         */
+        delete: {
+            parameters: {
+                query?: never;
+                header?: {
+                    /** @description The alias revision this write expects. Required on a `live` alias that already exists (428 without it) and refused with 412 when the stored revision has moved on. Optional on preview aliases and on the first `live` deployment, which has no revision yet. */
+                    "if-match"?: string;
+                    /** @description Replay key. Repeating an activation with the same key returns the receipt the first call produced instead of moving the pointer twice. */
+                    "idempotency-key"?: string;
+                };
+                path: {
+                    id: string;
+                    alias: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Alias archived */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            alias: string;
+                            /** @enum {boolean} */
+                            archived: true;
+                            receiptId: string;
+                            revision: number;
+                        };
+                    };
+                };
+                /** @description Invalid request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Insufficient permissions */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Alias or agent not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"] & {
+                            agentId: string;
+                            alias: string;
+                            /** @enum {string} */
+                            code: "alias_not_found";
+                        };
+                    };
+                };
+                /** @description The live alias cannot be archived */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"] & {
+                            /** @enum {string} */
+                            code: "alias_archive_forbidden";
+                        };
+                    };
+                };
+                /** @description Alias revision mismatch */
+                412: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"] & {
+                            actual: number | null;
+                            /** @enum {string} */
+                            code: "alias_revision_mismatch";
+                            expected: number;
+                        };
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+            };
+        };
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/agents/{id}/aliases/{alias}/rollback": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Roll a release alias back to its previous version
+         * @description Re-aim an alias at the version recorded as `previousVersionId` on its most recent pointer-moving receipt, walking `steps` receipts back. Writes a `rollback` receipt. Rolling back `live` follows the same scope and `If-Match` rules as activation, and restores configuration only: external data and side effects are not rolled back.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: {
+                    /** @description The alias revision this write expects. Required on a `live` alias that already exists (428 without it) and refused with 412 when the stored revision has moved on. Optional on preview aliases and on the first `live` deployment, which has no revision yet. */
+                    "if-match"?: string;
+                    /** @description Replay key. Repeating an activation with the same key returns the receipt the first call produced instead of moving the pointer twice. */
+                    "idempotency-key"?: string;
+                };
+                path: {
+                    id: string;
+                    alias: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        reason?: string;
+                        /** @default 1 */
+                        steps?: number;
+                    };
+                };
+            };
+            responses: {
+                /** @description Alias rolled back */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            alias: string;
+                            changed: boolean;
+                            receiptId: string;
+                            revision: number;
+                            versionId: string;
+                            versionNumber: number | null;
+                        };
+                    };
+                };
+                /** @description Invalid request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Insufficient permissions */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Alias, agent, or rollback target not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"] & {
+                            agentId: string;
+                            alias: string;
+                            /** @enum {string} */
+                            code: "alias_not_found";
+                        };
+                    };
+                };
+                /** @description Alias revision mismatch */
+                412: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"] & {
+                            actual: number | null;
+                            /** @enum {string} */
+                            code: "alias_revision_mismatch";
+                            expected: number;
+                        };
+                    };
+                };
+                /** @description Target version references a dependency that no longer resolves */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"] & {
+                            /** @enum {string} */
+                            code: "alias_dependency_unresolved";
+                            refs: string[];
+                        };
+                    };
+                };
+                /** @description If-Match required for the live alias */
+                428: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/agents/{id}/approve": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Resolve a pending agent tool approval
+         * @description Resolve a pending tool approval on a paused agent execution (approved/denied). Streams a Server-Sent Events response when streamResponse is true (default); otherwise returns a JSON result.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["AgentApproveRequest"];
+                };
+            };
+            responses: {
+                /** @description Server-Sent Events stream of agent execution events (or a JSON result when streamResponse is false) */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["AgentApproveContinuationJsonResponse"];
+                        "text/event-stream": unknown;
+                    };
+                };
+                /** @description Invalid request body */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Platform-key spend limit exceeded during a buffered continuation */
+                402: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["AgentApprovalContinuationJsonResponse"];
+                    };
+                };
+                /** @description Insufficient permissions */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Agent or execution not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Execution is not awaiting this approval or cannot be resumed here */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description The paused execution was armed by the retired legacy flow engine and cannot be resumed (LEGACY_PAUSE_UNRESUMABLE); re-run the flow */
+                410: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/agents/{id}/capabilities": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Add capability to agent
+         * @description Add a capability (flow, sub-agent, or tool binding) to an agent.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        enabled?: boolean;
+                        flowId?: string;
+                        parametersSchema?: unknown;
+                        subAgentId?: string;
+                        toolDescription?: string;
+                        toolId?: string;
+                        toolName: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description Capability added */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            agentId?: string;
+                            createdAt?: string;
+                            displayOrder: number | null;
+                            enabled: boolean;
+                            flowId: string | null;
+                            id: string;
+                            parametersSchema?: unknown;
+                            subAgentId: string | null;
+                            toolDescription: string | null;
+                            toolId: string | null;
+                            toolName: string;
+                        };
+                    };
+                };
+                /** @description Validation error */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Insufficient permissions */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Agent not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Tool name already exists for this agent */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/agents/{id}/capabilities/{capabilityId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /**
+         * Remove capability from agent
+         * @description Remove a capability (flow, sub-agent, or tool binding) from an agent.
+         */
+        delete: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                    capabilityId: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Capability removed */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            success: boolean;
+                        };
+                    };
+                };
+                /** @description Invalid agent or capability ID */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Agent or capability not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+            };
+        };
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/agents/{id}/conversations/{conversationId}/events": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List internal agent conversation events
+         * @description List provenance-bearing internal events posted to a saved agent conversation, including detached subagent completion activities. These events are never represented as human messages.
+         */
+        get: {
+            parameters: {
+                query?: {
+                    limit?: string;
+                    after?: string;
+                };
+                header?: never;
+                path: {
+                    id: string;
+                    conversationId: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Conversation event list in chronological order */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            data: {
+                                consumedAt: string | null;
+                                createdAt: string;
+                                eventKind: string;
+                                eventRevision: number;
+                                id: string;
+                                /** @enum {string} */
+                                notificationMode: "narrate" | "react";
+                                payload: {
+                                    [key: string]: unknown;
+                                };
+                                runId: string;
+                            }[];
+                        };
+                    };
+                };
+                /** @description Invalid request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Insufficient permissions */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Agent not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/agents/{id}/deployments": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List deployment receipts for an agent
+         * @description The append-only deployment history of this agent, newest first, cursor-paginated. Each receipt records the pointer, the previous and new versions, the alias revision, the actor, provenance and the dependency fingerprints checked at activation.
+         */
+        get: {
+            parameters: {
+                query?: {
+                    alias?: string;
+                    limit?: string;
+                    cursor?: string;
+                };
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Deployment receipts */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            data: {
+                                action: string;
+                                actorUserId: string | null;
+                                alias: string;
+                                aliasRevision: number;
+                                createdAt: string;
+                                dependencies: {
+                                    [key: string]: unknown;
+                                } | null;
+                                id: string;
+                                previousVersionId: string | null;
+                                source: {
+                                    [key: string]: unknown;
+                                };
+                                versionId: string;
+                            }[];
+                            pagination: {
+                                [key: string]: unknown;
+                            };
                         };
                     };
                 };
@@ -2898,7 +3688,7 @@ interface paths {
         put?: never;
         /**
          * Execute agent
-         * @description Execute an agent with a message array. Streams a Server-Sent Events response when streamResponse is true (default); otherwise returns a JSON result. Send the RFC 7240 `Prefer: respond-async` header to receive a durable execution handle immediately, then poll its status URL for completion.
+         * @description Execute an agent with a message array. Streams a Server-Sent Events response when streamResponse is true (default); otherwise returns a JSON result. Send the RFC 7240 `Prefer: respond-async` header to receive a durable execution handle immediately, then poll its status URL for completion. The optional `durability` body field pins the lane for this request (`forced`: `durable` or `in_process`) or bounds its attached watch (`watchLeaseMs`), and outranks the saved agent config.
          */
         post: {
             parameters: {
@@ -3067,6 +3857,19 @@ interface paths {
                                 agentId: string | null;
                                 agentSource: string | null;
                                 agentSpec?: unknown;
+                                /**
+                                 * @description How the run selected its definition: `alias` or `version` for a request that named a selector, `legacy-live-row` for a run that read the mutable agent row.
+                                 * @enum {string}
+                                 */
+                                agentTargetResolution: "alias" | "version" | "legacy-live-row";
+                                /** @description Version number and label for `agentVersionId`, joined from `agent_versions`. `null` exactly when `agentVersionId` is `null`. */
+                                agentVersion: {
+                                    id: string;
+                                    label: string | null;
+                                    versionNumber: number;
+                                } | null;
+                                /** @description The `agent_versions` row this run was recorded against, or `null`. `null` means the surface that admitted the run stamps no version (A2A, Product API, A2A pause admission and the Product MCP capability path record none today) or the run predates version stamping. It is never a claim that the run executed an unversioned configuration. */
+                                agentVersionId: string | null;
                                 /** @description Whether the agent loop ended by exhausting its `maxTurns` budget. Read this rather than inferring truncation from `stopReason`: a single-turn loop publishes `end_turn` on a budget end to preserve its original payload shape, and several clean success paths publish that same value. `null` means UNKNOWN — a run recorded before this field existed, or one executed by a lane that reports no per-iteration breakdown (external agents, Claude Managed) — and must not be read as `false`. */
                                 budgetExhausted: boolean | null;
                                 cancelRequestedAt: string | null;
@@ -3204,6 +4007,19 @@ interface paths {
                             agentId: string | null;
                             agentSource: string | null;
                             agentSpec?: unknown;
+                            /**
+                             * @description How the run selected its definition: `alias` or `version` for a request that named a selector, `legacy-live-row` for a run that read the mutable agent row.
+                             * @enum {string}
+                             */
+                            agentTargetResolution: "alias" | "version" | "legacy-live-row";
+                            /** @description Version number and label for `agentVersionId`, joined from `agent_versions`. `null` exactly when `agentVersionId` is `null`. */
+                            agentVersion: {
+                                id: string;
+                                label: string | null;
+                                versionNumber: number;
+                            } | null;
+                            /** @description The `agent_versions` row this run was recorded against, or `null`. `null` means the surface that admitted the run stamps no version (A2A, Product API, A2A pause admission and the Product MCP capability path record none today) or the run predates version stamping. It is never a claim that the run executed an unversioned configuration. */
+                            agentVersionId: string | null;
                             /** @description Whether the agent loop ended by exhausting its `maxTurns` budget. Read this rather than inferring truncation from `stopReason`: a single-turn loop publishes `end_turn` on a budget end to preserve its original payload shape, and several clean success paths publish that same value. `null` means UNKNOWN — a run recorded before this field existed, or one executed by a lane that reports no per-iteration breakdown (external agents, Claude Managed) — and must not be read as `false`. */
                             budgetExhausted: boolean | null;
                             cancelRequestedAt: string | null;
@@ -4623,11 +5439,16 @@ interface paths {
                                 results: {
                                     completionTokens: number | null;
                                     createdAt: string;
+                                    /**
+                                     * @deprecated
+                                     * @description Deprecated alias for `modelCost`; identical value.
+                                     */
                                     estimatedCost: string | null;
                                     executionTimeMs: number | null;
                                     flowId: string | null;
                                     flowName: string | null;
                                     id: string;
+                                    modelCost: string | null;
                                     modelUsed: string | null;
                                     promptId: string | null;
                                     promptName: string | null;
@@ -4639,6 +5460,8 @@ interface paths {
                                     recordType: string;
                                     result: string | null;
                                     status: string;
+                                    /** @description Built-in tool spend for this execution, as a decimal string. `null` means unknown, not zero: rows written before per-run cost was split into model and tool portions carry no tool figure. A run that genuinely used no billable tool records `"0"`. Sum with `modelCost` for the run total, and treat `null` as unknown rather than zero. */
+                                    toolCost: string | null;
                                     totalTokens: number | null;
                                 }[];
                             };
@@ -11094,7 +11917,7 @@ interface paths {
         put?: never;
         /**
          * Execute a flow or agent
-         * @description Main dispatch endpoint for flow and agent execution with record resolution. Supports streaming via SSE or synchronous JSON responses. Send the RFC 7240 `Prefer: respond-async` header to receive a durable execution handle immediately, then poll its status URL for completion.
+         * @description Main dispatch endpoint for flow and agent execution with record resolution. Supports streaming via SSE or synchronous JSON responses. Send the RFC 7240 `Prefer: respond-async` header to receive a durable execution handle immediately, then poll its status URL for completion. A saved agent may run on the durable session lane; the admission headers `x-runtype-concurrency` (reject, supersede, queue), `x-runtype-coalesce` (true) and `idempotency-key` then apply exactly as on `POST /v1/agents/{id}/execute`, and are ignored for a turn that resolves to the in-process lane.
          */
         post: {
             parameters: {
@@ -11114,6 +11937,7 @@ interface paths {
                             agentId?: string;
                             /** @enum {string} */
                             agentType?: "runtype" | "claude_managed";
+                            alias?: string;
                             artifacts?: {
                                 /** @enum {boolean} */
                                 enabled: true;
@@ -11129,6 +11953,12 @@ interface paths {
                                 setupMode?: "create" | "connect";
                                 systemPrompt?: string;
                             };
+                            durability?: {
+                                /** @enum {string} */
+                                forced?: "durable" | "in_process";
+                                maxBudgetMs?: number | null;
+                                watchLeaseMs?: number | null;
+                            };
                             errorHandling?: {
                                 fallbacks?: ({
                                     delay?: number;
@@ -11189,16 +12019,25 @@ interface paths {
                             };
                             sandbox?: {
                                 enabled: boolean;
-                                /** @enum {string} */
+                                /**
+                                 * @description Only standard-4 is supported on the hosted Agent Sandbox path; other sizes cannot be enabled.
+                                 * @enum {string}
+                                 */
                                 instanceType?: "standard-1" | "standard-2" | "standard-3" | "standard-4";
                                 networkAccess?: ("none" | "essentials" | "open") | {
                                     allow?: string[];
                                     /** @enum {string} */
                                     profile?: "none" | "essentials" | "open";
                                 };
-                                /** @enum {string} */
+                                /**
+                                 * @description Supported: ephemeral or conversation. Named remains parseable for stored configs but cannot be enabled.
+                                 * @enum {string}
+                                 */
                                 persistence?: "ephemeral" | "conversation" | "named";
-                                /** @enum {string} */
+                                /**
+                                 * @description Only runtype-sandbox is currently supported. Daytona is retained for stored-config parsing but rejected at authoring/execution.
+                                 * @enum {string}
+                                 */
                                 provider?: "runtype-sandbox" | "daytona";
                                 secretEnv?: {
                                     [key: string]: string;
@@ -11284,6 +12123,7 @@ interface paths {
                             };
                             topK?: number;
                             topP?: number;
+                            versionId?: string;
                             voice?: {
                                 elevenLabs?: {
                                     modelId?: string;
@@ -11514,6 +12354,7 @@ interface paths {
                             agentId?: string;
                             /** @enum {string} */
                             agentType?: "runtype" | "claude_managed";
+                            alias?: string;
                             artifacts?: {
                                 /** @enum {boolean} */
                                 enabled: true;
@@ -11529,6 +12370,12 @@ interface paths {
                                 setupMode?: "create" | "connect";
                                 systemPrompt?: string;
                             };
+                            durability?: {
+                                /** @enum {string} */
+                                forced?: "durable" | "in_process";
+                                maxBudgetMs?: number | null;
+                                watchLeaseMs?: number | null;
+                            };
                             errorHandling?: {
                                 fallbacks?: ({
                                     delay?: number;
@@ -11589,16 +12436,25 @@ interface paths {
                             };
                             sandbox?: {
                                 enabled: boolean;
-                                /** @enum {string} */
+                                /**
+                                 * @description Only standard-4 is supported on the hosted Agent Sandbox path; other sizes cannot be enabled.
+                                 * @enum {string}
+                                 */
                                 instanceType?: "standard-1" | "standard-2" | "standard-3" | "standard-4";
                                 networkAccess?: ("none" | "essentials" | "open") | {
                                     allow?: string[];
                                     /** @enum {string} */
                                     profile?: "none" | "essentials" | "open";
                                 };
-                                /** @enum {string} */
+                                /**
+                                 * @description Supported: ephemeral or conversation. Named remains parseable for stored configs but cannot be enabled.
+                                 * @enum {string}
+                                 */
                                 persistence?: "ephemeral" | "conversation" | "named";
-                                /** @enum {string} */
+                                /**
+                                 * @description Only runtype-sandbox is currently supported. Daytona is retained for stored-config parsing but rejected at authoring/execution.
+                                 * @enum {string}
+                                 */
                                 provider?: "runtype-sandbox" | "daytona";
                                 secretEnv?: {
                                     [key: string]: string;
@@ -11684,6 +12540,7 @@ interface paths {
                             };
                             topK?: number;
                             topP?: number;
+                            versionId?: string;
                             voice?: {
                                 elevenLabs?: {
                                     modelId?: string;
@@ -12269,7 +13126,166 @@ interface paths {
                         "application/json": components["schemas"]["Error"];
                     };
                 };
-                /** @description Execution is not awaiting this approval or cannot be resumed here */
+                /** @description Execution is not awaiting this approval or cannot be resumed here */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description The paused execution was armed by the retired legacy flow engine and cannot be resumed (LEGACY_PAUSE_UNRESUMABLE); re-run the flow */
+                410: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/dispatch/resume": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Resume a paused execution
+         * @description Resumes a paused flow or agent execution by providing tool outputs. Does not count against execution limits. A saved-agent dispatch that ran on the durable lane pauses under its `aex_` execution id; resuming it hands the outputs to the durable session, answers `{ executionId, status: "running" }` (or a streamed `await` with `awaitReason: "detached"`), and ignores `messages`. Follow the run through `GET /v1/executions/{executionId}/events`.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        /** @description The execution ID to resume */
+                        executionId: string;
+                        /** @description Optional conversation override for the resumed leg. It REPLACES the stored conversation rather than being appended to it, so send the full conversation you want the model to see, not just the new turn. Omit it to keep the stored conversation unchanged. A `system` message must come first, as in any conversation. Note this is the flow client-tool continuation contract; an agent checkpoint resume (`options.resumeFrom` on `/v1/dispatch`) instead APPENDS its `messages` after the snapshot history — send only new input there. */
+                        messages?: {
+                            content: string | ({
+                                text: string;
+                                /** @enum {string} */
+                                type: "text";
+                            } | {
+                                image: string;
+                                mimeType?: string;
+                                /** @enum {string} */
+                                type: "image";
+                            } | {
+                                data: string;
+                                filename: string;
+                                mimeType: string;
+                                /** @enum {string} */
+                                type: "file";
+                            } | {
+                                providerOptions?: {
+                                    [key: string]: unknown;
+                                };
+                                text: string;
+                                /** @enum {string} */
+                                type: "reasoning";
+                            })[];
+                            /** @enum {string} */
+                            role: "system" | "user" | "assistant";
+                        }[];
+                        /**
+                         * @description Whether to stream the response via SSE
+                         * @default true
+                         */
+                        streamResponse?: boolean;
+                        /**
+                         * @description Local tool outputs for the paused execution. Key each output by the per-call `toolCallId` from the `flow_await` / `agent_await` event (preferred, and required to disambiguate parallel calls to the same tool), or by tool name (legacy; collapses same-tool parallel calls onto one slot).
+                         * @default {}
+                         */
+                        toolOutputs?: {
+                            [key: string]: unknown;
+                        };
+                    };
+                };
+            };
+            responses: {
+                /** @description Execution resumed (SSE stream or JSON). A durable-lane resume answers the `DispatchDetachedToolOutputJsonResponse` variant, or a stream that closes on `await` with `awaitReason: "detached"`. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["DispatchResumeJsonResponse"];
+                        "text/event-stream": unknown;
+                    };
+                };
+                /** @description Validation error */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Platform key spend limit exceeded */
+                402: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["DispatchToolOutputContinuationJsonResponse"];
+                    };
+                };
+                /** @description Insufficient permissions */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Paused execution not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description The durable execution is not awaiting tool output or cannot be resumed here */
                 409: {
                     headers: {
                         [name: string]: unknown;
@@ -12304,156 +13320,6 @@ interface paths {
         patch?: never;
         trace?: never;
     };
-    "/v1/dispatch/resume": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        get?: never;
-        put?: never;
-        /**
-         * Resume a paused execution
-         * @description Resumes a paused flow or agent execution by providing tool outputs. Does not count against execution limits.
-         */
-        post: {
-            parameters: {
-                query?: never;
-                header?: never;
-                path?: never;
-                cookie?: never;
-            };
-            requestBody?: {
-                content: {
-                    "application/json": {
-                        /** @description The execution ID to resume */
-                        executionId: string;
-                        /** @description Optional conversation override for the resumed leg. It REPLACES the stored conversation rather than being appended to it, so send the full conversation you want the model to see, not just the new turn. Omit it to keep the stored conversation unchanged. A `system` message must come first, as in any conversation. Note this is the flow client-tool continuation contract; an agent checkpoint resume (`options.resumeFrom` on `/v1/dispatch`) instead APPENDS its `messages` after the snapshot history — send only new input there. */
-                        messages?: {
-                            content: string | ({
-                                text: string;
-                                /** @enum {string} */
-                                type: "text";
-                            } | {
-                                image: string;
-                                mimeType?: string;
-                                /** @enum {string} */
-                                type: "image";
-                            } | {
-                                data: string;
-                                filename: string;
-                                mimeType: string;
-                                /** @enum {string} */
-                                type: "file";
-                            } | {
-                                providerOptions?: {
-                                    [key: string]: unknown;
-                                };
-                                text: string;
-                                /** @enum {string} */
-                                type: "reasoning";
-                            })[];
-                            /** @enum {string} */
-                            role: "system" | "user" | "assistant";
-                        }[];
-                        /**
-                         * @description Whether to stream the response via SSE
-                         * @default true
-                         */
-                        streamResponse?: boolean;
-                        /**
-                         * @description Local tool outputs for the paused execution. Key each output by the per-call `toolCallId` from the `flow_await` / `agent_await` event (preferred, and required to disambiguate parallel calls to the same tool), or by tool name (legacy; collapses same-tool parallel calls onto one slot).
-                         * @default {}
-                         */
-                        toolOutputs?: {
-                            [key: string]: unknown;
-                        };
-                    };
-                };
-            };
-            responses: {
-                /** @description Execution resumed (SSE stream or JSON) */
-                200: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["DispatchToolOutputContinuationJsonResponse"];
-                        "text/event-stream": unknown;
-                    };
-                };
-                /** @description Validation error */
-                400: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["Error"];
-                    };
-                };
-                /** @description Unauthorized */
-                401: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["Error"];
-                    };
-                };
-                /** @description Platform key spend limit exceeded */
-                402: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["DispatchToolOutputContinuationJsonResponse"];
-                    };
-                };
-                /** @description Insufficient permissions */
-                403: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["Error"];
-                    };
-                };
-                /** @description Paused execution not found */
-                404: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["Error"];
-                    };
-                };
-                /** @description The paused execution was armed by the retired legacy flow engine and cannot be resumed (LEGACY_PAUSE_UNRESUMABLE); re-run the flow */
-                410: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["Error"];
-                    };
-                };
-                /** @description Internal server error */
-                500: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["Error"];
-                    };
-                };
-            };
-        };
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
     "/v1/docs/search": {
         parameters: {
             query?: never;
@@ -16063,6 +16929,12 @@ interface paths {
                     content: {
                         "application/json": {
                             batchExecutionId: string;
+                            /** @description Every graded case that errored, with the failure text its scores recorded. Empty when no case errored, when the run is not scored yet, or when it was scored before the field shipped. */
+                            caseErrors: {
+                                caseId: string | null;
+                                error: string;
+                                name: string;
+                            }[];
                             completedAt?: string;
                             evalConfig?: unknown;
                             evalGroupId?: string;
@@ -16158,6 +17030,106 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/executions/{executionId}/events": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Stream execution events
+         * @description Execution-scoped alias of `GET /v1/agents/{id}/executions/{executionId}/events`: reconnect to a durable turn and replay-and-tail its Server-Sent Events without already knowing which agent ran it. The agent is resolved from the execution's own persisted record, so a run started through `/v1/dispatch` reconnects by execution id alone; a record with no agent (an inline definition, which addresses no durable session) answers 404. A turn that streams over an expired watch lease ends with `await` / `awaitReason: "detached"` while the execution keeps running; pass the last seen SSE `id:` as `after` to rejoin it. Replays buffered events strictly past the `after` cursor, then live-tails if the turn is still running. Each event carries an SSE `id:` line — a durable row seq, or (unified vocabulary) a composite `<seq>.<subIndex>` when one durable row translates to multiple events. Pass that id verbatim after any disconnect (tab reload, sleep, stream timeout) to resume without missing or duplicating events. Replayed and live-tailed frames use the unified execution vocabulary. An API key needs `AGENTS:READ`, `AGENTS:*`, `DISPATCH:*`, or `*`; `DISPATCH:*` is admitted because this alias exists for dispatch-started runs.
+         */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description Fallback session key, honored only for a turn that persists no session key of its own (the Claude Managed lane). A durable turn resolves its session owner from the persisted execution, and a subagent run from its private child thread. */
+                    conversationId?: string;
+                    /** @description Replay only events strictly past this cursor (the last seen SSE id, passed verbatim): a plain row seq, or the composite `<seq>.<subIndex>` a unified-vocabulary stream stamps on intermediate sub-frames. Defaults to 0 (replay the whole turn). */
+                    after?: string;
+                };
+                header?: never;
+                path: {
+                    executionId: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Server-Sent Events stream (buffered replay followed by a live tail) */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "text/event-stream": unknown;
+                    };
+                };
+                /** @description No session owner resolves for this execution */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Insufficient API key permissions */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Execution not found, or it addresses no durable session */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+                /** @description Failed to attach to the execution stream */
+                502: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/executions/{executionId}/journal": {
         parameters: {
             query?: never;
@@ -16289,6 +17261,19 @@ interface paths {
                     };
                     content: {
                         "application/json": {
+                            /**
+                             * @description How the run selected its definition: `alias` or `version` for a request that named a selector, `legacy-live-row` for a run that read the mutable agent row.
+                             * @enum {string}
+                             */
+                            agentTargetResolution?: "alias" | "version" | "legacy-live-row";
+                            /** @description Version number and label for `agentVersionId`. `null` exactly when `agentVersionId` is `null`. */
+                            agentVersion?: {
+                                id: string;
+                                label: string | null;
+                                versionNumber: number;
+                            } | null;
+                            /** @description The `agent_versions` row the run was recorded against. Present only for durable agent executions; `null` when that surface stamps no version. */
+                            agentVersionId?: string | null;
                             createdAt: string;
                             error?: string;
                             executionId: string;
@@ -17528,7 +18513,7 @@ interface paths {
         put?: never;
         /**
          * Ensure flow (config-as-code converge)
-         * @description Idempotently converge a repo-defined flow definition onto the platform. Identity is name + account scope. Hash-only probes skip the payload in the steady state (a miss is a normal 200 `definitionRequired` response, not an error); full requests create the flow or append a new version when the canonical content hash differs. Non-executing: never touches the execution pipeline — the deploy-time sibling of the dispatch-coupled `flowMode: "upsert"` (which saves and runs in one request). The response always carries the server-computed canonical hash. Set dryRun to plan without writing (CI drift gate), onConflict: "overwrite" to converge over dashboard/API edits, and release: "publish" to also re-aim the published-version pointer.
+         * @description Idempotently converge a repo-defined flow definition onto the platform. Identity is name + account scope. Hash-only probes skip the payload in the steady state (a miss is a normal 200 `definitionRequired` response, not an error); full requests create the flow or append a new version when the canonical content hash differs. Non-executing: never touches the execution pipeline — the deploy-time sibling of the dispatch-coupled `flowMode: "upsert"` (which saves and runs in one request). The response always carries the server-computed canonical hash. Set dryRun to plan without writing (CI drift gate), onConflict: "overwrite" to converge over dashboard/API edits, and release: "publish" to also re-aim the published-version pointer. Optional version.label / version.notes stamp provenance (a git SHA, a release tag) on the appended version row.
          */
         post: {
             parameters: {
@@ -17561,6 +18546,7 @@ interface paths {
                         onConflict?: "error" | "overwrite";
                         /** @enum {string} */
                         release?: "none" | "publish";
+                        version?: components["schemas"]["EnsureVersionMetadata"];
                     };
                 };
             };
@@ -37063,6 +38049,10 @@ interface paths {
                         "application/json": {
                             data: {
                                 createdAt: string;
+                                /**
+                                 * @deprecated
+                                 * @description Deprecated alias for `modelCost`; identical value.
+                                 */
                                 estimatedCost: string | null;
                                 /**
                                  * @description Engine that actually executed this record execution ('runtime' | 'legacy'). Recorded at write time from the committed lane decision; never inferred later. Null for rows written before attribution shipped and for units that never started executing (externally executed runs carry no engine).
@@ -37073,12 +38063,15 @@ interface paths {
                                 flowId: string | null;
                                 flowName: string | null;
                                 id: string;
+                                modelCost: string | null;
                                 modelUsed: string | null;
                                 promptId: string | null;
                                 promptName: string | null;
                                 recordId: string;
                                 result?: unknown;
                                 status: string;
+                                /** @description Built-in tool spend for this execution, as a decimal string. `null` means unknown, not zero: rows written before per-run cost was split into model and tool portions carry no tool figure. A run that genuinely used no billable tool records `"0"`. Sum with `modelCost` for the run total, and treat `null` as unknown rather than zero. */
+                                toolCost: string | null;
                                 totalTokens: number | null;
                             }[];
                             pagination: {
@@ -43766,7 +44759,7 @@ interface paths {
         put?: never;
         /**
          * Deploy Runtype Sandbox
-         * @description Deploy code to a persistent Runtype Sandbox container and return a preview URL.
+         * @description Deploy a live Runtype Sandbox preview. Omitted retention preserves unlimited legacy retention; explicit retention is metered and rollout-gated. Provider sleep or loss can end availability earlier.
          */
         post: {
             parameters: {
@@ -43778,6 +44771,30 @@ interface paths {
             requestBody?: {
                 content: {
                     "application/json": {
+                        code: string;
+                        files?: {
+                            [key: string]: string;
+                        };
+                        /** @enum {string} */
+                        language?: "javascript" | "typescript" | "python";
+                        /** @enum {boolean} */
+                        managed?: false;
+                        packageJson?: string;
+                        port?: number;
+                        /** @enum {string} */
+                        retention?: "10m" | "1h" | "24h" | "unlimited";
+                        sandboxId?: string;
+                        sleepPolicy?: {
+                            /** @enum {string} */
+                            mode: "never";
+                        } | {
+                            /** @enum {string} */
+                            after: "5m" | "15m" | "30m" | "1h";
+                            /** @enum {string} */
+                            mode: "idle";
+                        };
+                        startCommand?: string;
+                    } & {
                         [key: string]: unknown;
                     };
                 };
@@ -43790,6 +44807,26 @@ interface paths {
                     };
                     content: {
                         "application/json": {
+                            effectivePolicy?: {
+                                autoDeleteInterval?: number;
+                                autoStopInterval?: number;
+                                expiresAt: string | null;
+                                /** @enum {string} */
+                                metering: "active" | "legacy-untracked";
+                                /** @enum {string} */
+                                origin: "explicit" | "legacy-default";
+                                /** @enum {string} */
+                                retention: "10m" | "1h" | "24h" | "unlimited";
+                                sleepPolicy?: {
+                                    /** @enum {string} */
+                                    mode: "never";
+                                } | {
+                                    /** @enum {string} */
+                                    after: "5m" | "15m" | "30m" | "1h";
+                                    /** @enum {string} */
+                                    mode: "idle";
+                                };
+                            };
                             error?: string;
                             output?: string;
                             previewUrl?: string;
@@ -43826,6 +44863,15 @@ interface paths {
                         "application/json": components["schemas"]["Error"];
                     };
                 };
+                /** @description Sandbox lifecycle enrollment conflict */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
                 /** @description Internal server error */
                 500: {
                     headers: {
@@ -43924,7 +44970,7 @@ interface paths {
         put?: never;
         /**
          * Deploy Daytona sandbox
-         * @description Deploy code to a persistent Daytona sandbox and return a preview URL.
+         * @description Deploy a live Daytona preview. Retention defaults to 10m; provider sleep or deletion can end availability earlier. Preview URLs are not durable hosting.
          */
         post: {
             parameters: {
@@ -43936,6 +44982,35 @@ interface paths {
             requestBody?: {
                 content: {
                     "application/json": {
+                        autoDeleteInterval?: number;
+                        autoStopInterval?: number;
+                        code: string;
+                        files?: {
+                            [key: string]: string;
+                        };
+                        labels?: {
+                            [key: string]: string;
+                        };
+                        /** @enum {string} */
+                        language?: "javascript" | "typescript" | "python";
+                        /** @enum {boolean} */
+                        managed?: false;
+                        packageJson?: string;
+                        port?: number;
+                        /** @enum {string} */
+                        retention?: "10m" | "1h" | "24h" | "unlimited";
+                        sandboxId?: string;
+                        sleepPolicy?: {
+                            /** @enum {string} */
+                            mode: "never";
+                        } | {
+                            /** @enum {string} */
+                            after: "5m" | "15m" | "30m" | "1h";
+                            /** @enum {string} */
+                            mode: "idle";
+                        };
+                        startCommand?: string;
+                    } & {
                         [key: string]: unknown;
                     };
                 };
@@ -43948,6 +45023,26 @@ interface paths {
                     };
                     content: {
                         "application/json": {
+                            effectivePolicy?: {
+                                autoDeleteInterval?: number;
+                                autoStopInterval?: number;
+                                expiresAt: string | null;
+                                /** @enum {string} */
+                                metering: "active" | "legacy-untracked";
+                                /** @enum {string} */
+                                origin: "explicit" | "legacy-default";
+                                /** @enum {string} */
+                                retention: "10m" | "1h" | "24h" | "unlimited";
+                                sleepPolicy?: {
+                                    /** @enum {string} */
+                                    mode: "never";
+                                } | {
+                                    /** @enum {string} */
+                                    after: "5m" | "15m" | "30m" | "1h";
+                                    /** @enum {string} */
+                                    mode: "idle";
+                                };
+                            };
                             error?: string;
                             output?: string;
                             previewUrl?: string;
@@ -43983,6 +45078,15 @@ interface paths {
                         "application/json": components["schemas"]["Error"];
                     };
                 };
+                /** @description Sandbox not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
                 /** @description Internal server error */
                 500: {
                     headers: {
@@ -43992,6 +45096,15 @@ interface paths {
                         "application/json": components["schemas"]["Error"];
                     };
                 };
+                /** @description Sandbox metering unavailable */
+                503: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
             };
         };
         delete?: never;
@@ -45521,6 +46634,14 @@ interface components {
             /** @enum {string} */
             status: "running";
         };
+        AgentEnsureBadRequest: {
+            /**
+             * @description A release alias is organization-owned, so a personal-scope agent cannot carry one.
+             * @enum {string}
+             */
+            code?: "alias_requires_organization";
+            error: string;
+        };
         AgentEnsureConflict: {
             /** @enum {string} */
             code: "external_modification" | "remote_changed";
@@ -45529,6 +46650,25 @@ interface components {
             lastModifiedSource?: string;
             modifiedAt?: string | null;
         };
+        /** @description Atomically save this definition and activate it at a release alias. Use { alias: "live" } to deploy to production, or any name matching ^[a-z0-9][a-z0-9-]{0,62}$ for a preview pointer. A non-live alias appends a candidate version and moves that one pointer: it never writes the agent row, its config hash, its capabilities, its draft pointer or its live pointer, so onConflict and expectedRemoteHash describe writes it never performs and are rejected with a 400 alongside it. A release alias is organization-owned, so a non-live deploy on a personal-scope agent is a 400 with code alias_requires_organization. Mutually exclusive with release. */
+        AgentEnsureDeployTarget: {
+            alias: string;
+        };
+        /** @description Present when the converge carried release or deploy and the activation was applied. */
+        AgentEnsureDeployment: {
+            /** @description The release alias this converge aimed. */
+            alias: string;
+            /** @description Whether this converge moved the pointer (on a dry run, whether it would move it). */
+            changed: boolean;
+            /** @description The deployment receipt this converge appended. Absent when the pointer did not move. */
+            receiptId?: string;
+            /** @description Compare-and-swap revision of the alias, null when the alias does not exist yet. */
+            revision: number | null;
+            /** @description The version the alias selects as of this response (null on a dry run against an alias that does not exist yet). */
+            versionId: string | null;
+            /** @description Version number of that version, when known. */
+            versionNumber: number | null;
+        };
         AgentEnsureHashMismatch: {
             /** @enum {string} */
             code: "content_hash_mismatch";
@@ -45540,6 +46680,9 @@ interface components {
             agentId: string;
             /** @description Server-computed canonical content hash. Clients should echo this hash in probes. */
             contentHash: string;
+            deployment?: components["schemas"]["AgentEnsureDeployment"];
+            /** @description For a non-live deploy: the content hash the alias carried before this converge (absent when the alias is new). */
+            remoteHash?: string;
             /** @enum {string} */
             result: "unchanged" | "created" | "updated";
             /** @description The version snapshot backing this state (null if snapshotting failed). */
@@ -45553,10 +46696,18 @@ interface components {
             /** @enum {string} */
             changes: "none" | "create" | "update";
             contentHash: string;
+            deployment?: components["schemas"]["AgentEnsureDeployment"] & unknown;
             remoteHash?: string;
             /** @enum {string} */
             result: "plan";
         };
+        AgentEnsureServerError: {
+            /** @description The release alias whose activation failed. No pointer was moved. */
+            alias?: string;
+            /** @enum {string} */
+            code?: "alias_activation_failed";
+            error: string;
+        };
         AgentPullResponse: {
             agentId: string;
             contentHash: string;
@@ -45654,16 +46805,25 @@ interface components {
                     };
                     sandbox?: {
                         enabled: boolean;
-                        /** @enum {string} */
+                        /**
+                         * @description Only standard-4 is supported on the hosted Agent Sandbox path; other sizes cannot be enabled.
+                         * @enum {string}
+                         */
                         instanceType?: "standard-1" | "standard-2" | "standard-3" | "standard-4";
                         networkAccess?: ("none" | "essentials" | "open") | {
                             allow?: string[];
                             /** @enum {string} */
                             profile?: "none" | "essentials" | "open";
                         };
-                        /** @enum {string} */
+                        /**
+                         * @description Supported: ephemeral or conversation. Named remains parseable for stored configs but cannot be enabled.
+                         * @enum {string}
+                         */
                         persistence?: "ephemeral" | "conversation" | "named";
-                        /** @enum {string} */
+                        /**
+                         * @description Only runtype-sandbox is currently supported. Daytona is retained for stored-config parsing but rejected at authoring/execution.
+                         * @enum {string}
+                         */
                         provider?: "runtype-sandbox" | "daytona";
                         secretEnv?: {
                             [key: string]: string;
@@ -46038,13 +47198,20 @@ interface components {
             upgradeUrl?: string;
         };
         DispatchApproveJsonResponse: components["schemas"]["DispatchApprovalContinuationJsonResponse"] | components["schemas"]["DispatchDetachedApprovalJsonResponse"];
-        DispatchContinuationJsonResponse: components["schemas"]["DispatchToolOutputContinuationJsonResponse"] | components["schemas"]["DispatchApprovalContinuationJsonResponse"] | components["schemas"]["DispatchDetachedApprovalJsonResponse"];
+        DispatchContinuationJsonResponse: components["schemas"]["DispatchToolOutputContinuationJsonResponse"] | components["schemas"]["DispatchApprovalContinuationJsonResponse"] | components["schemas"]["DispatchDetachedApprovalJsonResponse"] | components["schemas"]["DispatchDetachedToolOutputJsonResponse"];
         DispatchDetachedApprovalJsonResponse: {
             approvalId: string;
             executionId: string;
             /** @enum {string} */
             status: "running";
         };
+        DispatchDetachedToolOutputJsonResponse: {
+            executionId: string;
+            /** @enum {string} */
+            pauseKind: "client_tool" | "elicitation";
+            /** @enum {string} */
+            status: "running";
+        };
         DispatchFlowJsonResponse: {
             blockReason?: string;
             code?: string;
@@ -46087,6 +47254,7 @@ interface components {
             /** @enum {string} */
             type: "durable_poll";
         };
+        DispatchResumeJsonResponse: components["schemas"]["DispatchToolOutputContinuationJsonResponse"] | components["schemas"]["DispatchDetachedToolOutputJsonResponse"];
         DispatchToolOutputContinuationJsonResponse: {
             blockReason?: string;
             code?: string;
@@ -46169,6 +47337,19 @@ interface components {
                 versionNumber: number;
             } | null;
         };
+        /** @description Provenance recorded on the version row this converge appends. Omit to keep the default "sdk-ensure" label and the server-generated notes. */
+        EnsureVersionMetadata: {
+            /**
+             * @description Short provenance label recorded on the appended version row (e.g. a git SHA or release tag). Defaults to "sdk-ensure". An empty string is treated as omitted.
+             * @example a1b2c3d
+             */
+            label?: string;
+            /**
+             * @description Free-form notes recorded on the appended version row, used verbatim. Defaults to the server-generated converge summary. An empty string is treated as omitted.
+             * @example Promoted from CI run 4821 (main@a1b2c3d).
+             */
+            notes?: string;
+        };
         Error: {
             details?: {
                 /** @description Stable Runtype validation code (e.g. MISSING_REQUIRED_FIELD, INVALID_ENUM). */
@@ -46381,6 +47562,8 @@ interface components {
             cases: {
                 /** @description The saved eval case id; null when the case row was deleted or the record could not be mapped to a case. */
                 caseId: string | null;
+                /** @description Why the case errored (the provider or execution failure text, 2000 chars max); null when the case did not error or the run predates this field. */
+                error: string | null;
                 /**
                  * @description Engine that actually executed this graded case ('runtime' | 'legacy'). Recorded at write time from the committed lane decision; never inferred later. Null for rows written before attribution shipped and for units that never started executing (externally executed runs carry no engine).
                  * @enum {string|null}
@@ -47420,6 +48603,8 @@ interface components {
         };
         RunEvalResponse: {
             cases: {
+                /** @description Why the case errored (the provider or execution failure text, 2000 chars max). Present only when errored is true and the run reported a cause. */
+                error?: string;
                 errored: boolean;
                 name: string;
                 outcomes: {
@@ -49712,8 +50897,12 @@ type DispatchResponse = paths['/v1/dispatch']['post']['responses'][200]['content
 type AsyncExecutionHandle = components['schemas']['AsyncDispatchHandle'];
 /** Lifecycle response returned by the generic asynchronous execution status route. */
 type AsyncExecutionStatus = paths['/v1/executions/{executionId}/status']['get']['responses'][200]['content']['application/json'];
-/** Buffered `/v1/dispatch/resume` response for a tool-output continuation. */
+/** Buffered ordinary tool-output continuation (a durable-lane resume uses a separate variant). */
 type DispatchResumeResponse = components['schemas']['DispatchToolOutputContinuationJsonResponse'];
+/** Buffered detached tool-output acknowledgement; the durable run keeps going after it. */
+type DispatchDetachedToolOutputResponse = components['schemas']['DispatchDetachedToolOutputJsonResponse'];
+/** Buffered `/v1/dispatch/resume` response, including a durable-lane acknowledgement. */
+type DispatchResumeJsonResponse = paths['/v1/dispatch/resume']['post']['responses'][200]['content']['application/json'];
 /** Buffered ordinary-approval result (detached approvals use a separate variant). */
 type DispatchApprovalContinuationResponse = components['schemas']['DispatchApprovalContinuationJsonResponse'];
 /** Buffered detached-approval acknowledgement; the detached run remains active. */
@@ -49879,6 +51068,22 @@ interface ExecuteToolResponse {
     errorMessage?: string;
     executionTimeMs: number;
 }
+type SandboxDeployRetention = '10m' | '1h' | '24h' | 'unlimited';
+type SandboxDeploySleepPolicy = {
+    mode: 'never';
+} | {
+    mode: 'idle';
+    after: '5m' | '15m' | '30m' | '1h';
+};
+interface SandboxDeployEffectivePolicy {
+    retention: SandboxDeployRetention;
+    origin: 'explicit' | 'legacy-default';
+    expiresAt: string | null;
+    metering: 'active' | 'legacy-untracked';
+    sleepPolicy?: SandboxDeploySleepPolicy;
+    autoStopInterval?: number;
+    autoDeleteInterval?: number;
+}
 interface DeploySandboxRequest {
     code: string;
     packageJson?: string;
@@ -49893,6 +51098,10 @@ interface DeploySandboxRequest {
     autoStopInterval?: number;
     /** Auto-delete interval in minutes (Daytona); 0 deletes immediately on stop. Disabled when omitted. */
     autoDeleteInterval?: number;
+    /** Runtype destruction backstop; defaults to 10m independently of provider autostop. */
+    retention?: SandboxDeployRetention;
+    /** Cannot be combined with autoStopInterval. Does not extend retention. */
+    sleepPolicy?: SandboxDeploySleepPolicy;
 }
 interface DeploySandboxResponse {
     sandboxId: string;
@@ -49900,6 +51109,7 @@ interface DeploySandboxResponse {
     output: string;
     status: 'running' | 'error';
     error?: string;
+    effectivePolicy?: SandboxDeployEffectivePolicy;
 }
 interface DeployCfSandboxRequest {
     code: string;
@@ -49909,6 +51119,10 @@ interface DeployCfSandboxRequest {
     sandboxId?: string;
     startCommand?: string;
     files?: Record<string, string>;
+    /** Omission preserves unlimited legacy retention. Explicit policy requires lifecycle rollout enablement. */
+    retention?: SandboxDeployRetention;
+    /** Legacy Runtype Sandbox supports idle sleep only; continuous keepAlive is unavailable. */
+    sleepPolicy?: SandboxDeploySleepPolicy;
 }
 interface DeployCfSandboxResponse {
     sandboxId: string;
@@ -49917,6 +51131,7 @@ interface DeployCfSandboxResponse {
     status: 'running' | 'error';
     stage?: 'validate_port' | 'validate_files' | 'write_package_json' | 'npm_install' | 'write_main_file' | 'write_additional_files' | 'start_process' | 'expose_port';
     error?: string;
+    effectivePolicy?: SandboxDeployEffectivePolicy;
 }
 interface ModelUsageQueryParams {
     startDate?: string;
@@ -50552,6 +51767,164 @@ interface BillingSpendAnalyticsParams {
      */
     period?: 'billing_period' | 'current_month' | 'last_7_days' | 'last_30_days' | 'last_90_days';
 }
+interface ProductionHealthQuery {
+    /** Length of the reporting window in days (1-90). Defaults to 7. */
+    days?: number;
+}
+/**
+ * A metric beside its comparison value: the preceding period of equal length,
+ * unless the field says otherwise. `null` means "not computable", never
+ * "zero".
+ *
+ * These metrics are read from run ledgers that record one row per run. No row
+ * exists for a run that finished before those ledgers were deployed and none
+ * can be reconstructed, so `previous` is empty rather than wrong until the
+ * preceding period is entirely made up of ledger-era runs.
+ */
+interface MetricDelta {
+    value: number | null;
+    previous: number | null;
+}
+/**
+ * Run counts for one population. `successes + failures + unsettled` equals
+ * `current`; the success rate divides `successes` by the settled runs only, so
+ * `failures` must be read rather than derived as `current - successes`.
+ */
+interface ExecutionCounts {
+    /** Runs that started inside the current period. */
+    current: number;
+    /** Runs that started inside the preceding period of equal length. */
+    previous: number;
+    /** Current-period runs that finished successfully. */
+    successes: number;
+    /** Current-period runs that ended in an error or lost their stream. */
+    failures: number;
+    /**
+     * Current-period runs with no verdict: still running, paused waiting on an
+     * approval or a client tool, or cancelled by the caller. They are inside
+     * `current` because they happened, and outside the success rate entirely.
+     */
+    unsettled: number;
+}
+interface HealthInsight {
+    id: string;
+    severity: 'critical' | 'warning' | 'info';
+    title: string;
+    detail: string;
+    href?: string;
+}
+interface ProductionHealthResponse {
+    /** Daily intervals anchored to period.start, counting root runs once. */
+    activity?: Array<{
+        date: string;
+        agents: number;
+        flows: number;
+        unclassified: number;
+    }>;
+    period: {
+        days: number;
+        start: string;
+        end: string;
+        previousStart: string;
+    };
+    /**
+     * Run totals across BOTH populations, one row per run whatever it did.
+     * `agents` is broken out first: an agent turn drives a flow internally, so
+     * before this split the same run was counted on the headline and again on
+     * the agents line. Every field is agents plus flows plus unclassified history.
+     *
+     * The two halves come from different tables because neither is complete on
+     * its own. Agent counts come from `agent_executions`, which is the only
+     * record of an agent the customer hosts themselves (reported over
+     * OpenTelemetry, or proxied over HTTP) since no Runtype runtime ran it. Flow
+     * counts come from `flow_executions` rows that no agent drove.
+     */
+    executions: ExecutionCounts & {
+        /** Agent runs. Includes agents running outside Runtype. */
+        agents: ExecutionCounts;
+        /** Flow runs. */
+        flows: ExecutionCounts;
+        unclassified: ExecutionCounts;
+    };
+    /**
+     * Successful runs over SETTLED runs. Runs still open, paused mid-run, or
+     * cancelled are outside both halves of this division rather than counted as
+     * either outcome. Null when nothing in the period settled.
+     */
+    successRate: MetricDelta;
+    /**
+     * 95th percentile of a run's wall clock, start to finish: context steps,
+     * tool-call steps and queueing included. Measured over settled runs only, so
+     * a run that is still open or still paused contributes nothing. A run that
+     * paused for an approval or a client tool and then resumed carries that wait
+     * inside its wall clock, because the caller waited for it too. Null when no
+     * settled run in the period recorded a duration.
+     */
+    p95LatencyMs: MetricDelta;
+    /**
+     * Model cost including retries, compaction, fallback and descendants, divided
+     * by successful runs. Null when any run has incomplete model accounting.
+     * Estimated execution cost excludes billing margin and is not billed spend.
+     */
+    modelCostPerSuccess: MetricDelta;
+    /** Estimated model cost across every run in the window, failed runs included. Same caveats. */
+    totalModelCost: MetricDelta;
+    costs: Record<'model' | 'tool' | 'total', MetricDelta & {
+        knownValue: number;
+        knownPrevious: number;
+        incompleteRuns: number;
+        previousIncompleteRuns: number;
+    }>;
+    /**
+     * Share of runs where at least one attempt routed to a fallback model instead
+     * of the configured one, over every run in the period. Null when any run has
+     * incomplete model accounting.
+     */
+    fallbackShare: MetricDelta;
+    /**
+     * Eval pass rates. `value` and `previous` are the latest scored run and the previous scored run
+     * in the same suite, compared run over run rather than period over
+     * period, so either may predate the window.
+     */
+    evals: MetricDelta & {
+        suiteId: string | null;
+        suiteName: string | null;
+        /** When the most recent eval run of any kind was created; null if none has ever run. */
+        lastRunAt: string | null;
+        /**
+         * When the run behind `value` was created; null while nothing has ever
+         * scored. This is older than `lastRunAt` whenever the newest run is still
+         * processing, cancelled, failed, or graded nothing, so it is the only
+         * timestamp a pass rate may be presented beside. Pairing `value` with
+         * `lastRunAt` attributes a rate to a run that did not produce it.
+         */
+        lastScoredRunAt: string | null;
+        /**
+         * Whether `lastRunAt` falls inside the current period. Any eval run counts,
+         * including one still processing, cancelled, failed, or with no graders, so
+         * this can be true while `value` is null (nothing scored yet) and false
+         * while `value` is set (the last run that scored predates the window).
+         */
+        ranInPeriod: boolean;
+    };
+    agents: {
+        /**
+         * Share of agent runs that stopped because they hit the turn ceiling.
+         * Agent run counts live on `executions.agents`, not here.
+         */
+        maxTurnsShare: MetricDelta;
+    };
+    surfaces: Array<{
+        /** Surface the agent executions were attributed to; rows with no surface type are grouped as `unknown`. */
+        surfaceType: string;
+        /** Agent executions on this surface in the current period. Counts agent runs only, not flow runs. */
+        executions: number;
+        /** Share of those agent executions that completed. */
+        successRate: number | null;
+    }>;
+    insights: HealthInsight[];
+    generatedAt: string;
+}
 
 /**
  * Per-grader severity (mirror of `@runtypelabs/shared`'s `GraderSeverity`). A
@@ -50976,6 +52349,8 @@ interface RunEvalCaseResult {
     outputExcerpt: string;
     /** Whether producing the output threw. */
     errored: boolean;
+    /** Why the case errored (provider or execution failure text); present only when `errored` is true and a cause was reported. */
+    error?: string;
 }
 /** The synchronous run + score result returned by `client.evals.runSuite(...)`. */
 interface RunEvalResult {
@@ -51022,6 +52397,8 @@ interface EvalRunCaseScores {
     outcomes: PersistedGraderOutcome[];
     /** Truncated snapshot of the output that was graded. */
     outputExcerpt: string;
+    /** Why the case errored; null when it did not, or for runs recorded before this field shipped. */
+    error: string | null;
     /**
      * For a checkpoint ("saved from run") case run in next-step mode: the
      * tool-call intent(s) the target emitted as its graded next step (captured,
@@ -51182,6 +52559,12 @@ interface EnsureFlowOptions {
      * the remote still hashes to this value (409 remote_changed otherwise).
      */
     expectedRemoteHash?: string;
+    /**
+     * Provenance stamped on the version row this converge appends (a git SHA, a
+     * release tag). Omit to keep the default 'sdk-ensure' label and the
+     * server-generated notes.
+     */
+    version?: components['schemas']['EnsureVersionMetadata'];
     /** Implies dryRun; throws FlowDriftError unless the plan is 'none'. */
     expectNoChanges?: boolean;
 }
@@ -53284,6 +54667,12 @@ interface EnsureAgentOptions {
      * the remote still hashes to this value (409 remote_changed otherwise).
      */
     expectedRemoteHash?: string;
+    /**
+     * Provenance stamped on the version row this converge appends (a git SHA, a
+     * release tag). Omit to keep the default 'sdk-ensure' label and the
+     * server-generated notes.
+     */
+    version?: components['schemas']['EnsureVersionMetadata'];
     /** Implies dryRun; throws AgentDriftError unless the plan is 'none'. */
     expectNoChanges?: boolean;
 }
@@ -53916,6 +55305,97 @@ declare class SurfacesNamespace {
     pull(productId: string, name: string): Promise<SurfacePullResult>;
 }
 
+/**
+ * Transparent reconnect for a DETACHED agent stream (ADR 0020 point 6;
+ * blueprint `2026-08-25-durable-by-default-agent-turns.md` §4).
+ *
+ * ## What the server does
+ *
+ * A durable agent turn runs inside a Durable Object, and the socket it streams
+ * over carries a WATCH LEASE (10 minutes by default), not the turn's lifetime.
+ * When the lease expires the server emits a unified `await` frame with
+ * `awaitReason: 'detached'` and CLOSES the stream — the execution keeps running
+ * server-side. Detach is part of the public contract, not an error:
+ *
+ *   id: 118
+ *   event: await
+ *   data: {"type":"await","awaitReason":"detached","executionId":"aex_…",…}
+ *
+ * Raw-HTTP consumers get documented behavior. The SDKs are expected to follow
+ * it, which is what this module does: it reopens the turn through the events
+ * route with `?after=<last SSE id>` and keeps yielding frames until a real
+ * terminal arrives.
+ *
+ * ## Why it wraps the stream rather than the callbacks
+ *
+ * `executeStream` is the single place every consumer goes through
+ * (`executeWithCallbacks` and the local-tool loop both build on it), so
+ * wrapping the `Response` body makes reconnect transparent for all of them at
+ * once — and for a caller reading the raw stream by hand.
+ *
+ * Bytes are forwarded VERBATIM. This is not a re-encoder: it parses complete
+ * SSE blocks only to observe three things (the last `id:`, the executionId, and
+ * whether a terminal or a detach frame went by), and passes the original text
+ * straight through. That matters because the `id:` line IS the relay cursor —
+ * re-stamping it would break the very reconnect this exists to perform.
+ *
+ * ## Cursor and duplicate-freedom
+ *
+ * The server replays strictly AFTER the cursor, so a reconnect produces no
+ * duplicates. A cursor that is malformed or lost fails OPEN to a replay from
+ * the start of the turn, which is why the last-seen `id:` is tracked as the
+ * raw string rather than being parsed into a number here.
+ *
+ * ## The detach frame is not swallowed
+ *
+ * It is forwarded like any other frame. The wire vocabulary is unchanged, so a
+ * consumer that renders `await` states keeps rendering this one; the difference
+ * is only that the stream no longer ENDS there.
+ *
+ * The Python SDK mirrors this behavior — a follow-up, tracked with the rest of
+ * the SDK work in the blueprint's §4 slice 2.
+ */
+/**
+ * How many times a single logical turn may be re-opened. A detached turn is
+ * bounded by its absolute budget (30 minutes by default, 24 hours at most) and
+ * each leg covers a full watch lease, so this is a safety stop against a server
+ * that detaches immediately and repeatedly — not a normal-path limit.
+ */
+declare const DEFAULT_MAX_DETACHED_RECONNECTS = 12;
+interface DetachedReconnectOptions {
+    /**
+     * Turn transparent reconnect OFF and hand back the raw stream, ending at the
+     * detach frame. The documented escape hatch: a caller that wants to own the
+     * reconnect (its own backoff, its own cursor storage, a handoff to another
+     * process) sets this and drives the events route itself.
+     */
+    autoReconnect?: boolean;
+    /** Safety stop; see {@link DEFAULT_MAX_DETACHED_RECONNECTS}. */
+    maxReconnects?: number;
+    /** Milliseconds to wait before each reconnect attempt. */
+    reconnectDelayMs?: number;
+}
+/**
+ * Link a caller's cancellation to the reconnect wrapper's own signal.
+ *
+ * Cancelling the wrapped stream must abort a reattach request that is already
+ * opening, so a reattach honors BOTH signals rather than only the caller's.
+ */
+declare function combineAbortSignals(...signals: Array<AbortSignal | undefined>): AbortSignal | undefined;
+/** Open the next leg of a detached turn. Returns `null` when it cannot. */
+type DetachedReattach = (args: {
+    executionId: string;
+    after: string;
+    signal?: AbortSignal;
+}) => Promise<Response | null>;
+/**
+ * Wrap a durable-turn SSE `Response` so a detach transparently continues.
+ *
+ * A non-streaming or failed response is returned untouched — there is nothing
+ * to follow, and swallowing it here would hide the error from the caller.
+ */
+declare function withDetachedReconnect(response: Response, reattach: DetachedReattach, options?: DetachedReconnectOptions): Response;
+
 interface RuntypeConfig {
     /** API key for authentication */
     apiKey?: string;
@@ -53972,8 +55452,14 @@ declare class RuntypeClient$1 {
      * (`RuntypeFlowBuilder`), so it normalizes the request to the canonical
      * `/v1/dispatch` wire contract here — every builder path inherits the same
      * normalization the `DispatchEndpoint` applies, with no per-builder call.
+     *
+     * A dispatched agent turn runs on the durable lane, so the stream follows a
+     * detach through {@link executionEvents}; pass `autoReconnect: false` to own
+     * the reconnect yourself.
      */
-    dispatch(config: unknown): Promise<Response>;
+    dispatch(config: unknown, init?: {
+        signal?: AbortSignal;
+    } & DetachedReconnectOptions): Promise<Response>;
     /**
      * Dispatch flow execution (non-streaming JSON).
      *
@@ -53985,6 +55471,26 @@ declare class RuntypeClient$1 {
     /** Start a normalized dispatch and return a durable handle immediately. */
     dispatchAsync(config: unknown): Promise<AsyncExecutionHandle>;
     getExecutionStatus(executionId: string): Promise<AsyncExecutionStatus>;
+    /**
+     * Rejoin a durable execution's Server-Sent Events by execution id.
+     *
+     * The execution-scoped alias of the agent events route, so a turn started
+     * through `/v1/dispatch` reconnects without knowing which agent served it.
+     * Pass the last SSE `id:` the stream delivered as `after` to replay strictly
+     * past that cursor and then live-tail while the run is still going. This is
+     * the same leg a detached dispatch stream follows on its own, exposed for a
+     * caller that stores the cursor and reattaches later or from elsewhere.
+     *
+     * @example
+     * ```typescript
+     * const events = await client.executionEvents('aex_123', { after: '118' })
+     * ```
+     */
+    executionEvents(executionId: string, opts?: {
+        after?: string;
+        conversationId?: string;
+        signal?: AbortSignal;
+    }): Promise<Response>;
     /**
      * Build full URL with query parameters
      */
@@ -54287,90 +55793,6 @@ declare class Runtype {
     static get surfaces(): SurfacesNamespace;
 }
 
-/**
- * Transparent reconnect for a DETACHED agent stream (ADR 0020 point 6;
- * blueprint `2026-08-25-durable-by-default-agent-turns.md` §4).
- *
- * ## What the server does
- *
- * A durable agent turn runs inside a Durable Object, and the socket it streams
- * over carries a WATCH LEASE (10 minutes by default), not the turn's lifetime.
- * When the lease expires the server emits a unified `await` frame with
- * `awaitReason: 'detached'` and CLOSES the stream — the execution keeps running
- * server-side. Detach is part of the public contract, not an error:
- *
- *   id: 118
- *   event: await
- *   data: {"type":"await","awaitReason":"detached","executionId":"aex_…",…}
- *
- * Raw-HTTP consumers get documented behavior. The SDKs are expected to follow
- * it, which is what this module does: it reopens the turn through the events
- * route with `?after=<last SSE id>` and keeps yielding frames until a real
- * terminal arrives.
- *
- * ## Why it wraps the stream rather than the callbacks
- *
- * `executeStream` is the single place every consumer goes through
- * (`executeWithCallbacks` and the local-tool loop both build on it), so
- * wrapping the `Response` body makes reconnect transparent for all of them at
- * once — and for a caller reading the raw stream by hand.
- *
- * Bytes are forwarded VERBATIM. This is not a re-encoder: it parses complete
- * SSE blocks only to observe three things (the last `id:`, the executionId, and
- * whether a terminal or a detach frame went by), and passes the original text
- * straight through. That matters because the `id:` line IS the relay cursor —
- * re-stamping it would break the very reconnect this exists to perform.
- *
- * ## Cursor and duplicate-freedom
- *
- * The server replays strictly AFTER the cursor, so a reconnect produces no
- * duplicates. A cursor that is malformed or lost fails OPEN to a replay from
- * the start of the turn, which is why the last-seen `id:` is tracked as the
- * raw string rather than being parsed into a number here.
- *
- * ## The detach frame is not swallowed
- *
- * It is forwarded like any other frame. The wire vocabulary is unchanged, so a
- * consumer that renders `await` states keeps rendering this one; the difference
- * is only that the stream no longer ENDS there.
- *
- * The Python SDK mirrors this behavior — a follow-up, tracked with the rest of
- * the SDK work in the blueprint's §4 slice 2.
- */
-/**
- * How many times a single logical turn may be re-opened. A detached turn is
- * bounded by its absolute budget (30 minutes by default, 24 hours at most) and
- * each leg covers a full watch lease, so this is a safety stop against a server
- * that detaches immediately and repeatedly — not a normal-path limit.
- */
-declare const DEFAULT_MAX_DETACHED_RECONNECTS = 12;
-interface DetachedReconnectOptions {
-    /**
-     * Turn transparent reconnect OFF and hand back the raw stream, ending at the
-     * detach frame. The documented escape hatch: a caller that wants to own the
-     * reconnect (its own backoff, its own cursor storage, a handoff to another
-     * process) sets this and drives the events route itself.
-     */
-    autoReconnect?: boolean;
-    /** Safety stop; see {@link DEFAULT_MAX_DETACHED_RECONNECTS}. */
-    maxReconnects?: number;
-    /** Milliseconds to wait before each reconnect attempt. */
-    reconnectDelayMs?: number;
-}
-/** Open the next leg of a detached turn. Returns `null` when it cannot. */
-type DetachedReattach = (args: {
-    executionId: string;
-    after: string;
-    signal?: AbortSignal;
-}) => Promise<Response | null>;
-/**
- * Wrap a durable-turn SSE `Response` so a detach transparently continues.
- *
- * A non-streaming or failed response is returned untouched — there is nothing
- * to follow, and swallowing it here would hide the error from the caller.
- */
-declare function withDetachedReconnect(response: Response, reattach: DetachedReattach, options?: DetachedReconnectOptions): Response;
-
 /**
  * Agent API key request types.
  *
@@ -54973,6 +56395,20 @@ interface ApiClient {
     postBinary<T>(path: string, body: Uint8Array, contentType: string): Promise<T>;
     requestStream(path: string, options?: RequestInit): Promise<Response>;
 }
+/**
+ * Path of the execution-scoped events alias,
+ * `GET /v1/executions/{executionId}/events`.
+ *
+ * The reconnect leg a dispatch-started durable turn rejoins through: it names
+ * no agent, because the alias resolves the agent from the execution's own
+ * persisted record. Single-sourced here so the transparent reattach inside
+ * `DispatchEndpoint.executeStream` and the explicit `executionEvents` method on
+ * the client build the same URL, cursor and session key included.
+ */
+declare function buildExecutionEventsPath(executionId: string, query?: {
+    after?: string;
+    conversationId?: string;
+}): string;
 /**
  * Flows endpoint handlers
  */
@@ -55540,16 +56976,33 @@ declare class DispatchEndpoint {
     executeAsync(data: DispatchRequest): Promise<AsyncExecutionHandle>;
     /**
      * Dispatch with streaming response
+     *
+     * A dispatched agent turn runs on the durable lane, so its socket can close
+     * with `await` / `awaitReason: 'detached'` while the run continues. The
+     * stream follows that detach through the execution-scoped events alias;
+     * `autoReconnect: false` hands back the raw stream instead.
+     */
+    executeStream(data: DispatchRequest, init?: {
+        signal?: AbortSignal;
+    } & DetachedReconnectOptions): Promise<Response>;
+    /**
+     * The `?after=` reattach leg a detached dispatch stream is followed with.
+     *
+     * Unlike an agent execute, a dispatch knows no agent id at the call site, so
+     * it rejoins by execution id alone through the execution-scoped alias. The
+     * cursor is the last SSE `id:` the stream delivered, forwarded verbatim.
      */
-    executeStream(data: DispatchRequest): Promise<Response>;
+    private buildDetachedReattach;
     /**
      * Resume paused flow execution
-     * Uses buffered JSON when streamResponse is omitted.
+     * Uses buffered JSON when streamResponse is omitted. A durable-lane (`aex_`)
+     * pause answers `{ executionId, status: 'running' }` buffered, or a stream
+     * that detaches and is followed through the execution events alias.
      *
      * @param data.executionId - The execution ID to resume
      * @param data.toolOutputs - Tool outputs to inject into the flow
      * @param data.streamResponse - Whether to stream the response (defaults to false)
-     * @param data.messages - Optional messages to override the original dispatch messages
+     * @param data.messages - Optional messages that REPLACE the stored conversation; ignored by a durable-lane resume
      */
     resume(data: {
         executionId: string;
@@ -55563,7 +57016,9 @@ declare class DispatchEndpoint {
                 image?: string;
             }>;
         }>;
-    }): Promise<any>;
+    }, init?: {
+        signal?: AbortSignal;
+    } & DetachedReconnectOptions): Promise<any>;
     /**
      * Evaluate a model-proposed runtime tool against a configurable allowlist policy.
      * Useful for local `propose_runtime_tool` handlers before redispatch.
@@ -55652,6 +57107,12 @@ declare class AnalyticsEndpoint {
      * Get execution and platform-spend usage grouped by projected product end user.
      */
     getEndUserUsage(params: EndUserUsageQuery): Promise<EndUserUsageResponse>;
+    /**
+     * Get reliability, latency, unit economics, and eval health for the current
+     * period against the preceding period of equal length, plus a derived feed of
+     * notable changes.
+     */
+    getProductionHealth(params?: ProductionHealthQuery): Promise<ProductionHealthResponse>;
 }
 /**
  * Flow Steps endpoint handlers
@@ -55794,7 +57255,7 @@ declare class ToolsEndpoint {
      */
     getBuiltInToolSchema(toolId: string): Promise<BuiltInTool>;
     /**
-     * Deploy code to a persistent Daytona sandbox and get a preview URL
+     * Deploy a Daytona preview; retention defaults to ten minutes and the URL is not durable hosting.
      */
     deploySandbox(data: DeploySandboxRequest): Promise<DeploySandboxResponse>;
     /**
@@ -55802,7 +57263,7 @@ declare class ToolsEndpoint {
      */
     cleanupSandbox(sandboxId: string): Promise<void>;
     /**
-     * Deploy code to a persistent Cloudflare Sandbox container and get a preview URL
+     * Deploy a Runtype Sandbox preview; omitted retention preserves the legacy unlimited backstop.
      */
     deployCfSandbox(data: DeployCfSandboxRequest): Promise<DeployCfSandboxResponse>;
     /**
@@ -56623,6 +58084,16 @@ interface AgentExecuteRequest {
      * Mirrors `DispatchRequest.options.cache`.
      */
     cache?: boolean;
+    /**
+     * Per-request durability override. `forced` pins this turn's lane and outranks the saved
+     * agent's `config.durability` pin; `watchLeaseMs` bounds only the single attached socket,
+     * after which the watcher detaches and the turn keeps running. Durability does not imply
+     * async: `Prefer: respond-async` stays a separate choice. Mirrors `DispatchRequest.agent.durability`.
+     */
+    durability?: {
+        forced?: 'durable' | 'in_process';
+        watchLeaseMs?: number;
+    };
 }
 /**
  * Agent execute response (non-streaming)
@@ -59363,4 +60834,4 @@ declare function getLikelySupportingCandidatePaths(bestCandidatePath: string | u
 declare function getDefaultPlanPath(taskName: string): string;
 declare function sanitizeTaskSlug(taskName: string): string;
 
-export { type AIGrader, type Agent, type AgentAdmissionOptions, type AgentApprovalCompleteEvent, type AgentApprovalStartEvent, type AgentCompleteEvent, type AgentDefinition, type AgentDefinitionConfig, AgentDriftError, type AgentElicitation, type AgentElicitationRequest, AgentEnsureConflictError, type AgentErrorEvent, type AgentEvent, type AgentEventType, type AgentExecuteRequest, type AgentExecuteResponse, type AgentIterationCompleteEvent, type AgentIterationStartEvent, type AgentMediaEvent, type AgentMessage, type AgentPausedEvent, type AgentPingEvent, type AgentPullResult, type AgentReflectionEvent, type AgentRuntimeToolDefinition, type AgentStartEvent, type AgentStreamCallbacks, type AgentStreamEvent, type AgentSubagentConfig, type AgentToolCompleteEvent, type AgentToolDeltaEvent, type AgentToolInputCompleteEvent, type AgentToolInputDeltaEvent, type AgentToolStartEvent, type AgentTurnCompleteEvent, type AgentTurnDeltaEvent, type AgentTurnStartEvent, type AgentVersionDetail, type AgentVersionListItem, type AgentVersionPublishResponse, AgentVersionsEndpoint, type AgentVersionsListResponse, AgentsEndpoint, AgentsNamespace, AnalyticsEndpoint, type ApiClient, type ApiKey, type ApiKeyRequest, type ApiKeyRequestDelivery, type ApiKeyRequestEnvironment, type ApiKeyRequestHandoff, type ApiKeyRequestListParams, type ApiKeyRequestRequester, type ApiKeyRequestStatus, ApiKeyRequestsEndpoint, ApiKeysEndpoint, type ApiResponse, type ApplyGeneratedProposalOptions, type ApplyGeneratedProposalResult, type AssetReferenceContentPart, type AsyncExecutionHandle, type AsyncExecutionStatus, type AttachRuntimeToolsOptions, type BaseAgentEvent, BatchBuilder, type BatchClient, type BatchListParams, type BatchOptions, type BatchRequest, type BatchResult, type BatchScheduleConfig, type BatchStatus, BatchesNamespace, BillingEndpoint, type BillingSpendAnalyticsParams, type BindSkillInput, type BuiltInGraderId, type BuiltInTool, type BulkEditCondition, type BulkEditRequest, type BulkEditResponse, type BulkEditResult, type CanonicalDispatchMessageContent, type CanonicalDispatchRequest, type CaseExpected, type CatalogClientToolRef, ChatEndpoint, type CheckGrader, type ClaimApiKeyRequestInput, type ClaimApiKeyRequestResponse, type ClaudeManagedEvalOverrideValues, ClientBatchBuilder, type ClientConfig, type ClientConversation, ClientEvalBuilder, ClientFlowBuilder, type ClientToken, type ClientTokenConfig, type ClientTokenEnvironment, type ClientTokenVersionPin, ClientTokensEndpoint, type ClientToolDefinition, type ClientToolEntry, type ClientWidgetTheme, type CollectionMeta, CollectionsEndpoint, type ConditionalGetResult, type ConditionalStepConfig$1 as ConditionalStepConfig, type ContextErrorHandling, type ContextFallback, ContextTemplatesEndpoint, type Conversation, type ConversationListItem, type ConversationListParams, type ConversationMessage, type ConversationSource, ConversationsEndpoint, type ConversationsListResponse, type CreateApiKeyRequest, type CreateApiKeyRequestInput, type CreateApiKeyRequestResponse, type CreateClientTokenRequest, type CreateClientTokenResponse, type CreateCollectionRequest, type CreateConversationRequest, type CreateEvalSuiteInput, type CreateFlowRequest, type CreateModelConfigRequest, type CreatePromptData, type CreatePromptRequest, type CreateProviderKeyRequest, type CreateRecordRequest, type CreateScheduleRequest, type CreateSecretRequest, type CreateToolRequest, type CurrentBilledSpendResponse, type CurrentBilledSpendSource, type CustomMCPServer, type CustomMCPServerAuth, type CustomToolConfig, DEFAULT_MAX_DETACHED_RECONNECTS, DEFAULT_RECOVERY_AFTER_EMPTY_SESSIONS, DEFAULT_STALL_STOP_AFTER, type DecomposeCriteriaResult, type DefineAgentInput, type DefineEvalCaseInput, type DefineEvalInput, type DefineFlowInput, type DefineProductInput, type DefineSkillInput, type DefineSurfaceInput, type DefineToolInput, type DeployCfSandboxRequest, type DeployCfSandboxResponse, type DeploySandboxRequest, type DeploySandboxResponse, type DetachedReattach, type DetachedReconnectOptions, type DiscoveredModel, type DispatchAgentInput, type DispatchApprovalContinuationResponse, type DispatchApproveRequest, type DispatchApproveResponse, type DispatchClient, type DispatchContinuationRequest, type DispatchContinuationResponse, type DispatchDetachedApprovalResponse, DispatchEndpoint, type DispatchEnvironment, type DispatchEvent, type DispatchFlowInput, type DispatchMessageContent, type DispatchOptions$1 as DispatchOptions, type DispatchRequest, type DispatchResponse, type DispatchResumeRequest, type DispatchResumeResponse, type EndUserUsageQuery, type EndUserUsageResponse, type EnsureAgentConverged, type EnsureAgentOptions, type EnsureAgentPlan, type EnsureAgentResult, type EnsureEvalResult, type EnsureFlowConverged, type EnsureFlowOptions, type EnsureFlowPlan, type EnsureFlowResult, type EnsureFpoOptions, type EnsureFpoResult, type EnsureProductConverged, type EnsureProductOptions, type EnsureProductPlan, type EnsureProductResult, type EnsureSkillConverged, type EnsureSkillOptions, type EnsureSkillPlan, type EnsureSkillResult, type EnsureSurfaceConverged, type EnsureSurfaceOptions, type EnsureSurfacePlan, type EnsureSurfaceResult, type EnsureToolConverged, type EnsureToolOptions, type EnsureToolPlan, type EnsureToolResult, type ErrorHandlingMode, EvalBuilder, type EvalCaseDefinition, type EvalCaseInput, type EvalCaseProposal, type EvalCaseProposalAccepted, type EvalCaseProposalListResult, type EvalCasesGenerated, type EvalClient, type EvalDefinition, EvalEndpoint, type EvalListParams, type EvalMessage, type EvalOptions, type EvalOverrideValues, type EvalProposalSource, type EvalProposalStatus, type EvalProposedCase, type EvalPullResult, type EvalRecord, type EvalRequest, type EvalResult, type EvalRunCaseScores, type EvalRunConfig, type EvalRunScores, EvalRunner, type EvalStatus, type EvalSuiteCase, type EvalSuiteCaseInput, type EvalSuiteCoverage, type EvalSuiteDetail, type EvalSuiteLatestRun, type EvalSuiteListResult, type EvalSuiteRunQueued, type EvalSuiteRunResult, type EvalSuiteSummary, EvalSuitesNamespace, type EvalTarget, EvalsNamespace, type ExecuteToolRequest, type ExecuteToolResponse, type ExecutionStreamEvent, ExecutionsEndpoint, ExecutionsNamespace, type ExternalAgentContext, type ExternalToolConfig, type FallbackFailEvent, type FallbackStartEvent, type FallbackSuccessEvent, type FallbackTrigger, type FallbackTriggerType, type FallbacksExhaustedEvent, type FallbacksInitiatedEvent, type FetchUrlStepConfig$1 as FetchUrlStepConfig, type FieldFormat, type FileContentPart, type Flow, type FlowAttachment, FlowBuilder, type FlowCompleteEvent, type FlowConfig$1 as FlowConfig, type FlowDefinition, type FlowDefinitionStep, FlowDriftError, FlowEnsureConflictError, type FlowErrorEvent, type FlowFallback, type FlowInlineEvalInput, type FlowListItem, type FlowPausedEvent, type FlowPullResult, FlowResult, type FlowStartEvent, type FlowStep, type FlowStepDefinition, type FlowStepType, FlowStepsEndpoint, type FlowStreamEvent, type FlowSummary, type FlowToolConfig, type FlowValidationClient, type FlowValidationIssue, type FlowValidationResult, type FlowVersionDetail, type FlowVersionListItem, type FlowVersionPublishResponse, FlowVersionsEndpoint, type FlowVersionsListResponse, FlowsEndpoint, FlowsNamespace, type FpoEntityOutcome, type FpoInput, type GenerateEmbeddingStepConfig$1 as GenerateEmbeddingStepConfig, type GenerateEvalCasesInput, type GeneratedRuntimeToolGateDecision, type GeneratedRuntimeToolGateOptions, type GetApiKeyRequestResponse, type GetRecordStepConfig$1 as GetRecordStepConfig, type Gradeable, type GraderConfig, type GraderOutcome, type GraderSeverity, type HumanVerdict, type ImageContentPart, type InferCollectionSchemaResponse, type Integration, type IntegrationTool, IntegrationsEndpoint, type IntegrationsListResponse, type JSONSchema, type JsonArray, type JsonObject, type JsonPrimitive, type JsonValue, LEDGER_ARTIFACT_LINE_PREFIX, type ListCollectionsResponse, type ListConversationsResponse, type ListParams, type ListRecordsStepConfig$1 as ListRecordsStepConfig, type LocalToolConfig, type LocalToolDefinition, type LocalToolExecutionCompleteEvent, type LocalToolExecutionLoopSnapshotSlice, type LocalToolExecutionStartEvent, type LogEntry, type LogQueryParams, type LogQueryResponse, type LogQueryResult, type LogStatsParams, type LogStatsResponse, type LogStatsResult, LogsEndpoint, type LoopStepConfig$1 as LoopStepConfig, type Message$1 as Message, type MessageContent, type MessageFallback, type Metadata, type ModelConfig, ModelConfigsEndpoint, type ModelFallback, type ModelOverride, type ModelUsageDetail, type ModelUsageQueryParams, type ModelUsageResponse, type ModelUsageSummary, type ModelUsageTimeSeries, type PaginationResponse, type PersistedGraderOutcome, type ProductDefinition, ProductDriftError, ProductEnsureConflictError, type ProductPullResult, ProductsNamespace, type Prompt$1 as Prompt, type PromptErrorHandling, type PromptFallback, type PromptListParams, type PromptStepConfig$1 as PromptStepConfig, PromptsEndpoint, PromptsNamespace, type ProviderApiKey, type ProviderKeyModel, ProviderKeysEndpoint, type PullFpoResult, RUNTYPE_CLIENT_KIND, type ReasoningConfig, type ReasoningContentPart, type ReasoningValue, type RecordCollection, type RecordCollectionWithHistory, type RecordCollections, type RecordConfig$1 as RecordConfig, type RecordCostAggregation, type RecordCostModelBreakdown, type RecordFilter, type RecordFilterCondition, type RecordFilterGroup, type RecordFilterOperator, type RecordListItem, type RecordListParams, type RecordStepResult, type RecordStepResultsParams, type RecordStepResultsResponse, type RecordWriteResponse, RecordsEndpoint, type RetrieveRecordStepConfig$1 as RetrieveRecordStepConfig, type RetryFallback, type RunEvalCaseResult, type RunEvalInput, type RunEvalResult, type RunTaskContextBudgetBreakdown, type RunTaskContextCompactionEvent, type RunTaskContextCompactionStrategy, type RunTaskContextNoticeEvent, type RunTaskContextSummaryEntry, type RunTaskContinuation, type RunTaskOffloadRecorder, type RunTaskOnContextCompaction, type RunTaskOnContextNotice, type RunTaskOnSession, type RunTaskOptions, type RunTaskResult, type RunTaskResumeState, type RunTaskSessionSummary, type RunTaskState, type RunTaskStateSlice, type RunTaskStatus, type RunTaskToolTraceSlice, type RuntimeCustomToolConfig, type RuntimeExternalToolConfig, type RuntimeFlowToolConfig, type RuntimeLocalToolConfig, type RuntimeSubagentToolConfig, type RuntimeTool, type RuntimeToolConfig, Runtype, type AgentSkillBinding as RuntypeAgentSkillBinding, RuntypeApiError, RuntypeClient, type ConditionalStepConfig as RuntypeConditionalStepConfig, type RuntypeConfig, type FetchUrlStepConfig as RuntypeFetchUrlStepConfig, RuntypeFlowBuilder, type FlowConfig as RuntypeFlowConfig, type GenerateEmbeddingStepConfig as RuntypeGenerateEmbeddingStepConfig, type GetRecordStepConfig as RuntypeGetRecordStepConfig, type ListRecordsStepConfig as RuntypeListRecordsStepConfig, type LoopStepConfig as RuntypeLoopStepConfig, type Message as RuntypeMessage, type ModelOverride$1 as RuntypeModelOverride, type Prompt as RuntypePrompt, type PromptStepConfig as RuntypePromptStepConfig, type RuntypeRecord, type RecordConfig as RuntypeRecordConfig, type RetrieveRecordStepConfig as RuntypeRetrieveRecordStepConfig, type SearchStepConfig as RuntypeSearchStepConfig, type SendEmailStepConfig as RuntypeSendEmailStepConfig, type SendEventStepConfig as RuntypeSendEventStepConfig, type SendStreamStepConfig as RuntypeSendStreamStepConfig, type SetVariableStepConfig as RuntypeSetVariableStepConfig, type Skill as RuntypeSkill, type SkillCapabilities as RuntypeSkillCapabilities, type SkillFrontmatter as RuntypeSkillFrontmatter, type SkillManifest as RuntypeSkillManifest, type SkillProposal as RuntypeSkillProposal, type SkillRuntypeExtensions as RuntypeSkillRuntypeExtensions, type SkillVersion as RuntypeSkillVersion, type TransformDataStepConfig as RuntypeTransformDataStepConfig, type UpsertFlowConfig as RuntypeUpsertFlowConfig, type UpsertRecordStepConfig as RuntypeUpsertRecordStepConfig, type VectorSearchStepConfig as RuntypeVectorSearchStepConfig, type WaitUntilStepConfig as RuntypeWaitUntilStepConfig, SDK_USER_AGENT, SDK_VERSION, STEP_FIELD_REGISTRY, STEP_TYPE_TO_METHOD, type Schedule, type ScheduleExecutionOptions, type ScheduleListParams, type ScheduleMessage, type ScheduleMessageSet, type ScheduleMessages, type ScheduleMutationResponse, type ScheduleRun, type ScheduleRunNowResponse, type ScheduleStatusResponse, type ScheduleTarget, type ScheduleTrigger, SchedulesEndpoint, type SearchStepConfig$1 as SearchStepConfig, type Secret, type SecretCheckResponse, type SecretDeleteResponse, type SecretSetupUrlRequest, type SecretSetupUrlResponse, SecretsEndpoint, type SelectOrganizationProviderCredentialRequest, type SelectOrganizationProviderCredentialResponse, type SendEmailStepConfig$1 as SendEmailStepConfig, type SendEventStepConfig$1 as SendEventStepConfig, type SendStreamStepConfig$1 as SendStreamStepConfig, type SetVariableStepConfig$1 as SetVariableStepConfig, type SkillDefinition, SkillDriftError, SkillEnsureConflictError, type SkillListPage, type SkillListPagination, type SkillListParams, type SkillManifestInput, type SkillMarkdownInput, type SkillOrigin, type SkillProposalStatus, SkillProposalsNamespace, type SkillPullResult, type SkillStatus, type SkillTrustLevel, type SkillVersionStatus, type SkillWithVersion, type SkillWriteInput, SkillsNamespace, type SlackAppStatusResponse, type SlackInstallRequest, type SlackManifestRequest, type SlackManifestResponse, type SlackOAuthStartRequest, type SlackOAuthStartResponse, type StepCompleteEvent, type StepDeltaEvent, type StepFallback, type StepFieldMeta, type StepStartEvent, type StepWaitingLocalEvent, type StreamCallbacks, type StreamConsumeOptions, type StreamEvent, type StreamEventOf, type SubagentToolConfig, type Surface, type SurfaceDefinition, type SurfaceDefinitionStatus, type SurfaceDefinitionType, SurfaceDriftError, SurfaceEnsureConflictError, type SurfaceListParams, type SurfacePullResult, SurfacesEndpoint, SurfacesNamespace, type TextContentPart, type Tool, type ToolApprovalGrant, ToolApprovalGrantsEndpoint, type ToolConfig, type ToolDefinition, type ToolDefinitionType, ToolDriftError, ToolEnsureConflictError, type ToolPullResult, type ToolWithValidation, type ToolsConfig, ToolsEndpoint, ToolsNamespace, type TransformDataStepConfig$1 as TransformDataStepConfig, type TypedCreateRecordRequest, type TypedRecordListItem, type TypedRecordWriteResponse, TypedRecordsScope, type TypedRuntypeRecord, UNIFIED_EVENTS_QUERY, type UpdateClientTokenRequest, type UpdateCollectionRequest, type UpdateCollectionResponse, type UpdateConversationRequest, type UpdateEvalCaseInput, type UpdateEvalSuiteInput, type UpdateFlowRequest, type UpdatePromptData, type UpdateProviderKeyRequest, type UpdateScheduleRequest, type UpdateSecretRequest, type UpdateToolRequest, type UpdatedFlow, type UpsertFlowConfig$1 as UpsertFlowConfig, type UpsertOptions, type UpsertRecordStepConfig$1 as UpsertRecordStepConfig, type UserProfile, UsersEndpoint, type ValidateExistingRecordsResponse, type VectorSearchStepConfig$1 as VectorSearchStepConfig, type VersionPublishOptions, type VersionType, type WaitUntilStepConfig$1 as WaitUntilStepConfig, type WorkflowCompileDeps, type WorkflowCompletionCriteriaConfig, type WorkflowConfig, type WorkflowConfigFactory, type WorkflowContext, type WorkflowDefinition, type WorkflowHookEntry, type WorkflowHookKind, type WorkflowHookRef, type WorkflowHookSignatures, type WorkflowMilestoneConfig, type WorkflowPhase, type WorkflowPolicyConfig, type WorkflowRecoveryConfig, type WorkflowSlot, type WorkflowStallPolicy, applyGeneratedRuntimeToolProposalToDispatchRequest, attachRuntimeToolsToDispatchRequest, buildAgentAdmissionHeaders, buildEmptySessionNudge, buildGeneratedRuntimeToolGateOutput, buildLedgerOffloadReference, buildObservationMaskMarker, buildPolicyGuidance, buildSendViewOffloadMarker, calledTool, compileWorkflowConfig, completed, computeAgentContentHash, computeEvalContentHash, computeFlowContentHash, computeFpoContentHash, computeProductContentHash, computeSkillContentHash, computeSurfaceContentHash, computeToolContentHash, contains, cost, createAgentEventTranslator, createClient, createExternalTool, createFlowEventTranslator, defaultWorkflow, defaultWorkflowConfig, defineAgent, defineEval, defineFlow, defineFpo, definePlaybook, defineProduct, defineSkill, defineSurface, defineTool, deployWorkflow, ensureDefaultWorkflowHooks, ensureEval, ensureFpo, evaluateGeneratedRuntimeToolProposal, extractDeclaredToolResultChars, gameWorkflow, getDefaultPlanPath, getLikelySupportingCandidatePaths, interpolateWorkflowTemplate, isCatalogClientToolRef, isDiscoveryToolName, isMarathonArtifactPath, isPreservationSensitiveTask, isUnifiedEventType, isWorkflowHookRef, jsonField, judge, judges, latency, length, listWorkflowHooks, matchesExpected, maxToolCalls, noError, normalizeAgentDefinition, normalizeCandidatePath, normalizeFpoDefinition, normalizeProductDefinition, normalizeSkillDefinition, normalizeSurfaceDefinition, normalizeToolDefinition, notCalledTool, notContains, parseFinalBuffer, parseLedgerArtifactRelativePath, parseOffloadedOutputId, parseSSEChunk, processStream, pullEval, pullFpo, ranStep, regex, registerWorkflowHook, resolveStallStopAfter, resolveWorkflowHook, runEvalSuite, sanitizeTaskSlug, shouldInjectEmptySessionNudge, shouldRequestModelEscalation, stepOrder, streamEvents, toolOrder, unregisterWorkflowHook, usedNoTools, validJson, withDetachedReconnect, withUnifiedEvents };
+export { type AIGrader, type Agent, type AgentAdmissionOptions, type AgentApprovalCompleteEvent, type AgentApprovalStartEvent, type AgentCompleteEvent, type AgentDefinition, type AgentDefinitionConfig, AgentDriftError, type AgentElicitation, type AgentElicitationRequest, AgentEnsureConflictError, type AgentErrorEvent, type AgentEvent, type AgentEventType, type AgentExecuteRequest, type AgentExecuteResponse, type AgentIterationCompleteEvent, type AgentIterationStartEvent, type AgentMediaEvent, type AgentMessage, type AgentPausedEvent, type AgentPingEvent, type AgentPullResult, type AgentReflectionEvent, type AgentRuntimeToolDefinition, type AgentStartEvent, type AgentStreamCallbacks, type AgentStreamEvent, type AgentSubagentConfig, type AgentToolCompleteEvent, type AgentToolDeltaEvent, type AgentToolInputCompleteEvent, type AgentToolInputDeltaEvent, type AgentToolStartEvent, type AgentTurnCompleteEvent, type AgentTurnDeltaEvent, type AgentTurnStartEvent, type AgentVersionDetail, type AgentVersionListItem, type AgentVersionPublishResponse, AgentVersionsEndpoint, type AgentVersionsListResponse, AgentsEndpoint, AgentsNamespace, AnalyticsEndpoint, type ApiClient, type ApiKey, type ApiKeyRequest, type ApiKeyRequestDelivery, type ApiKeyRequestEnvironment, type ApiKeyRequestHandoff, type ApiKeyRequestListParams, type ApiKeyRequestRequester, type ApiKeyRequestStatus, ApiKeyRequestsEndpoint, ApiKeysEndpoint, type ApiResponse, type ApplyGeneratedProposalOptions, type ApplyGeneratedProposalResult, type AssetReferenceContentPart, type AsyncExecutionHandle, type AsyncExecutionStatus, type AttachRuntimeToolsOptions, type BaseAgentEvent, BatchBuilder, type BatchClient, type BatchListParams, type BatchOptions, type BatchRequest, type BatchResult, type BatchScheduleConfig, type BatchStatus, BatchesNamespace, BillingEndpoint, type BillingSpendAnalyticsParams, type BindSkillInput, type BuiltInGraderId, type BuiltInTool, type BulkEditCondition, type BulkEditRequest, type BulkEditResponse, type BulkEditResult, type CanonicalDispatchMessageContent, type CanonicalDispatchRequest, type CaseExpected, type CatalogClientToolRef, ChatEndpoint, type CheckGrader, type ClaimApiKeyRequestInput, type ClaimApiKeyRequestResponse, type ClaudeManagedEvalOverrideValues, ClientBatchBuilder, type ClientConfig, type ClientConversation, ClientEvalBuilder, ClientFlowBuilder, type ClientToken, type ClientTokenConfig, type ClientTokenEnvironment, type ClientTokenVersionPin, ClientTokensEndpoint, type ClientToolDefinition, type ClientToolEntry, type ClientWidgetTheme, type CollectionMeta, CollectionsEndpoint, type ConditionalGetResult, type ConditionalStepConfig$1 as ConditionalStepConfig, type ContextErrorHandling, type ContextFallback, ContextTemplatesEndpoint, type Conversation, type ConversationListItem, type ConversationListParams, type ConversationMessage, type ConversationSource, ConversationsEndpoint, type ConversationsListResponse, type CreateApiKeyRequest, type CreateApiKeyRequestInput, type CreateApiKeyRequestResponse, type CreateClientTokenRequest, type CreateClientTokenResponse, type CreateCollectionRequest, type CreateConversationRequest, type CreateEvalSuiteInput, type CreateFlowRequest, type CreateModelConfigRequest, type CreatePromptData, type CreatePromptRequest, type CreateProviderKeyRequest, type CreateRecordRequest, type CreateScheduleRequest, type CreateSecretRequest, type CreateToolRequest, type CurrentBilledSpendResponse, type CurrentBilledSpendSource, type CustomMCPServer, type CustomMCPServerAuth, type CustomToolConfig, DEFAULT_MAX_DETACHED_RECONNECTS, DEFAULT_RECOVERY_AFTER_EMPTY_SESSIONS, DEFAULT_STALL_STOP_AFTER, type DecomposeCriteriaResult, type DefineAgentInput, type DefineEvalCaseInput, type DefineEvalInput, type DefineFlowInput, type DefineProductInput, type DefineSkillInput, type DefineSurfaceInput, type DefineToolInput, type DeployCfSandboxRequest, type DeployCfSandboxResponse, type DeploySandboxRequest, type DeploySandboxResponse, type DetachedReattach, type DetachedReconnectOptions, type DiscoveredModel, type DispatchAgentInput, type DispatchApprovalContinuationResponse, type DispatchApproveRequest, type DispatchApproveResponse, type DispatchClient, type DispatchContinuationRequest, type DispatchContinuationResponse, type DispatchDetachedApprovalResponse, type DispatchDetachedToolOutputResponse, DispatchEndpoint, type DispatchEnvironment, type DispatchEvent, type DispatchFlowInput, type DispatchMessageContent, type DispatchOptions$1 as DispatchOptions, type DispatchRequest, type DispatchResponse, type DispatchResumeJsonResponse, type DispatchResumeRequest, type DispatchResumeResponse, type EndUserUsageQuery, type EndUserUsageResponse, type EnsureAgentConverged, type EnsureAgentOptions, type EnsureAgentPlan, type EnsureAgentResult, type EnsureEvalResult, type EnsureFlowConverged, type EnsureFlowOptions, type EnsureFlowPlan, type EnsureFlowResult, type EnsureFpoOptions, type EnsureFpoResult, type EnsureProductConverged, type EnsureProductOptions, type EnsureProductPlan, type EnsureProductResult, type EnsureSkillConverged, type EnsureSkillOptions, type EnsureSkillPlan, type EnsureSkillResult, type EnsureSurfaceConverged, type EnsureSurfaceOptions, type EnsureSurfacePlan, type EnsureSurfaceResult, type EnsureToolConverged, type EnsureToolOptions, type EnsureToolPlan, type EnsureToolResult, type ErrorHandlingMode, EvalBuilder, type EvalCaseDefinition, type EvalCaseInput, type EvalCaseProposal, type EvalCaseProposalAccepted, type EvalCaseProposalListResult, type EvalCasesGenerated, type EvalClient, type EvalDefinition, EvalEndpoint, type EvalListParams, type EvalMessage, type EvalOptions, type EvalOverrideValues, type EvalProposalSource, type EvalProposalStatus, type EvalProposedCase, type EvalPullResult, type EvalRecord, type EvalRequest, type EvalResult, type EvalRunCaseScores, type EvalRunConfig, type EvalRunScores, EvalRunner, type EvalStatus, type EvalSuiteCase, type EvalSuiteCaseInput, type EvalSuiteCoverage, type EvalSuiteDetail, type EvalSuiteLatestRun, type EvalSuiteListResult, type EvalSuiteRunQueued, type EvalSuiteRunResult, type EvalSuiteSummary, EvalSuitesNamespace, type EvalTarget, EvalsNamespace, type ExecuteToolRequest, type ExecuteToolResponse, type ExecutionCounts, type ExecutionStreamEvent, ExecutionsEndpoint, ExecutionsNamespace, type ExternalAgentContext, type ExternalToolConfig, type FallbackFailEvent, type FallbackStartEvent, type FallbackSuccessEvent, type FallbackTrigger, type FallbackTriggerType, type FallbacksExhaustedEvent, type FallbacksInitiatedEvent, type FetchUrlStepConfig$1 as FetchUrlStepConfig, type FieldFormat, type FileContentPart, type Flow, type FlowAttachment, FlowBuilder, type FlowCompleteEvent, type FlowConfig$1 as FlowConfig, type FlowDefinition, type FlowDefinitionStep, FlowDriftError, FlowEnsureConflictError, type FlowErrorEvent, type FlowFallback, type FlowInlineEvalInput, type FlowListItem, type FlowPausedEvent, type FlowPullResult, FlowResult, type FlowStartEvent, type FlowStep, type FlowStepDefinition, type FlowStepType, FlowStepsEndpoint, type FlowStreamEvent, type FlowSummary, type FlowToolConfig, type FlowValidationClient, type FlowValidationIssue, type FlowValidationResult, type FlowVersionDetail, type FlowVersionListItem, type FlowVersionPublishResponse, FlowVersionsEndpoint, type FlowVersionsListResponse, FlowsEndpoint, FlowsNamespace, type FpoEntityOutcome, type FpoInput, type GenerateEmbeddingStepConfig$1 as GenerateEmbeddingStepConfig, type GenerateEvalCasesInput, type GeneratedRuntimeToolGateDecision, type GeneratedRuntimeToolGateOptions, type GetApiKeyRequestResponse, type GetRecordStepConfig$1 as GetRecordStepConfig, type Gradeable, type GraderConfig, type GraderOutcome, type GraderSeverity, type HealthInsight, type HumanVerdict, type ImageContentPart, type InferCollectionSchemaResponse, type Integration, type IntegrationTool, IntegrationsEndpoint, type IntegrationsListResponse, type JSONSchema, type JsonArray, type JsonObject, type JsonPrimitive, type JsonValue, LEDGER_ARTIFACT_LINE_PREFIX, type ListCollectionsResponse, type ListConversationsResponse, type ListParams, type ListRecordsStepConfig$1 as ListRecordsStepConfig, type LocalToolConfig, type LocalToolDefinition, type LocalToolExecutionCompleteEvent, type LocalToolExecutionLoopSnapshotSlice, type LocalToolExecutionStartEvent, type LogEntry, type LogQueryParams, type LogQueryResponse, type LogQueryResult, type LogStatsParams, type LogStatsResponse, type LogStatsResult, LogsEndpoint, type LoopStepConfig$1 as LoopStepConfig, type Message$1 as Message, type MessageContent, type MessageFallback, type Metadata, type MetricDelta, type ModelConfig, ModelConfigsEndpoint, type ModelFallback, type ModelOverride, type ModelUsageDetail, type ModelUsageQueryParams, type ModelUsageResponse, type ModelUsageSummary, type ModelUsageTimeSeries, type PaginationResponse, type PersistedGraderOutcome, type ProductDefinition, ProductDriftError, ProductEnsureConflictError, type ProductPullResult, type ProductionHealthQuery, type ProductionHealthResponse, ProductsNamespace, type Prompt$1 as Prompt, type PromptErrorHandling, type PromptFallback, type PromptListParams, type PromptStepConfig$1 as PromptStepConfig, PromptsEndpoint, PromptsNamespace, type ProviderApiKey, type ProviderKeyModel, ProviderKeysEndpoint, type PullFpoResult, RUNTYPE_CLIENT_KIND, type ReasoningConfig, type ReasoningContentPart, type ReasoningValue, type RecordCollection, type RecordCollectionWithHistory, type RecordCollections, type RecordConfig$1 as RecordConfig, type RecordCostAggregation, type RecordCostModelBreakdown, type RecordFilter, type RecordFilterCondition, type RecordFilterGroup, type RecordFilterOperator, type RecordListItem, type RecordListParams, type RecordStepResult, type RecordStepResultsParams, type RecordStepResultsResponse, type RecordWriteResponse, RecordsEndpoint, type RetrieveRecordStepConfig$1 as RetrieveRecordStepConfig, type RetryFallback, type RunEvalCaseResult, type RunEvalInput, type RunEvalResult, type RunTaskContextBudgetBreakdown, type RunTaskContextCompactionEvent, type RunTaskContextCompactionStrategy, type RunTaskContextNoticeEvent, type RunTaskContextSummaryEntry, type RunTaskContinuation, type RunTaskOffloadRecorder, type RunTaskOnContextCompaction, type RunTaskOnContextNotice, type RunTaskOnSession, type RunTaskOptions, type RunTaskResult, type RunTaskResumeState, type RunTaskSessionSummary, type RunTaskState, type RunTaskStateSlice, type RunTaskStatus, type RunTaskToolTraceSlice, type RuntimeCustomToolConfig, type RuntimeExternalToolConfig, type RuntimeFlowToolConfig, type RuntimeLocalToolConfig, type RuntimeSubagentToolConfig, type RuntimeTool, type RuntimeToolConfig, Runtype, type AgentSkillBinding as RuntypeAgentSkillBinding, RuntypeApiError, RuntypeClient, type ConditionalStepConfig as RuntypeConditionalStepConfig, type RuntypeConfig, type FetchUrlStepConfig as RuntypeFetchUrlStepConfig, RuntypeFlowBuilder, type FlowConfig as RuntypeFlowConfig, type GenerateEmbeddingStepConfig as RuntypeGenerateEmbeddingStepConfig, type GetRecordStepConfig as RuntypeGetRecordStepConfig, type ListRecordsStepConfig as RuntypeListRecordsStepConfig, type LoopStepConfig as RuntypeLoopStepConfig, type Message as RuntypeMessage, type ModelOverride$1 as RuntypeModelOverride, type Prompt as RuntypePrompt, type PromptStepConfig as RuntypePromptStepConfig, type RuntypeRecord, type RecordConfig as RuntypeRecordConfig, type RetrieveRecordStepConfig as RuntypeRetrieveRecordStepConfig, type SearchStepConfig as RuntypeSearchStepConfig, type SendEmailStepConfig as RuntypeSendEmailStepConfig, type SendEventStepConfig as RuntypeSendEventStepConfig, type SendStreamStepConfig as RuntypeSendStreamStepConfig, type SetVariableStepConfig as RuntypeSetVariableStepConfig, type Skill as RuntypeSkill, type SkillCapabilities as RuntypeSkillCapabilities, type SkillFrontmatter as RuntypeSkillFrontmatter, type SkillManifest as RuntypeSkillManifest, type SkillProposal as RuntypeSkillProposal, type SkillRuntypeExtensions as RuntypeSkillRuntypeExtensions, type SkillVersion as RuntypeSkillVersion, type TransformDataStepConfig as RuntypeTransformDataStepConfig, type UpsertFlowConfig as RuntypeUpsertFlowConfig, type UpsertRecordStepConfig as RuntypeUpsertRecordStepConfig, type VectorSearchStepConfig as RuntypeVectorSearchStepConfig, type WaitUntilStepConfig as RuntypeWaitUntilStepConfig, SDK_USER_AGENT, SDK_VERSION, STEP_FIELD_REGISTRY, STEP_TYPE_TO_METHOD, type SandboxDeployEffectivePolicy, type SandboxDeployRetention, type SandboxDeploySleepPolicy, type Schedule, type ScheduleExecutionOptions, type ScheduleListParams, type ScheduleMessage, type ScheduleMessageSet, type ScheduleMessages, type ScheduleMutationResponse, type ScheduleRun, type ScheduleRunNowResponse, type ScheduleStatusResponse, type ScheduleTarget, type ScheduleTrigger, SchedulesEndpoint, type SearchStepConfig$1 as SearchStepConfig, type Secret, type SecretCheckResponse, type SecretDeleteResponse, type SecretSetupUrlRequest, type SecretSetupUrlResponse, SecretsEndpoint, type SelectOrganizationProviderCredentialRequest, type SelectOrganizationProviderCredentialResponse, type SendEmailStepConfig$1 as SendEmailStepConfig, type SendEventStepConfig$1 as SendEventStepConfig, type SendStreamStepConfig$1 as SendStreamStepConfig, type SetVariableStepConfig$1 as SetVariableStepConfig, type SkillDefinition, SkillDriftError, SkillEnsureConflictError, type SkillListPage, type SkillListPagination, type SkillListParams, type SkillManifestInput, type SkillMarkdownInput, type SkillOrigin, type SkillProposalStatus, SkillProposalsNamespace, type SkillPullResult, type SkillStatus, type SkillTrustLevel, type SkillVersionStatus, type SkillWithVersion, type SkillWriteInput, SkillsNamespace, type SlackAppStatusResponse, type SlackInstallRequest, type SlackManifestRequest, type SlackManifestResponse, type SlackOAuthStartRequest, type SlackOAuthStartResponse, type StepCompleteEvent, type StepDeltaEvent, type StepFallback, type StepFieldMeta, type StepStartEvent, type StepWaitingLocalEvent, type StreamCallbacks, type StreamConsumeOptions, type StreamEvent, type StreamEventOf, type SubagentToolConfig, type Surface, type SurfaceDefinition, type SurfaceDefinitionStatus, type SurfaceDefinitionType, SurfaceDriftError, SurfaceEnsureConflictError, type SurfaceListParams, type SurfacePullResult, SurfacesEndpoint, SurfacesNamespace, type TextContentPart, type Tool, type ToolApprovalGrant, ToolApprovalGrantsEndpoint, type ToolConfig, type ToolDefinition, type ToolDefinitionType, ToolDriftError, ToolEnsureConflictError, type ToolPullResult, type ToolWithValidation, type ToolsConfig, ToolsEndpoint, ToolsNamespace, type TransformDataStepConfig$1 as TransformDataStepConfig, type TypedCreateRecordRequest, type TypedRecordListItem, type TypedRecordWriteResponse, TypedRecordsScope, type TypedRuntypeRecord, UNIFIED_EVENTS_QUERY, type UpdateClientTokenRequest, type UpdateCollectionRequest, type UpdateCollectionResponse, type UpdateConversationRequest, type UpdateEvalCaseInput, type UpdateEvalSuiteInput, type UpdateFlowRequest, type UpdatePromptData, type UpdateProviderKeyRequest, type UpdateScheduleRequest, type UpdateSecretRequest, type UpdateToolRequest, type UpdatedFlow, type UpsertFlowConfig$1 as UpsertFlowConfig, type UpsertOptions, type UpsertRecordStepConfig$1 as UpsertRecordStepConfig, type UserProfile, UsersEndpoint, type ValidateExistingRecordsResponse, type VectorSearchStepConfig$1 as VectorSearchStepConfig, type VersionPublishOptions, type VersionType, type WaitUntilStepConfig$1 as WaitUntilStepConfig, type WorkflowCompileDeps, type WorkflowCompletionCriteriaConfig, type WorkflowConfig, type WorkflowConfigFactory, type WorkflowContext, type WorkflowDefinition, type WorkflowHookEntry, type WorkflowHookKind, type WorkflowHookRef, type WorkflowHookSignatures, type WorkflowMilestoneConfig, type WorkflowPhase, type WorkflowPolicyConfig, type WorkflowRecoveryConfig, type WorkflowSlot, type WorkflowStallPolicy, applyGeneratedRuntimeToolProposalToDispatchRequest, attachRuntimeToolsToDispatchRequest, buildAgentAdmissionHeaders, buildEmptySessionNudge, buildExecutionEventsPath, buildGeneratedRuntimeToolGateOutput, buildLedgerOffloadReference, buildObservationMaskMarker, buildPolicyGuidance, buildSendViewOffloadMarker, calledTool, combineAbortSignals, compileWorkflowConfig, completed, computeAgentContentHash, computeEvalContentHash, computeFlowContentHash, computeFpoContentHash, computeProductContentHash, computeSkillContentHash, computeSurfaceContentHash, computeToolContentHash, contains, cost, createAgentEventTranslator, createClient, createExternalTool, createFlowEventTranslator, defaultWorkflow, defaultWorkflowConfig, defineAgent, defineEval, defineFlow, defineFpo, definePlaybook, defineProduct, defineSkill, defineSurface, defineTool, deployWorkflow, ensureDefaultWorkflowHooks, ensureEval, ensureFpo, evaluateGeneratedRuntimeToolProposal, extractDeclaredToolResultChars, gameWorkflow, getDefaultPlanPath, getLikelySupportingCandidatePaths, interpolateWorkflowTemplate, isCatalogClientToolRef, isDiscoveryToolName, isMarathonArtifactPath, isPreservationSensitiveTask, isUnifiedEventType, isWorkflowHookRef, jsonField, judge, judges, latency, length, listWorkflowHooks, matchesExpected, maxToolCalls, noError, normalizeAgentDefinition, normalizeCandidatePath, normalizeFpoDefinition, normalizeProductDefinition, normalizeSkillDefinition, normalizeSurfaceDefinition, normalizeToolDefinition, notCalledTool, notContains, parseFinalBuffer, parseLedgerArtifactRelativePath, parseOffloadedOutputId, parseSSEChunk, processStream, pullEval, pullFpo, ranStep, regex, registerWorkflowHook, resolveStallStopAfter, resolveWorkflowHook, runEvalSuite, sanitizeTaskSlug, shouldInjectEmptySessionNudge, shouldRequestModelEscalation, stepOrder, streamEvents, toolOrder, unregisterWorkflowHook, usedNoTools, validJson, withDetachedReconnect, withUnifiedEvents };