@runtypelabs/sdk 9.13.0 → 9.15.0

package/dist/index.d.cts

@@ -2711,6 +2711,8 @@ interface paths {
                             data: {
                                 alias: string;
                                 archivedAt: string | null;
+                                /** @description Names of the per-alias secret bindings in force at this pointer. Executions that resolve through it read these ahead of the organization secret of the same name. Names only: a binding value is never returned by any read. */
+                                bindingNames: string[];
                                 contentHash: string | null;
                                 createdAt: string;
                                 expiresAt: string | null;
@@ -2720,6 +2722,8 @@ interface paths {
                                 versionId: string;
                                 versionNumber: number | null;
                             }[];
+                            /** @description Whether an execution that names no version selector already resolves this agent through its `live` alias. False means a save still changes what runs, so moving production needs a publish; true means `live` is authoritative and moving production is an alias activation. */
+                            liveDefault: boolean;
                             nextCursor: string | null;
                         };
                     };
@@ -2813,6 +2817,8 @@ interface paths {
                         "application/json": {
                             alias: string;
                             archivedAt: string | null;
+                            /** @description Names of the per-alias secret bindings in force at this pointer. Executions that resolve through it read these ahead of the organization secret of the same name. Names only: a binding value is never returned by any read. */
+                            bindingNames: string[];
                             contentHash: string | null;
                             createdAt: string;
                             expiresAt: string | null;
@@ -2916,6 +2922,8 @@ interface paths {
                             /** @description How many preview aliases this agent has active after the write. Null for `live`, which is never counted. Read it beside `previewLimit` to see a per-pull-request pipeline filling up before an activation is refused with PREVIEW_ALIAS_LIMIT. */
                             activePreviewCount: number | null;
                             alias: string;
+                            /** @description Per-alias secret binding names in force after this activation. Names only, never values. */
+                            bindingNames: string[];
                             changed: boolean;
                             /** @description The active-preview ceiling this agent is counted against. Null for `live`. */
                             previewLimit: number | null;
@@ -3150,6 +3158,344 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/agents/{id}/aliases/{alias}/bindings": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Read the secret binding names of a release alias
+         * @description The per-alias secret binding NAMES this pointer carries. A binding value is write-only: no read surface returns it, and it never appears on a receipt, an audit envelope or a log line.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                    alias: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Binding names */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            alias: string;
+                            /** @description Present on a write: false when the set was already identical and nothing moved. */
+                            changed?: boolean;
+                            names: string[];
+                            /** @description The `bind` receipt this write appended, or null when it changed nothing. */
+                            receiptId?: string | null;
+                            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 Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+            };
+        };
+        /**
+         * Replace the secret bindings of a release alias
+         * @description Replace the complete set of `{{secret:NAME}}` values executions resolve when they reach this agent through this pointer. A binding wins over the organization secret of the same name, so one preview per pull request can aim its HTTP tools at that pull request environment while the version content stays byte-identical to what `live` runs. Whole-set replacement: a name you stop sending stops resolving. Values are encrypted at rest and never returned. Names beginning RUNTYPE_, PLATFORM_, CLOUDFLARE_ or INTERNAL_ are refused because they are platform-resolved before the alias plane. A change bumps the alias revision and appends a `bind` receipt; an identical set writes nothing. Requires the same deploy scope as activating this alias.
+         */
+        put: {
+            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": {
+                        /** @description The complete binding set, NAME to value. An empty object clears every binding. */
+                        bindings: {
+                            [key: string]: string;
+                        };
+                        /** @description Why this binding write happened, recorded on the receipt for humans. */
+                        reason?: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description Bindings replaced */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            alias: string;
+                            /** @description Present on a write: false when the set was already identical and nothing moved. */
+                            changed?: boolean;
+                            names: string[];
+                            /** @description The `bind` receipt this write appended, or null when it changed nothing. */
+                            receiptId?: string | null;
+                            revision: number;
+                        };
+                    };
+                };
+                /** @description Binding name or value rejected */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"] & {
+                            /** @enum {string} */
+                            code: "alias_binding_invalid";
+                        };
+                    };
+                };
+                /** @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 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 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;
+        /**
+         * Clear the secret bindings of a release alias
+         * @description Remove every per-alias secret binding from this pointer, so its executions fall back to the organization secrets. Equivalent to replacing the set with an empty object.
+         */
+        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 Bindings cleared */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            alias: string;
+                            /** @description Present on a write: false when the set was already identical and nothing moved. */
+                            changed?: boolean;
+                            names: string[];
+                            /** @description The `bind` receipt this write appended, or null when it changed nothing. */
+                            receiptId?: string | null;
+                            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 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 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"];
+                    };
+                };
+            };
+        };
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/agents/{id}/aliases/{alias}/rollback": {
         parameters: {
             query?: never;
@@ -3198,6 +3544,8 @@ interface paths {
                             /** @description How many preview aliases this agent has active after the write. Null for `live`, which is never counted. Read it beside `previewLimit` to see a per-pull-request pipeline filling up before an activation is refused with PREVIEW_ALIAS_LIMIT. */
                             activePreviewCount: number | null;
                             alias: string;
+                            /** @description Per-alias secret binding names in force after this activation. Names only, never values. */
+                            bindingNames: string[];
                             changed: boolean;
                             /** @description The active-preview ceiling this agent is counted against. Null for `live`. */
                             previewLimit: number | null;
@@ -3761,6 +4109,10 @@ interface paths {
                                 actorUserId: string | null;
                                 alias: string;
                                 aliasRevision: number;
+                                /** @description The per-alias secret binding NAMES in force when this receipt was written, as `{ names: [...] }`. Null when the pointer carried none. Values never appear here. */
+                                bindings: {
+                                    [key: string]: unknown;
+                                } | null;
                                 createdAt: string;
                                 dependencies: {
                                     [key: string]: unknown;
@@ -4197,6 +4549,7 @@ interface paths {
                             /** @enum {string} */
                             executionMode: "attached" | "detached";
                             expiresAt: string | null;
+                            externalObservedApprovals: components["schemas"]["ExternalObservedApprovals"];
                             finalOutput?: unknown;
                             id: string;
                             inputMessages?: unknown;
@@ -4701,7 +5054,7 @@ interface paths {
         };
         /**
          * Export agent for runtime
-         * @description Export a fully-resolved, self-contained agent definition that the @runtypelabs/runtime package can consume directly at boot. Capabilities, flows, and nested sub-agents are inlined recursively (up to 3 levels). MCP credential values and external-agent auth credentials are replaced with secret-name references.
+         * @description Export a fully-resolved, self-contained agent definition that the @runtypelabs/runtime package can consume directly at boot. Capabilities, flows, and nested sub-agents are inlined recursively (up to 3 levels). MCP credential values and external-agent auth credentials are replaced with secret-name references. Requires the `RUNTIME:EXPORT` scope and an Enterprise plan (the `byoc` entitlement); an unentitled account receives `403` with code `BYOC_PLAN_REQUIRED` in every environment.
          *
          *     The response carries `hostDependencies`: the runtime seams the exported artifact needs a host to wire before it can run everything it describes. A durable-class step (`wait-until` or `crawl`) anywhere in the agent's executable closure declares a `durable-pause-host` dependency; a detached-capable dynamic subagent pool or a detached inline subagent tool declares a `background-run-coordinator` dependency. The array is empty when nothing needs wiring.
          */
@@ -12650,6 +13003,11 @@ interface paths {
                             name?: string;
                             steps?: unknown[];
                         };
+                        /**
+                         * @description Where this turn's prior history comes from. "inline" (the default, and today's behavior) replays exactly the `messages` sent here. "stored" replays the transcript saved on the `conversationId` conversation, treats `messages` as the new delta, and appends both the delta and the settled assistant turn back onto it; it requires a saved `agent.agentId` and a `conversationId`, and is refused for a flow dispatch, an inline or `claude_managed` agent, `Prefer: respond-async`, a join, or a resume.
+                         * @enum {string}
+                         */
+                        history?: "inline" | "stored";
                         /** @description Customer-native auth proof for the Identity Exchange. When present and the surface has a matching integration, the verified tenant/end-user replace any body-asserted tenant/endUser (which are never trusted for web-embedded callers). When Identity Exchange admission is disabled for the caller, the proof is accepted but ignored and confers no trust. */
                         identityProof?: {
                             provider: string;
@@ -12658,7 +13016,7 @@ interface paths {
                         inputs?: {
                             [key: string]: unknown;
                         };
-                        /** @description Conversation history for this turn. A `system` message that is not the first message keeps its position on OpenAI-family models (so a per-turn system message sent last leaves the cached leading prompt untouched) and is folded into the leading system prompt on providers that require a single leading system turn. */
+                        /** @description Conversation history for this turn, or with `history: "stored"` only the new delta. A `system` message that is not the first message keeps its position on OpenAI-family models (so a per-turn system message sent last leaves the cached leading prompt untouched) and is folded into the leading system prompt on providers that require a single leading system turn. A `tool` message must carry `toolResults` answering an assistant `toolCalls` entry issued earlier in the array. */
                         messages?: {
                             content: string | ({
                                 text: string;
@@ -12684,7 +13042,30 @@ interface paths {
                                 type: "reasoning";
                             })[];
                             /** @enum {string} */
-                            role: "system" | "user" | "assistant";
+                            role: "system" | "user" | "assistant" | "tool";
+                            /** @description Assistant messages only. Every entry must be answered by the next tool message. */
+                            toolCalls?: {
+                                /** @default {} */
+                                args?: {
+                                    [key: string]: unknown;
+                                };
+                                providerOptions?: {
+                                    [key: string]: unknown;
+                                };
+                                toolCallId: string;
+                                toolName: string;
+                            }[];
+                            /** @description Tool messages only, and required on them. */
+                            toolResults?: {
+                                providerOptions?: {
+                                    [key: string]: unknown;
+                                };
+                                /** @description Whatever the tool returned. */
+                                result?: unknown;
+                                /** @description Must answer a toolCalls entry issued earlier. */
+                                toolCallId: string;
+                                toolName: string;
+                            }[];
                         }[];
                         /**
                          * @default {
@@ -13070,6 +13451,11 @@ interface paths {
                             name?: string;
                             steps?: unknown[];
                         };
+                        /**
+                         * @description Where this turn's prior history comes from. "inline" (the default, and today's behavior) replays exactly the `messages` sent here. "stored" replays the transcript saved on the `conversationId` conversation, treats `messages` as the new delta, and appends both the delta and the settled assistant turn back onto it; it requires a saved `agent.agentId` and a `conversationId`, and is refused for a flow dispatch, an inline or `claude_managed` agent, `Prefer: respond-async`, a join, or a resume.
+                         * @enum {string}
+                         */
+                        history?: "inline" | "stored";
                         /** @description Customer-native auth proof for the Identity Exchange. When present and the surface has a matching integration, the verified tenant/end-user replace any body-asserted tenant/endUser (which are never trusted for web-embedded callers). When Identity Exchange admission is disabled for the caller, the proof is accepted but ignored and confers no trust. */
                         identityProof?: {
                             provider: string;
@@ -13078,7 +13464,7 @@ interface paths {
                         inputs?: {
                             [key: string]: unknown;
                         };
-                        /** @description Conversation history for this turn. A `system` message that is not the first message keeps its position on OpenAI-family models (so a per-turn system message sent last leaves the cached leading prompt untouched) and is folded into the leading system prompt on providers that require a single leading system turn. */
+                        /** @description Conversation history for this turn, or with `history: "stored"` only the new delta. A `system` message that is not the first message keeps its position on OpenAI-family models (so a per-turn system message sent last leaves the cached leading prompt untouched) and is folded into the leading system prompt on providers that require a single leading system turn. A `tool` message must carry `toolResults` answering an assistant `toolCalls` entry issued earlier in the array. */
                         messages?: {
                             content: string | ({
                                 text: string;
@@ -13104,7 +13490,30 @@ interface paths {
                                 type: "reasoning";
                             })[];
                             /** @enum {string} */
-                            role: "system" | "user" | "assistant";
+                            role: "system" | "user" | "assistant" | "tool";
+                            /** @description Assistant messages only. Every entry must be answered by the next tool message. */
+                            toolCalls?: {
+                                /** @default {} */
+                                args?: {
+                                    [key: string]: unknown;
+                                };
+                                providerOptions?: {
+                                    [key: string]: unknown;
+                                };
+                                toolCallId: string;
+                                toolName: string;
+                            }[];
+                            /** @description Tool messages only, and required on them. */
+                            toolResults?: {
+                                providerOptions?: {
+                                    [key: string]: unknown;
+                                };
+                                /** @description Whatever the tool returned. */
+                                result?: unknown;
+                                /** @description Must answer a toolCalls entry issued earlier. */
+                                toolCallId: string;
+                                toolName: string;
+                            }[];
                         }[];
                         /**
                          * @default {
@@ -24634,7 +25043,7 @@ interface paths {
                     content: {
                         "application/json": {
                             data: {
-                                /** @description True when part of the window could not be read, so entries are missing: historical (R2 SQL) logs were unavailable, or the recent hot tier failed. Rows the hot tier evicted are served from R2 instead, so an eviction sets this only for the part too recent for R2 to have ingested. Absent on healthy responses. */
+                                /** @description True when part of the window could not be read, so entries may be missing. Evicted ordinary rows are recovered from R2 when old enough; receipt-backed recovery remains degraded when source time cannot prove ingestion. Absent on healthy responses. */
                                 degraded?: boolean;
                                 entries: {
                                     [key: string]: unknown;
@@ -24827,7 +25236,7 @@ interface paths {
                                 byType: {
                                     [key: string]: number;
                                 };
-                                /** @description True when part of the window could not be read, so counts are partial: historical (R2 SQL) counts were unavailable, or the recent hot tier failed. Rows the hot tier evicted are counted from R2 instead, so an eviction sets this only for the part too recent for R2 to have ingested. Absent on healthy responses, which are the only ones cached. */
+                                /** @description True when part of the window could not be read, so counts may be partial. Evicted ordinary rows are counted from R2 when old enough; receipt-backed recovery remains degraded when source time cannot prove ingestion. Absent on healthy responses, which are the only ones cached. */
                                 degraded?: boolean;
                                 histogram: {
                                     bucket: string;
@@ -27322,6 +27731,11 @@ interface paths {
                                 inputCostPer1kTokens: number;
                                 /** @default 4096 */
                                 maxOutputTokens?: number;
+                                /**
+                                 * @description Where a system message that follows a conversation turn lands on this endpoint. Omitted keeps it at its position (Mistral- and Gemma-family ids fold it into the leading prompt); "hoist" folds it for any endpoint whose chat template rejects a non-leading system role.
+                                 * @enum {string}
+                                 */
+                                midConversationSystemMessages?: "preserve" | "hoist";
                                 outputCostPer1kTokens: number;
                                 reasoning?: {
                                     defaultEffort?: string;
@@ -27988,6 +28402,11 @@ interface paths {
                                 inputCostPer1kTokens: number;
                                 /** @default 4096 */
                                 maxOutputTokens?: number;
+                                /**
+                                 * @description Where a system message that follows a conversation turn lands on this endpoint. Omitted keeps it at its position (Mistral- and Gemma-family ids fold it into the leading prompt); "hoist" folds it for any endpoint whose chat template rejects a non-leading system role.
+                                 * @enum {string}
+                                 */
+                                midConversationSystemMessages?: "preserve" | "hoist";
                                 outputCostPer1kTokens: number;
                                 reasoning?: {
                                     defaultEffort?: string;
@@ -36364,6 +36783,11 @@ interface paths {
                             id: string;
                             inputCostPer1kTokens?: number;
                             maxOutputTokens?: number;
+                            /**
+                             * @description Where a system message that follows a conversation turn lands on this endpoint. Omitted keeps it at its position (Mistral- and Gemma-family ids fold it into the leading prompt); "hoist" folds it for any endpoint whose chat template rejects a non-leading system role.
+                             * @enum {string}
+                             */
+                            midConversationSystemMessages?: "preserve" | "hoist";
                             outputCostPer1kTokens?: number;
                             reasoning?: {
                                 defaultEffort?: string;
@@ -44583,6 +45007,26 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/telemetry/ingest-health": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Inspect OTLP admission, queryability, and durable recovery debt
+         * @description Owner-scoped delivery receipts retained for 30 days. Lag is acceptance to the first positive query probe, not stream ACK latency or a production SLO guarantee. Idle is not proof of sink health. No transcripts or retained payloads are returned. Requires ANALYTICS:READ or AGENTS:READ; TELEMETRY:WRITE alone is append-only.
+         */
+        get: operations["getOtlpIngestHealth"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/tool-approval-grants": {
         parameters: {
             query?: never;
@@ -47403,6 +47847,10 @@ interface components {
         /** @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 The complete set of `{{secret:NAME}}` values executions resolve when they reach this agent through this pointer, ahead of the organization secret of the same name. One preview per pull request can aim its HTTP tools at that pull request environment while the version content stays byte-identical to what `live` runs. Whole-set replacement: a name you stop sending stops resolving, and an empty object clears them. Values are encrypted at rest and never returned; only their names appear on the deployment receipt. */
+            bindings?: {
+                [key: string]: string;
+            };
         };
         /** @description Present when the converge carried release or deploy and the activation was applied. */
         AgentEnsureDeployment: {
@@ -47915,7 +48363,7 @@ interface components {
         };
         /** @description Import provenance, stored as metadata.importSource. */
         ConversationSource: {
-            /** @description The conversation id in the source system. */
+            /** @description The conversation id in the source system. Re-creating with the same system and externalId returns the existing conversation with imported: false instead of a duplicate. */
             externalId?: string;
             /** Format: date-time */
             importedAt?: string;
@@ -47924,6 +48372,7 @@ interface components {
         };
         ConversationTranscriptMessage: {
             author?: components["schemas"]["ConversationMessageAuthor"];
+            /** @description Plain string, or an array of {type:"text"|"image"|"file"|"reasoning"|"asset_ref"} parts. */
             content: string | (({
                 text: string;
                 /** @enum {string} */
@@ -47967,12 +48416,14 @@ interface components {
             })[];
             /** @description ISO 8601 when Runtype mints it; any string is accepted on import. */
             createdAt?: string;
+            /** @description Minted when omitted. Use the source system id to make an import resumable. */
             id?: string;
             metadata?: {
                 [key: string]: unknown;
             };
             /** @enum {string} */
             role: "system" | "user" | "assistant" | "tool";
+            /** @description Assistant messages only. Every entry must be answered by the next tool message. */
             toolCalls?: {
                 /** @default {} */
                 args: {
@@ -47984,11 +48435,14 @@ interface components {
                 toolCallId: string;
                 toolName: string;
             }[];
+            /** @description Tool messages only, and required on them. */
             toolResults?: {
                 providerOptions?: {
                     [key: string]: unknown;
                 };
+                /** @description Whatever the tool returned. */
                 result?: unknown;
+                /** @description Must answer a toolCalls entry issued earlier. */
                 toolCallId: string;
                 toolName: string;
             }[];
@@ -48607,6 +49061,12 @@ interface components {
             /** @enum {string} */
             targetType: "flow" | "agent";
             updatedAt: string;
+            /** @description Non-blocking findings about this suite. `AGENT_NOT_DEPLOYED` means the target agent has no runnable `live` version, so a run that names no version selector refuses once the live default is on for the organization. */
+            warnings?: {
+                agentId?: string;
+                code: string;
+                message: string;
+            }[];
         };
         EvalSuiteLatestRun: {
             completedAt: string | null;
@@ -48681,6 +49141,12 @@ interface components {
             /** @enum {string} */
             targetType: "flow" | "agent";
             updatedAt: string;
+            /** @description Non-blocking findings about this suite. `AGENT_NOT_DEPLOYED` means the target agent has no runnable `live` version, so a run that names no version selector refuses once the live default is on for the organization. */
+            warnings?: {
+                agentId?: string;
+                code: string;
+                message: string;
+            }[];
         };
         ExecutionStreamEvent: {
             agentId?: string;
@@ -49259,6 +49725,41 @@ interface components {
             type: "custom";
             value?: unknown;
         };
+        /** @description Read-only approval observations within producer traces. Null means history unavailable; an empty lifecycle list means none observed. Structural history survives ingest-fact expiry and is retained when verbose logging is off. */
+        ExternalObservedApprovals: {
+            /** @enum {string} */
+            availability: "observed";
+            lifecycles: {
+                /** @enum {string} */
+                decision: "requested" | "approved" | "denied" | "conflicted";
+                key: string;
+                observations: {
+                    key: string;
+                    /** Format: date-time */
+                    observedAt?: string;
+                    source: {
+                        /** @enum {string} */
+                        attribute: "cloudflare.agents.tool.approval.state";
+                        /** @enum {string} */
+                        kind: "cloudflare-agents";
+                        spanId: string;
+                        traceId: string;
+                    };
+                    /** @enum {string} */
+                    state: "requested" | "approved" | "denied";
+                }[];
+                rawStates: ("requested" | "approved" | "denied")[];
+                /** @enum {boolean} */
+                sourceConflict?: true;
+                toolCallId: string;
+                toolName?: string;
+                toolType?: string;
+            }[];
+            /** @enum {boolean} */
+            truncated?: true;
+            /** @enum {number} */
+            version: 1;
+        } | null;
         FlowEnsureConflict: {
             /** @enum {string} */
             code: "external_modification" | "remote_changed";
@@ -49932,6 +50433,135 @@ interface components {
     headers: never;
     pathItems: never;
 }
+interface operations {
+    getOtlpIngestHealth: {
+        parameters: {
+            query?: {
+                traceId?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Admission and observed delivery health */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        admission: {
+                            activeRequests: number;
+                            availableBytes: number;
+                            availableRecords: number;
+                            maximumConcurrentRequests: number;
+                        };
+                        errors: {
+                            code: string;
+                            records: number;
+                        }[];
+                        lastAcceptedAt: string | null;
+                        observedAt: string;
+                        receiptHistoryDays: number;
+                        /** @enum {string} */
+                        status: "idle" | "observing" | "degraded" | "queryable";
+                        tiers: {
+                            canonical: {
+                                confirmed: number;
+                                maximumConfirmedLagMs: number | null;
+                                oldestPendingAgeMs: number | null;
+                                repairs: number;
+                                waiting: number;
+                            };
+                            hot: {
+                                confirmed: number;
+                                maximumConfirmedLagMs: number | null;
+                                oldestPendingAgeMs: number | null;
+                                repairs: number;
+                                waiting: number;
+                            };
+                            raw: {
+                                confirmed: number;
+                                maximumConfirmedLagMs: number | null;
+                                oldestPendingAgeMs: number | null;
+                                repairs: number;
+                                waiting: number;
+                            };
+                        };
+                        totals: {
+                            accepted: number;
+                            claimConflicts: number;
+                            complete: number;
+                            deleted: number;
+                            exhaustedAttempts: number;
+                            expired: number;
+                            pending: number;
+                            pendingBytes: number;
+                            suppressed: number;
+                        };
+                        trace: {
+                            acceptedAt: string;
+                            completeness: string;
+                            /** @description Receipt counts for this trace only; confirmations require positive tier reads, not stream acknowledgments. */
+                            delivery: {
+                                accepted: number;
+                                canonicalConfirmed: number;
+                                complete: number;
+                                hotConfirmed: number;
+                                pending: number;
+                                rawConfirmed: number;
+                            };
+                            diagnostics: {
+                                [key: string]: unknown;
+                            };
+                            expiresAt: string;
+                            revision: number;
+                            traceId: string;
+                        } | null;
+                    };
+                };
+            };
+            /** @description Invalid trace identity */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Unauthenticated */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Read scope required */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Health state temporarily unavailable */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+}
 
 /**
  * Hand-maintained, thin aliases over the GENERATED OpenAPI types.
@@ -50102,6 +50732,8 @@ type OrganizationAgentAliasList = paths['/v1/agent-aliases']['get']['responses']
 type OrganizationAgentAlias = OrganizationAgentAliasList['data'][number];
 /** What activating or rolling back a pointer reports back. */
 type AgentAliasActivation = paths['/v1/agents/{id}/aliases/{alias}']['put']['responses'][200]['content']['application/json'];
+/** The per-alias secret binding NAMES a pointer carries. Values are write-only. */
+type AgentAliasBindings = paths['/v1/agents/{id}/aliases/{alias}/bindings']['get']['responses'][200]['content']['application/json'];
 /** What archiving a pointer reports back. */
 type AgentAliasArchived = paths['/v1/agents/{id}/aliases/{alias}']['delete']['responses'][200]['content']['application/json'];
 /** One append-only deployment receipt. */
@@ -51724,6 +52356,12 @@ interface ProviderKeyModel {
         supported: boolean;
         defaultEffort?: string;
     };
+    /**
+     * Where a `system` message that follows a conversation turn lands on this endpoint. Omitted keeps
+     * it at its position (Mistral- and Gemma-family ids fold it into the leading prompt); `hoist` folds
+     * it for an endpoint whose chat template rejects a non-leading system role.
+     */
+    midConversationSystemMessages?: 'preserve' | 'hoist';
 }
 /** Content part types for multi-modal messages */
 interface TextContentPart {
@@ -51941,8 +52579,7 @@ type DispatchRecordInput = Omit<NonNullable<GeneratedDispatchRequest['record']>,
 };
 type DispatchRequestEnvelope = Omit<CanonicalDispatchRequestEnvelope, 'record' | 'messages' | 'clientTools'> & {
     record?: DispatchRecordInput;
-    messages?: Array<{
-        role: 'system' | 'user' | 'assistant';
+    messages?: Array<Omit<NonNullable<GeneratedDispatchRequest['messages']>[number], 'content'> & {
         content: DispatchMessageContent;
     }>;
     /**
@@ -54165,6 +54802,18 @@ interface EvalSuiteSummary {
     latestRun: EvalSuiteLatestRun | null;
     createdAt: string;
     updatedAt: string;
+    /**
+     * Non-blocking findings about this suite. `AGENT_NOT_DEPLOYED` means the
+     * target agent archived its `live` alias, so a run naming no version
+     * selector refuses once the live default is on for the organization.
+     */
+    warnings?: EvalSuiteWarning[];
+}
+/** One non-blocking finding about a suite's target. */
+interface EvalSuiteWarning {
+    code: string;
+    message: string;
+    agentId?: string;
 }
 /** A persisted test case. */
 interface EvalSuiteCase {
@@ -55613,6 +56262,15 @@ interface RollbackAgentAliasInput {
     revision?: number;
     reason?: string;
 }
+interface SetAgentAliasBindingsInput {
+    /** The complete set, NAME to value. An empty object clears every binding. */
+    bindings: Record<string, string>;
+    revision?: number;
+    reason?: string;
+}
+interface ClearAgentAliasBindingsInput {
+    revision?: number;
+}
 /**
  * One pointer an {@link AgentAliasesNamespace.archiveEverywhere} pass could not
  * archive. A stale revision (412) or a concurrent archive (404) is reported
@@ -55684,6 +56342,16 @@ declare class AgentAliasesNamespace {
     archive(agentId: string, alias: string, input?: ArchiveAgentAliasInput): Promise<AgentAliasArchived>;
     /** Re-aim a pointer at the version its receipt history records before this one. */
     rollback(agentId: string, alias: string, input?: RollbackAgentAliasInput): Promise<AgentAliasActivation>;
+    /** The per-alias secret binding NAMES this pointer carries. Values are write-only. */
+    getBindings(agentId: string, alias: string): Promise<AgentAliasBindings>;
+    /**
+     * Replace the complete set of `{{secret:NAME}}` values executions resolve
+     * when they reach this agent through this pointer, ahead of the organization
+     * secret of the same name. A name you stop sending stops resolving.
+     */
+    setBindings(agentId: string, alias: string, input: SetAgentAliasBindingsInput): Promise<AgentAliasBindings>;
+    /** Drop every binding, so this pointer's executions fall back to organization secrets. */
+    clearBindings(agentId: string, alias: string, input?: ClearAgentAliasBindingsInput): Promise<AgentAliasBindings>;
     private run;
 }
 /**
@@ -55881,6 +56549,13 @@ interface EnsureAgentOptions {
      */
     deploy?: {
         alias: string;
+        /**
+         * The complete set of `{{secret:NAME}}` values executions resolve when they
+         * reach this agent through this pointer, ahead of the organization secret
+         * of the same name. Whole-set replacement; an empty object clears them.
+         * Values are write-only and never returned.
+         */
+        bindings?: Record<string, string>;
     };
     /**
      * TOCTOU guard binding a dry run to its apply: the write only proceeds if