@mastra/client-js 1.22.0-alpha.3 → 1.22.0-alpha.5

package/dist/route-types.generated.d.ts

@@ -104,9 +104,16 @@ export type GetAgents_Response = {
         defaultStreamOptionsLegacy?: {
             [key: string]: any;
         } | undefined;
+        source?: ('code' | 'stored') | undefined;
         status?: ('draft' | 'published' | 'archived') | undefined;
         activeVersionId?: string | undefined;
         hasDraft?: boolean | undefined;
+        editor?: (false | {
+            instructions?: boolean | undefined;
+            tools?: (boolean | {
+                description?: boolean | undefined;
+            }) | undefined;
+        }) | undefined;
     };
 };
 export type GetAgents_Request = Simplify<(never extends never ? {} : {
@@ -262,9 +269,16 @@ export type GetAgentsAgentId_Response = {
     defaultStreamOptionsLegacy?: {
         [key: string]: any;
     } | undefined;
+    source?: ('code' | 'stored') | undefined;
     status?: ('draft' | 'published' | 'archived') | undefined;
     activeVersionId?: string | undefined;
     hasDraft?: boolean | undefined;
+    editor?: (false | {
+        instructions?: boolean | undefined;
+        tools?: (boolean | {
+            description?: boolean | undefined;
+        }) | undefined;
+    }) | undefined;
 };
 export type GetAgentsAgentId_Request = Simplify<(GetAgentsAgentId_PathParams extends never ? {} : {
     params: GetAgentsAgentId_PathParams;
@@ -807,6 +821,68 @@ export type PostAgentsAgentIdClone_Response = {
             })[];
         } | undefined;
     }[]) | undefined;
+    /** Tool provider connections and per-tool config (provider-agnostic). Coexists with the deprecated `integrationTools` field. */
+    toolProviders?: ({
+        [key: string]: {
+            tools: {
+                [key: string]: {
+                    toolkit?: string | undefined;
+                    description?: string | undefined;
+                };
+            };
+            connections: {
+                [key: string]: {
+                    kind: 'author' | 'invoker' | 'platform';
+                    toolkit: string;
+                    connectionId: string;
+                    label?: string | undefined;
+                    scope?: ('shared' | 'per-author' | 'caller-supplied') | undefined;
+                }[];
+            };
+        };
+    } | {
+        value: {
+            [key: string]: {
+                tools: {
+                    [key: string]: {
+                        toolkit?: string | undefined;
+                        description?: string | undefined;
+                    };
+                };
+                connections: {
+                    [key: string]: {
+                        kind: 'author' | 'invoker' | 'platform';
+                        toolkit: string;
+                        connectionId: string;
+                        label?: string | undefined;
+                        scope?: ('shared' | 'per-author' | 'caller-supplied') | undefined;
+                    }[];
+                };
+            };
+        };
+        rules?: {
+            operator: 'AND' | 'OR';
+            conditions: ({
+                field: string;
+                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                value?: unknown | undefined;
+            } | {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: {
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+    }[]) | undefined;
     /** Map of stored MCP client IDs to their tool configurations — static or conditional */
     mcpClients?: ({
         [key: string]: {
@@ -14185,6 +14261,68 @@ export type GetStoredAgents_Response = {
                 })[];
             } | undefined;
         }[]) | undefined;
+        /** Tool provider connections and per-tool config (provider-agnostic). Coexists with the deprecated `integrationTools` field. */
+        toolProviders?: ({
+            [key: string]: {
+                tools: {
+                    [key: string]: {
+                        toolkit?: string | undefined;
+                        description?: string | undefined;
+                    };
+                };
+                connections: {
+                    [key: string]: {
+                        kind: 'author' | 'invoker' | 'platform';
+                        toolkit: string;
+                        connectionId: string;
+                        label?: string | undefined;
+                        scope?: ('shared' | 'per-author' | 'caller-supplied') | undefined;
+                    }[];
+                };
+            };
+        } | {
+            value: {
+                [key: string]: {
+                    tools: {
+                        [key: string]: {
+                            toolkit?: string | undefined;
+                            description?: string | undefined;
+                        };
+                    };
+                    connections: {
+                        [key: string]: {
+                            kind: 'author' | 'invoker' | 'platform';
+                            toolkit: string;
+                            connectionId: string;
+                            label?: string | undefined;
+                            scope?: ('shared' | 'per-author' | 'caller-supplied') | undefined;
+                        }[];
+                    };
+                };
+            };
+            rules?: {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: ({
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    } | {
+                        operator: 'AND' | 'OR';
+                        conditions: {
+                            field: string;
+                            operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                            value?: unknown | undefined;
+                        }[];
+                    })[];
+                })[];
+            } | undefined;
+        }[]) | undefined;
         /** Map of stored MCP client IDs to their tool configurations — static or conditional */
         mcpClients?: ({
             [key: string]: {
@@ -15802,36 +15940,14 @@ export interface PostStoredAgentsPreviewInstructions_RouteContract {
     response: PostStoredAgentsPreviewInstructions_Response;
     responseType: 'json';
 }
-export type GetStoredAgentsStoredAgentId_PathParams = {
+export type PostStoredAgentsStoredAgentIdExport_PathParams = {
     /** Unique identifier for the stored agent */
     storedAgentId: string;
 };
-export type GetStoredAgentsStoredAgentId_QueryParams = {
-    /** Which version to resolve: published (active version) or draft (latest version) */
-    status: ('draft' | 'published' | 'archived') | undefined;
-};
-export type GetStoredAgentsStoredAgentId_Response = {
-    id: string;
-    /** Agent status: draft or published */
-    status: string;
-    activeVersionId?: string | undefined;
-    authorId?: string | undefined;
-    metadata?: {
-        [key: string]: unknown;
-    } | undefined;
-    visibility?: ('private' | 'public') | undefined;
-    /** Number of users who have favorited this agent */
-    favoriteCount?: number | undefined;
-    /** Whether the requesting user has favorited this agent */
-    isFavorited?: boolean | undefined;
-    createdAt: Date;
-    updatedAt: Date;
-    /** Name of the agent */
-    name: string;
-    /** Description of the agent */
-    description?: string | undefined;
-    /** System instructions for the agent (string or array of instruction blocks) */
-    instructions: string | ({
+export type PostStoredAgentsStoredAgentIdExport_Body = {
+    name?: string | undefined;
+    description?: (string | undefined) | undefined;
+    instructions?: (string | ({
         type: 'text';
         content: string;
     } | {
@@ -15862,9 +15978,8 @@ export type GetStoredAgentsStoredAgentId_Response = {
                 })[];
             })[];
         } | undefined;
-    })[];
-    /** Model configuration — static value or array of conditional variants */
-    model: {
+    })[]) | undefined;
+    model?: ({
         /** Model provider (e.g., openai, anthropic) */
         provider: string;
         /** Model name (e.g., gpt-4o, claude-3-opus) */
@@ -15900,9 +16015,8 @@ export type GetStoredAgentsStoredAgentId_Response = {
                 })[];
             })[];
         } | undefined;
-    }[];
-    /** Tool keys mapped to per-tool config — static or conditional */
-    tools?: ({
+    }[]) | undefined;
+    tools?: (({
         [key: string]: {
             description?: string | undefined;
             rules?: {
@@ -15978,9 +16092,8 @@ export type GetStoredAgentsStoredAgentId_Response = {
                 })[];
             })[];
         } | undefined;
-    }[]) | undefined;
-    /** Default options for generate/stream calls — static or conditional */
-    defaultOptions?: ({
+    }[]) | undefined) | undefined;
+    defaultOptions?: (({
         runId?: string | undefined;
         savePerStep?: boolean | undefined;
         maxSteps?: number | undefined;
@@ -16075,9 +16188,8 @@ export type GetStoredAgentsStoredAgentId_Response = {
                 })[];
             })[];
         } | undefined;
-    }[]) | undefined;
-    /** Workflow keys with optional per-workflow config — static or conditional */
-    workflows?: ({
+    }[]) | undefined) | undefined;
+    workflows?: (({
         [key: string]: {
             description?: string | undefined;
             rules?: {
@@ -16153,9 +16265,8 @@ export type GetStoredAgentsStoredAgentId_Response = {
                 })[];
             })[];
         } | undefined;
-    }[]) | undefined;
-    /** Agent keys with optional per-agent config — static or conditional */
-    agents?: ({
+    }[]) | undefined) | undefined;
+    agents?: (({
         [key: string]: {
             description?: string | undefined;
             rules?: {
@@ -16231,9 +16342,8 @@ export type GetStoredAgentsStoredAgentId_Response = {
                 })[];
             })[];
         } | undefined;
-    }[]) | undefined;
-    /** Map of tool provider IDs to their tool configurations — static or conditional */
-    integrationTools?: ({
+    }[]) | undefined) | undefined;
+    integrationTools?: (({
         [key: string]: {
             tools?: {
                 [key: string]: {
@@ -16317,68 +16427,43 @@ export type GetStoredAgentsStoredAgentId_Response = {
                 })[];
             })[];
         } | undefined;
-    }[]) | undefined;
-    /** Map of stored MCP client IDs to their tool configurations — static or conditional */
-    mcpClients?: ({
+    }[]) | undefined) | undefined;
+    toolProviders?: (({
         [key: string]: {
-            tools?: {
+            tools: {
                 [key: string]: {
+                    toolkit?: string | undefined;
                     description?: string | undefined;
-                    rules?: {
-                        operator: 'AND' | 'OR';
-                        conditions: ({
-                            field: string;
-                            operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
-                            value?: unknown | undefined;
-                        } | {
-                            operator: 'AND' | 'OR';
-                            conditions: ({
-                                field: string;
-                                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
-                                value?: unknown | undefined;
-                            } | {
-                                operator: 'AND' | 'OR';
-                                conditions: {
-                                    field: string;
-                                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
-                                    value?: unknown | undefined;
-                                }[];
-                            })[];
-                        })[];
-                    } | undefined;
                 };
-            } | undefined;
+            };
+            connections: {
+                [key: string]: {
+                    kind: 'author' | 'invoker' | 'platform';
+                    toolkit: string;
+                    connectionId: string;
+                    label?: string | undefined;
+                    scope?: ('shared' | 'per-author' | 'caller-supplied') | undefined;
+                }[];
+            };
         };
     } | {
         value: {
             [key: string]: {
-                tools?: {
+                tools: {
                     [key: string]: {
+                        toolkit?: string | undefined;
                         description?: string | undefined;
-                        rules?: {
-                            operator: 'AND' | 'OR';
-                            conditions: ({
-                                field: string;
-                                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
-                                value?: unknown | undefined;
-                            } | {
-                                operator: 'AND' | 'OR';
-                                conditions: ({
-                                    field: string;
-                                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
-                                    value?: unknown | undefined;
-                                } | {
-                                    operator: 'AND' | 'OR';
-                                    conditions: {
-                                        field: string;
-                                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
-                                        value?: unknown | undefined;
-                                    }[];
-                                })[];
-                            })[];
-                        } | undefined;
                     };
-                } | undefined;
+                };
+                connections: {
+                    [key: string]: {
+                        kind: 'author' | 'invoker' | 'platform';
+                        toolkit: string;
+                        connectionId: string;
+                        label?: string | undefined;
+                        scope?: ('shared' | 'per-author' | 'caller-supplied') | undefined;
+                    }[];
+                };
             };
         };
         rules?: {
@@ -16403,75 +16488,159 @@ export type GetStoredAgentsStoredAgentId_Response = {
                 })[];
             })[];
         } | undefined;
-    }[]) | undefined;
-    /** Input processor graph — static or conditional */
-    inputProcessors?: ({
-        /** Ordered list of processor graph entries */
-        steps: ({
-            type: 'step';
-            step: {
-                /** Unique ID for this step within the graph */
-                id: string;
-                /** ProcessorProvider ID that creates this processor */
-                providerId: string;
-                /** Configuration matching the provider configSchema */
-                config: {
-                    [key: string]: unknown;
-                };
-                /** Which processor phases to enable */
-                enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
-            };
-        } | {
-            type: 'parallel';
-            branches: ({
-                type: 'step';
-                step: {
-                    /** Unique ID for this step within the graph */
-                    id: string;
-                    /** ProcessorProvider ID that creates this processor */
-                    providerId: string;
-                    /** Configuration matching the provider configSchema */
-                    config: {
-                        [key: string]: unknown;
-                    };
-                    /** Which processor phases to enable */
-                    enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
-                };
-            } | {
-                type: 'parallel';
-                branches: {
-                    type: 'step';
-                    step: {
-                        /** Unique ID for this step within the graph */
-                        id: string;
-                        /** ProcessorProvider ID that creates this processor */
-                        providerId: string;
-                        /** Configuration matching the provider configSchema */
-                        config: {
-                            [key: string]: unknown;
-                        };
-                        /** Which processor phases to enable */
-                        enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
-                    };
-                }[][];
-            } | {
-                type: 'conditional';
-                conditions: {
-                    steps: {
-                        type: 'step';
-                        step: {
-                            /** Unique ID for this step within the graph */
-                            id: string;
-                            /** ProcessorProvider ID that creates this processor */
-                            providerId: string;
-                            /** Configuration matching the provider configSchema */
-                            config: {
-                                [key: string]: unknown;
-                            };
-                            /** Which processor phases to enable */
-                            enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
-                        };
-                    }[];
+    }[]) | undefined) | undefined;
+    mcpClients?: (({
+        [key: string]: {
+            tools?: {
+                [key: string]: {
+                    description?: string | undefined;
+                    rules?: {
+                        operator: 'AND' | 'OR';
+                        conditions: ({
+                            field: string;
+                            operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                            value?: unknown | undefined;
+                        } | {
+                            operator: 'AND' | 'OR';
+                            conditions: ({
+                                field: string;
+                                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                value?: unknown | undefined;
+                            } | {
+                                operator: 'AND' | 'OR';
+                                conditions: {
+                                    field: string;
+                                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                    value?: unknown | undefined;
+                                }[];
+                            })[];
+                        })[];
+                    } | undefined;
+                };
+            } | undefined;
+        };
+    } | {
+        value: {
+            [key: string]: {
+                tools?: {
+                    [key: string]: {
+                        description?: string | undefined;
+                        rules?: {
+                            operator: 'AND' | 'OR';
+                            conditions: ({
+                                field: string;
+                                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                value?: unknown | undefined;
+                            } | {
+                                operator: 'AND' | 'OR';
+                                conditions: ({
+                                    field: string;
+                                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                    value?: unknown | undefined;
+                                } | {
+                                    operator: 'AND' | 'OR';
+                                    conditions: {
+                                        field: string;
+                                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                        value?: unknown | undefined;
+                                    }[];
+                                })[];
+                            })[];
+                        } | undefined;
+                    };
+                } | undefined;
+            };
+        };
+        rules?: {
+            operator: 'AND' | 'OR';
+            conditions: ({
+                field: string;
+                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                value?: unknown | undefined;
+            } | {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: {
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+    }[]) | undefined) | undefined;
+    inputProcessors?: (({
+        /** Ordered list of processor graph entries */
+        steps: ({
+            type: 'step';
+            step: {
+                /** Unique ID for this step within the graph */
+                id: string;
+                /** ProcessorProvider ID that creates this processor */
+                providerId: string;
+                /** Configuration matching the provider configSchema */
+                config: {
+                    [key: string]: unknown;
+                };
+                /** Which processor phases to enable */
+                enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+            };
+        } | {
+            type: 'parallel';
+            branches: ({
+                type: 'step';
+                step: {
+                    /** Unique ID for this step within the graph */
+                    id: string;
+                    /** ProcessorProvider ID that creates this processor */
+                    providerId: string;
+                    /** Configuration matching the provider configSchema */
+                    config: {
+                        [key: string]: unknown;
+                    };
+                    /** Which processor phases to enable */
+                    enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                };
+            } | {
+                type: 'parallel';
+                branches: {
+                    type: 'step';
+                    step: {
+                        /** Unique ID for this step within the graph */
+                        id: string;
+                        /** ProcessorProvider ID that creates this processor */
+                        providerId: string;
+                        /** Configuration matching the provider configSchema */
+                        config: {
+                            [key: string]: unknown;
+                        };
+                        /** Which processor phases to enable */
+                        enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                    };
+                }[][];
+            } | {
+                type: 'conditional';
+                conditions: {
+                    steps: {
+                        type: 'step';
+                        step: {
+                            /** Unique ID for this step within the graph */
+                            id: string;
+                            /** ProcessorProvider ID that creates this processor */
+                            providerId: string;
+                            /** Configuration matching the provider configSchema */
+                            config: {
+                                [key: string]: unknown;
+                            };
+                            /** Which processor phases to enable */
+                            enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                        };
+                    }[];
                     rules?: {
                         operator: 'AND' | 'OR';
                         conditions: ({
@@ -16811,9 +16980,8 @@ export type GetStoredAgentsStoredAgentId_Response = {
                 })[];
             })[];
         } | undefined;
-    }[]) | undefined;
-    /** Output processor graph — static or conditional */
-    outputProcessors?: ({
+    }[]) | undefined) | undefined;
+    outputProcessors?: (({
         /** Ordered list of processor graph entries */
         steps: ({
             type: 'step';
@@ -17219,9 +17387,8 @@ export type GetStoredAgentsStoredAgentId_Response = {
                 })[];
             })[];
         } | undefined;
-    }[]) | undefined;
-    /** Memory configuration — static or conditional */
-    memory?: ({
+    }[]) | undefined) | undefined;
+    memory?: ((({
         /** Vector database identifier or false to disable */
         vector?: (string | false) | undefined;
         /** Memory behavior configuration, excluding workingMemory and threads */
@@ -17425,9 +17592,8 @@ export type GetStoredAgentsStoredAgentId_Response = {
                 })[];
             })[];
         } | undefined;
-    }[]) | undefined;
-    /** Scorer keys with optional sampling config — static or conditional */
-    scorers?: ({
+    }[]) | null) | undefined) | undefined;
+    scorers?: (({
         [key: string]: {
             description?: string | undefined;
             sampling?: ({
@@ -17515,9 +17681,8 @@ export type GetStoredAgentsStoredAgentId_Response = {
                 })[];
             })[];
         } | undefined;
-    }[]) | undefined;
-    /** Skill IDs mapped to per-skill config — static or conditional */
-    skills?: ({
+    }[]) | undefined) | undefined;
+    skills?: (({
         [key: string]: {
             description?: string | undefined;
             instructions?: string | undefined;
@@ -17555,9 +17720,8 @@ export type GetStoredAgentsStoredAgentId_Response = {
                 })[];
             })[];
         } | undefined;
-    }[]) | undefined;
-    /** Workspace reference (stored ID or inline config) — static or conditional */
-    workspace?: (({
+    }[]) | undefined) | undefined;
+    workspace?: ((({
         type: 'id';
         workspaceId: string;
     } | {
@@ -17761,9 +17925,8 @@ export type GetStoredAgentsStoredAgentId_Response = {
                 })[];
             })[];
         } | undefined;
-    }[]) | undefined;
-    /** Browser configuration — object config, true (apply default), false/null (disable) */
-    browser?: (({
+    }[]) | undefined) | undefined;
+    browser?: ((({
         type: 'inline';
         config: {
             /** Browser provider type (e.g., stagehand, playwright) */
@@ -17847,42 +18010,62 @@ export type GetStoredAgentsStoredAgentId_Response = {
                 })[];
             })[];
         } | undefined;
-    }[]) | boolean | null) | undefined;
-    /** JSON Schema defining valid request context variables */
-    requestContextSchema?: {
+    }[]) | boolean | null) | undefined) | undefined;
+    requestContextSchema?: ({
         [key: string]: unknown;
-    } | undefined;
+    } | undefined) | undefined;
 };
-export type GetStoredAgentsStoredAgentId_Request = Simplify<(GetStoredAgentsStoredAgentId_PathParams extends never ? {} : {
-    params: GetStoredAgentsStoredAgentId_PathParams;
-}) & (GetStoredAgentsStoredAgentId_QueryParams extends never ? {} : {} extends GetStoredAgentsStoredAgentId_QueryParams ? {
-    query?: GetStoredAgentsStoredAgentId_QueryParams;
-} : {
-    query: GetStoredAgentsStoredAgentId_QueryParams;
+export type PostStoredAgentsStoredAgentIdExport_Response = {
+    agentId: string;
+    fileName: string;
+    content: string;
+    config: {
+        [key: string]: unknown;
+    };
+};
+export type PostStoredAgentsStoredAgentIdExport_Request = Simplify<(PostStoredAgentsStoredAgentIdExport_PathParams extends never ? {} : {
+    params: PostStoredAgentsStoredAgentIdExport_PathParams;
 }) & (never extends never ? {} : {} extends never ? {
-    body?: never;
+    query?: never;
 } : {
-    body: never;
+    query: never;
+}) & (PostStoredAgentsStoredAgentIdExport_Body extends never ? {} : {} extends PostStoredAgentsStoredAgentIdExport_Body ? {
+    body?: PostStoredAgentsStoredAgentIdExport_Body;
+} : {
+    body: PostStoredAgentsStoredAgentIdExport_Body;
 })>;
-export interface GetStoredAgentsStoredAgentId_RouteContract {
-    pathParams: GetStoredAgentsStoredAgentId_PathParams;
-    queryParams: GetStoredAgentsStoredAgentId_QueryParams;
-    body: never;
-    request: GetStoredAgentsStoredAgentId_Request;
-    response: GetStoredAgentsStoredAgentId_Response;
+export interface PostStoredAgentsStoredAgentIdExport_RouteContract {
+    pathParams: PostStoredAgentsStoredAgentIdExport_PathParams;
+    queryParams: never;
+    body: PostStoredAgentsStoredAgentIdExport_Body;
+    request: PostStoredAgentsStoredAgentIdExport_Request;
+    response: PostStoredAgentsStoredAgentIdExport_Response;
     responseType: 'json';
 }
-export type PostStoredAgents_Body = {
-    /** Unique identifier for the agent. If not provided, derived from name. */
-    id?: string | undefined;
-    /** Author identifier for multi-tenant filtering */
+export type GetStoredAgentsStoredAgentId_PathParams = {
+    /** Unique identifier for the stored agent */
+    storedAgentId: string;
+};
+export type GetStoredAgentsStoredAgentId_QueryParams = {
+    /** Which version to resolve: published (active version) or draft (latest version) */
+    status: ('draft' | 'published' | 'archived') | undefined;
+};
+export type GetStoredAgentsStoredAgentId_Response = {
+    id: string;
+    /** Agent status: draft or published */
+    status: string;
+    activeVersionId?: string | undefined;
     authorId?: string | undefined;
-    /** Additional metadata for the agent */
     metadata?: {
         [key: string]: unknown;
     } | undefined;
-    /** Agent visibility: private (owner/admin only) or public (any reader) */
     visibility?: ('private' | 'public') | undefined;
+    /** Number of users who have favorited this agent */
+    favoriteCount?: number | undefined;
+    /** Whether the requesting user has favorited this agent */
+    isFavorited?: boolean | undefined;
+    createdAt: Date;
+    updatedAt: Date;
     /** Name of the agent */
     name: string;
     /** Description of the agent */
@@ -17920,8 +18103,8 @@ export type PostStoredAgents_Body = {
             })[];
         } | undefined;
     })[];
-    /** Model configuration — static value or array of conditional variants. When omitted, the builder default model is applied server-side. */
-    model?: ({
+    /** Model configuration — static value or array of conditional variants */
+    model: {
         /** Model provider (e.g., openai, anthropic) */
         provider: string;
         /** Model name (e.g., gpt-4o, claude-3-opus) */
@@ -17957,7 +18140,7 @@ export type PostStoredAgents_Body = {
                 })[];
             })[];
         } | undefined;
-    }[]) | undefined;
+    }[];
     /** Tool keys mapped to per-tool config — static or conditional */
     tools?: ({
         [key: string]: {
@@ -18375,6 +18558,2187 @@ export type PostStoredAgents_Body = {
             })[];
         } | undefined;
     }[]) | undefined;
+    /** Tool provider connections and per-tool config (provider-agnostic). Coexists with the deprecated `integrationTools` field. */
+    toolProviders?: ({
+        [key: string]: {
+            tools: {
+                [key: string]: {
+                    toolkit?: string | undefined;
+                    description?: string | undefined;
+                };
+            };
+            connections: {
+                [key: string]: {
+                    kind: 'author' | 'invoker' | 'platform';
+                    toolkit: string;
+                    connectionId: string;
+                    label?: string | undefined;
+                    scope?: ('shared' | 'per-author' | 'caller-supplied') | undefined;
+                }[];
+            };
+        };
+    } | {
+        value: {
+            [key: string]: {
+                tools: {
+                    [key: string]: {
+                        toolkit?: string | undefined;
+                        description?: string | undefined;
+                    };
+                };
+                connections: {
+                    [key: string]: {
+                        kind: 'author' | 'invoker' | 'platform';
+                        toolkit: string;
+                        connectionId: string;
+                        label?: string | undefined;
+                        scope?: ('shared' | 'per-author' | 'caller-supplied') | undefined;
+                    }[];
+                };
+            };
+        };
+        rules?: {
+            operator: 'AND' | 'OR';
+            conditions: ({
+                field: string;
+                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                value?: unknown | undefined;
+            } | {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: {
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+    }[]) | undefined;
+    /** Map of stored MCP client IDs to their tool configurations — static or conditional */
+    mcpClients?: ({
+        [key: string]: {
+            tools?: {
+                [key: string]: {
+                    description?: string | undefined;
+                    rules?: {
+                        operator: 'AND' | 'OR';
+                        conditions: ({
+                            field: string;
+                            operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                            value?: unknown | undefined;
+                        } | {
+                            operator: 'AND' | 'OR';
+                            conditions: ({
+                                field: string;
+                                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                value?: unknown | undefined;
+                            } | {
+                                operator: 'AND' | 'OR';
+                                conditions: {
+                                    field: string;
+                                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                    value?: unknown | undefined;
+                                }[];
+                            })[];
+                        })[];
+                    } | undefined;
+                };
+            } | undefined;
+        };
+    } | {
+        value: {
+            [key: string]: {
+                tools?: {
+                    [key: string]: {
+                        description?: string | undefined;
+                        rules?: {
+                            operator: 'AND' | 'OR';
+                            conditions: ({
+                                field: string;
+                                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                value?: unknown | undefined;
+                            } | {
+                                operator: 'AND' | 'OR';
+                                conditions: ({
+                                    field: string;
+                                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                    value?: unknown | undefined;
+                                } | {
+                                    operator: 'AND' | 'OR';
+                                    conditions: {
+                                        field: string;
+                                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                        value?: unknown | undefined;
+                                    }[];
+                                })[];
+                            })[];
+                        } | undefined;
+                    };
+                } | undefined;
+            };
+        };
+        rules?: {
+            operator: 'AND' | 'OR';
+            conditions: ({
+                field: string;
+                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                value?: unknown | undefined;
+            } | {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: {
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+    }[]) | undefined;
+    /** Input processor graph — static or conditional */
+    inputProcessors?: ({
+        /** Ordered list of processor graph entries */
+        steps: ({
+            type: 'step';
+            step: {
+                /** Unique ID for this step within the graph */
+                id: string;
+                /** ProcessorProvider ID that creates this processor */
+                providerId: string;
+                /** Configuration matching the provider configSchema */
+                config: {
+                    [key: string]: unknown;
+                };
+                /** Which processor phases to enable */
+                enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+            };
+        } | {
+            type: 'parallel';
+            branches: ({
+                type: 'step';
+                step: {
+                    /** Unique ID for this step within the graph */
+                    id: string;
+                    /** ProcessorProvider ID that creates this processor */
+                    providerId: string;
+                    /** Configuration matching the provider configSchema */
+                    config: {
+                        [key: string]: unknown;
+                    };
+                    /** Which processor phases to enable */
+                    enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                };
+            } | {
+                type: 'parallel';
+                branches: {
+                    type: 'step';
+                    step: {
+                        /** Unique ID for this step within the graph */
+                        id: string;
+                        /** ProcessorProvider ID that creates this processor */
+                        providerId: string;
+                        /** Configuration matching the provider configSchema */
+                        config: {
+                            [key: string]: unknown;
+                        };
+                        /** Which processor phases to enable */
+                        enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                    };
+                }[][];
+            } | {
+                type: 'conditional';
+                conditions: {
+                    steps: {
+                        type: 'step';
+                        step: {
+                            /** Unique ID for this step within the graph */
+                            id: string;
+                            /** ProcessorProvider ID that creates this processor */
+                            providerId: string;
+                            /** Configuration matching the provider configSchema */
+                            config: {
+                                [key: string]: unknown;
+                            };
+                            /** Which processor phases to enable */
+                            enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                        };
+                    }[];
+                    rules?: {
+                        operator: 'AND' | 'OR';
+                        conditions: ({
+                            field: string;
+                            operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                            value?: unknown | undefined;
+                        } | {
+                            operator: 'AND' | 'OR';
+                            conditions: ({
+                                field: string;
+                                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                value?: unknown | undefined;
+                            } | {
+                                operator: 'AND' | 'OR';
+                                conditions: {
+                                    field: string;
+                                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                    value?: unknown | undefined;
+                                }[];
+                            })[];
+                        })[];
+                    } | undefined;
+                }[];
+            })[][];
+        } | {
+            type: 'conditional';
+            conditions: {
+                steps: ({
+                    type: 'step';
+                    step: {
+                        /** Unique ID for this step within the graph */
+                        id: string;
+                        /** ProcessorProvider ID that creates this processor */
+                        providerId: string;
+                        /** Configuration matching the provider configSchema */
+                        config: {
+                            [key: string]: unknown;
+                        };
+                        /** Which processor phases to enable */
+                        enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                    };
+                } | {
+                    type: 'parallel';
+                    branches: {
+                        type: 'step';
+                        step: {
+                            /** Unique ID for this step within the graph */
+                            id: string;
+                            /** ProcessorProvider ID that creates this processor */
+                            providerId: string;
+                            /** Configuration matching the provider configSchema */
+                            config: {
+                                [key: string]: unknown;
+                            };
+                            /** Which processor phases to enable */
+                            enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                        };
+                    }[][];
+                } | {
+                    type: 'conditional';
+                    conditions: {
+                        steps: {
+                            type: 'step';
+                            step: {
+                                /** Unique ID for this step within the graph */
+                                id: string;
+                                /** ProcessorProvider ID that creates this processor */
+                                providerId: string;
+                                /** Configuration matching the provider configSchema */
+                                config: {
+                                    [key: string]: unknown;
+                                };
+                                /** Which processor phases to enable */
+                                enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                            };
+                        }[];
+                        rules?: {
+                            operator: 'AND' | 'OR';
+                            conditions: ({
+                                field: string;
+                                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                value?: unknown | undefined;
+                            } | {
+                                operator: 'AND' | 'OR';
+                                conditions: ({
+                                    field: string;
+                                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                    value?: unknown | undefined;
+                                } | {
+                                    operator: 'AND' | 'OR';
+                                    conditions: {
+                                        field: string;
+                                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                        value?: unknown | undefined;
+                                    }[];
+                                })[];
+                            })[];
+                        } | undefined;
+                    }[];
+                })[];
+                rules?: {
+                    operator: 'AND' | 'OR';
+                    conditions: ({
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    } | {
+                        operator: 'AND' | 'OR';
+                        conditions: ({
+                            field: string;
+                            operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                            value?: unknown | undefined;
+                        } | {
+                            operator: 'AND' | 'OR';
+                            conditions: {
+                                field: string;
+                                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                value?: unknown | undefined;
+                            }[];
+                        })[];
+                    })[];
+                } | undefined;
+            }[];
+        })[];
+    } | {
+        value: {
+            /** Ordered list of processor graph entries */
+            steps: ({
+                type: 'step';
+                step: {
+                    /** Unique ID for this step within the graph */
+                    id: string;
+                    /** ProcessorProvider ID that creates this processor */
+                    providerId: string;
+                    /** Configuration matching the provider configSchema */
+                    config: {
+                        [key: string]: unknown;
+                    };
+                    /** Which processor phases to enable */
+                    enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                };
+            } | {
+                type: 'parallel';
+                branches: ({
+                    type: 'step';
+                    step: {
+                        /** Unique ID for this step within the graph */
+                        id: string;
+                        /** ProcessorProvider ID that creates this processor */
+                        providerId: string;
+                        /** Configuration matching the provider configSchema */
+                        config: {
+                            [key: string]: unknown;
+                        };
+                        /** Which processor phases to enable */
+                        enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                    };
+                } | {
+                    type: 'parallel';
+                    branches: {
+                        type: 'step';
+                        step: {
+                            /** Unique ID for this step within the graph */
+                            id: string;
+                            /** ProcessorProvider ID that creates this processor */
+                            providerId: string;
+                            /** Configuration matching the provider configSchema */
+                            config: {
+                                [key: string]: unknown;
+                            };
+                            /** Which processor phases to enable */
+                            enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                        };
+                    }[][];
+                } | {
+                    type: 'conditional';
+                    conditions: {
+                        steps: {
+                            type: 'step';
+                            step: {
+                                /** Unique ID for this step within the graph */
+                                id: string;
+                                /** ProcessorProvider ID that creates this processor */
+                                providerId: string;
+                                /** Configuration matching the provider configSchema */
+                                config: {
+                                    [key: string]: unknown;
+                                };
+                                /** Which processor phases to enable */
+                                enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                            };
+                        }[];
+                        rules?: {
+                            operator: 'AND' | 'OR';
+                            conditions: ({
+                                field: string;
+                                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                value?: unknown | undefined;
+                            } | {
+                                operator: 'AND' | 'OR';
+                                conditions: ({
+                                    field: string;
+                                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                    value?: unknown | undefined;
+                                } | {
+                                    operator: 'AND' | 'OR';
+                                    conditions: {
+                                        field: string;
+                                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                        value?: unknown | undefined;
+                                    }[];
+                                })[];
+                            })[];
+                        } | undefined;
+                    }[];
+                })[][];
+            } | {
+                type: 'conditional';
+                conditions: {
+                    steps: ({
+                        type: 'step';
+                        step: {
+                            /** Unique ID for this step within the graph */
+                            id: string;
+                            /** ProcessorProvider ID that creates this processor */
+                            providerId: string;
+                            /** Configuration matching the provider configSchema */
+                            config: {
+                                [key: string]: unknown;
+                            };
+                            /** Which processor phases to enable */
+                            enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                        };
+                    } | {
+                        type: 'parallel';
+                        branches: {
+                            type: 'step';
+                            step: {
+                                /** Unique ID for this step within the graph */
+                                id: string;
+                                /** ProcessorProvider ID that creates this processor */
+                                providerId: string;
+                                /** Configuration matching the provider configSchema */
+                                config: {
+                                    [key: string]: unknown;
+                                };
+                                /** Which processor phases to enable */
+                                enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                            };
+                        }[][];
+                    } | {
+                        type: 'conditional';
+                        conditions: {
+                            steps: {
+                                type: 'step';
+                                step: {
+                                    /** Unique ID for this step within the graph */
+                                    id: string;
+                                    /** ProcessorProvider ID that creates this processor */
+                                    providerId: string;
+                                    /** Configuration matching the provider configSchema */
+                                    config: {
+                                        [key: string]: unknown;
+                                    };
+                                    /** Which processor phases to enable */
+                                    enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                                };
+                            }[];
+                            rules?: {
+                                operator: 'AND' | 'OR';
+                                conditions: ({
+                                    field: string;
+                                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                    value?: unknown | undefined;
+                                } | {
+                                    operator: 'AND' | 'OR';
+                                    conditions: ({
+                                        field: string;
+                                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                        value?: unknown | undefined;
+                                    } | {
+                                        operator: 'AND' | 'OR';
+                                        conditions: {
+                                            field: string;
+                                            operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                            value?: unknown | undefined;
+                                        }[];
+                                    })[];
+                                })[];
+                            } | undefined;
+                        }[];
+                    })[];
+                    rules?: {
+                        operator: 'AND' | 'OR';
+                        conditions: ({
+                            field: string;
+                            operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                            value?: unknown | undefined;
+                        } | {
+                            operator: 'AND' | 'OR';
+                            conditions: ({
+                                field: string;
+                                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                value?: unknown | undefined;
+                            } | {
+                                operator: 'AND' | 'OR';
+                                conditions: {
+                                    field: string;
+                                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                    value?: unknown | undefined;
+                                }[];
+                            })[];
+                        })[];
+                    } | undefined;
+                }[];
+            })[];
+        };
+        rules?: {
+            operator: 'AND' | 'OR';
+            conditions: ({
+                field: string;
+                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                value?: unknown | undefined;
+            } | {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: {
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+    }[]) | undefined;
+    /** Output processor graph — static or conditional */
+    outputProcessors?: ({
+        /** Ordered list of processor graph entries */
+        steps: ({
+            type: 'step';
+            step: {
+                /** Unique ID for this step within the graph */
+                id: string;
+                /** ProcessorProvider ID that creates this processor */
+                providerId: string;
+                /** Configuration matching the provider configSchema */
+                config: {
+                    [key: string]: unknown;
+                };
+                /** Which processor phases to enable */
+                enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+            };
+        } | {
+            type: 'parallel';
+            branches: ({
+                type: 'step';
+                step: {
+                    /** Unique ID for this step within the graph */
+                    id: string;
+                    /** ProcessorProvider ID that creates this processor */
+                    providerId: string;
+                    /** Configuration matching the provider configSchema */
+                    config: {
+                        [key: string]: unknown;
+                    };
+                    /** Which processor phases to enable */
+                    enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                };
+            } | {
+                type: 'parallel';
+                branches: {
+                    type: 'step';
+                    step: {
+                        /** Unique ID for this step within the graph */
+                        id: string;
+                        /** ProcessorProvider ID that creates this processor */
+                        providerId: string;
+                        /** Configuration matching the provider configSchema */
+                        config: {
+                            [key: string]: unknown;
+                        };
+                        /** Which processor phases to enable */
+                        enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                    };
+                }[][];
+            } | {
+                type: 'conditional';
+                conditions: {
+                    steps: {
+                        type: 'step';
+                        step: {
+                            /** Unique ID for this step within the graph */
+                            id: string;
+                            /** ProcessorProvider ID that creates this processor */
+                            providerId: string;
+                            /** Configuration matching the provider configSchema */
+                            config: {
+                                [key: string]: unknown;
+                            };
+                            /** Which processor phases to enable */
+                            enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                        };
+                    }[];
+                    rules?: {
+                        operator: 'AND' | 'OR';
+                        conditions: ({
+                            field: string;
+                            operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                            value?: unknown | undefined;
+                        } | {
+                            operator: 'AND' | 'OR';
+                            conditions: ({
+                                field: string;
+                                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                value?: unknown | undefined;
+                            } | {
+                                operator: 'AND' | 'OR';
+                                conditions: {
+                                    field: string;
+                                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                    value?: unknown | undefined;
+                                }[];
+                            })[];
+                        })[];
+                    } | undefined;
+                }[];
+            })[][];
+        } | {
+            type: 'conditional';
+            conditions: {
+                steps: ({
+                    type: 'step';
+                    step: {
+                        /** Unique ID for this step within the graph */
+                        id: string;
+                        /** ProcessorProvider ID that creates this processor */
+                        providerId: string;
+                        /** Configuration matching the provider configSchema */
+                        config: {
+                            [key: string]: unknown;
+                        };
+                        /** Which processor phases to enable */
+                        enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                    };
+                } | {
+                    type: 'parallel';
+                    branches: {
+                        type: 'step';
+                        step: {
+                            /** Unique ID for this step within the graph */
+                            id: string;
+                            /** ProcessorProvider ID that creates this processor */
+                            providerId: string;
+                            /** Configuration matching the provider configSchema */
+                            config: {
+                                [key: string]: unknown;
+                            };
+                            /** Which processor phases to enable */
+                            enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                        };
+                    }[][];
+                } | {
+                    type: 'conditional';
+                    conditions: {
+                        steps: {
+                            type: 'step';
+                            step: {
+                                /** Unique ID for this step within the graph */
+                                id: string;
+                                /** ProcessorProvider ID that creates this processor */
+                                providerId: string;
+                                /** Configuration matching the provider configSchema */
+                                config: {
+                                    [key: string]: unknown;
+                                };
+                                /** Which processor phases to enable */
+                                enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                            };
+                        }[];
+                        rules?: {
+                            operator: 'AND' | 'OR';
+                            conditions: ({
+                                field: string;
+                                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                value?: unknown | undefined;
+                            } | {
+                                operator: 'AND' | 'OR';
+                                conditions: ({
+                                    field: string;
+                                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                    value?: unknown | undefined;
+                                } | {
+                                    operator: 'AND' | 'OR';
+                                    conditions: {
+                                        field: string;
+                                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                        value?: unknown | undefined;
+                                    }[];
+                                })[];
+                            })[];
+                        } | undefined;
+                    }[];
+                })[];
+                rules?: {
+                    operator: 'AND' | 'OR';
+                    conditions: ({
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    } | {
+                        operator: 'AND' | 'OR';
+                        conditions: ({
+                            field: string;
+                            operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                            value?: unknown | undefined;
+                        } | {
+                            operator: 'AND' | 'OR';
+                            conditions: {
+                                field: string;
+                                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                value?: unknown | undefined;
+                            }[];
+                        })[];
+                    })[];
+                } | undefined;
+            }[];
+        })[];
+    } | {
+        value: {
+            /** Ordered list of processor graph entries */
+            steps: ({
+                type: 'step';
+                step: {
+                    /** Unique ID for this step within the graph */
+                    id: string;
+                    /** ProcessorProvider ID that creates this processor */
+                    providerId: string;
+                    /** Configuration matching the provider configSchema */
+                    config: {
+                        [key: string]: unknown;
+                    };
+                    /** Which processor phases to enable */
+                    enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                };
+            } | {
+                type: 'parallel';
+                branches: ({
+                    type: 'step';
+                    step: {
+                        /** Unique ID for this step within the graph */
+                        id: string;
+                        /** ProcessorProvider ID that creates this processor */
+                        providerId: string;
+                        /** Configuration matching the provider configSchema */
+                        config: {
+                            [key: string]: unknown;
+                        };
+                        /** Which processor phases to enable */
+                        enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                    };
+                } | {
+                    type: 'parallel';
+                    branches: {
+                        type: 'step';
+                        step: {
+                            /** Unique ID for this step within the graph */
+                            id: string;
+                            /** ProcessorProvider ID that creates this processor */
+                            providerId: string;
+                            /** Configuration matching the provider configSchema */
+                            config: {
+                                [key: string]: unknown;
+                            };
+                            /** Which processor phases to enable */
+                            enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                        };
+                    }[][];
+                } | {
+                    type: 'conditional';
+                    conditions: {
+                        steps: {
+                            type: 'step';
+                            step: {
+                                /** Unique ID for this step within the graph */
+                                id: string;
+                                /** ProcessorProvider ID that creates this processor */
+                                providerId: string;
+                                /** Configuration matching the provider configSchema */
+                                config: {
+                                    [key: string]: unknown;
+                                };
+                                /** Which processor phases to enable */
+                                enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                            };
+                        }[];
+                        rules?: {
+                            operator: 'AND' | 'OR';
+                            conditions: ({
+                                field: string;
+                                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                value?: unknown | undefined;
+                            } | {
+                                operator: 'AND' | 'OR';
+                                conditions: ({
+                                    field: string;
+                                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                    value?: unknown | undefined;
+                                } | {
+                                    operator: 'AND' | 'OR';
+                                    conditions: {
+                                        field: string;
+                                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                        value?: unknown | undefined;
+                                    }[];
+                                })[];
+                            })[];
+                        } | undefined;
+                    }[];
+                })[][];
+            } | {
+                type: 'conditional';
+                conditions: {
+                    steps: ({
+                        type: 'step';
+                        step: {
+                            /** Unique ID for this step within the graph */
+                            id: string;
+                            /** ProcessorProvider ID that creates this processor */
+                            providerId: string;
+                            /** Configuration matching the provider configSchema */
+                            config: {
+                                [key: string]: unknown;
+                            };
+                            /** Which processor phases to enable */
+                            enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                        };
+                    } | {
+                        type: 'parallel';
+                        branches: {
+                            type: 'step';
+                            step: {
+                                /** Unique ID for this step within the graph */
+                                id: string;
+                                /** ProcessorProvider ID that creates this processor */
+                                providerId: string;
+                                /** Configuration matching the provider configSchema */
+                                config: {
+                                    [key: string]: unknown;
+                                };
+                                /** Which processor phases to enable */
+                                enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                            };
+                        }[][];
+                    } | {
+                        type: 'conditional';
+                        conditions: {
+                            steps: {
+                                type: 'step';
+                                step: {
+                                    /** Unique ID for this step within the graph */
+                                    id: string;
+                                    /** ProcessorProvider ID that creates this processor */
+                                    providerId: string;
+                                    /** Configuration matching the provider configSchema */
+                                    config: {
+                                        [key: string]: unknown;
+                                    };
+                                    /** Which processor phases to enable */
+                                    enabledPhases: ('processInput' | 'processInputStep' | 'processOutputStream' | 'processOutputResult' | 'processOutputStep')[];
+                                };
+                            }[];
+                            rules?: {
+                                operator: 'AND' | 'OR';
+                                conditions: ({
+                                    field: string;
+                                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                    value?: unknown | undefined;
+                                } | {
+                                    operator: 'AND' | 'OR';
+                                    conditions: ({
+                                        field: string;
+                                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                        value?: unknown | undefined;
+                                    } | {
+                                        operator: 'AND' | 'OR';
+                                        conditions: {
+                                            field: string;
+                                            operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                            value?: unknown | undefined;
+                                        }[];
+                                    })[];
+                                })[];
+                            } | undefined;
+                        }[];
+                    })[];
+                    rules?: {
+                        operator: 'AND' | 'OR';
+                        conditions: ({
+                            field: string;
+                            operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                            value?: unknown | undefined;
+                        } | {
+                            operator: 'AND' | 'OR';
+                            conditions: ({
+                                field: string;
+                                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                value?: unknown | undefined;
+                            } | {
+                                operator: 'AND' | 'OR';
+                                conditions: {
+                                    field: string;
+                                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                    value?: unknown | undefined;
+                                }[];
+                            })[];
+                        })[];
+                    } | undefined;
+                }[];
+            })[];
+        };
+        rules?: {
+            operator: 'AND' | 'OR';
+            conditions: ({
+                field: string;
+                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                value?: unknown | undefined;
+            } | {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: {
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+    }[]) | undefined;
+    /** Memory configuration — static or conditional */
+    memory?: ({
+        /** Vector database identifier or false to disable */
+        vector?: (string | false) | undefined;
+        /** Memory behavior configuration, excluding workingMemory and threads */
+        options?: {
+            readOnly?: boolean | undefined;
+            lastMessages?: (number | false) | undefined;
+            semanticRecall?: (boolean | {
+                /** Number of semantically similar messages to retrieve */
+                topK: number;
+                /** Amount of surrounding context to include with each retrieved message */
+                messageRange: number | {
+                    before: number;
+                    after: number;
+                };
+                /** Scope for semantic search queries */
+                scope?: ('thread' | 'resource') | undefined;
+                /** Minimum similarity score threshold */
+                threshold?: number | undefined;
+                /** Index name for the vector store */
+                indexName?: string | undefined;
+            }) | undefined;
+            generateTitle?: (boolean | {
+                /** Model ID in format provider/model-name (ModelRouterModelId) */
+                model: string;
+                /** Custom instructions for title generation */
+                instructions?: string | undefined;
+            }) | undefined;
+        } | undefined;
+        /** Embedding model ID in the format "provider/model" (e.g., "openai/text-embedding-3-small") */
+        embedder?: string | undefined;
+        /** Options to pass to the embedder, omitting telemetry */
+        embedderOptions?: {
+            [key: string]: unknown;
+        } | undefined;
+        /** Serialized observational memory configuration */
+        observationalMemory?: (boolean | {
+            /** Model ID for both Observer and Reflector */
+            model?: string | undefined;
+            /** Memory scope */
+            scope?: ('resource' | 'thread') | undefined;
+            /** Share token budget between messages and observations */
+            shareTokenBudget?: boolean | undefined;
+            /** Observation step configuration */
+            observation?: {
+                /** Observer model ID */
+                model?: string | undefined;
+                /** Token threshold that triggers observation */
+                messageTokens?: number | undefined;
+                /** Model settings (temperature, etc.) */
+                modelSettings?: {
+                    [key: string]: unknown;
+                } | undefined;
+                /** Provider-specific options */
+                providerOptions?: {
+                    [key: string]: {
+                        [key: string]: unknown;
+                    } | undefined;
+                } | undefined;
+                /** Maximum tokens per batch */
+                maxTokensPerBatch?: number | undefined;
+                /** Async buffering interval or false */
+                bufferTokens?: (number | false) | undefined;
+                /** Ratio of buffered observations to activate */
+                bufferActivation?: number | undefined;
+                /** Token threshold for synchronous blocking */
+                blockAfter?: number | undefined;
+            } | undefined;
+            /** Reflection step configuration */
+            reflection?: {
+                /** Reflector model ID */
+                model?: string | undefined;
+                /** Token threshold that triggers reflection */
+                observationTokens?: number | undefined;
+                /** Model settings (temperature, etc.) */
+                modelSettings?: {
+                    [key: string]: unknown;
+                } | undefined;
+                /** Provider-specific options */
+                providerOptions?: {
+                    [key: string]: {
+                        [key: string]: unknown;
+                    } | undefined;
+                } | undefined;
+                /** Token threshold for synchronous blocking */
+                blockAfter?: number | undefined;
+                /** Ratio for async reflection buffering */
+                bufferActivation?: number | undefined;
+            } | undefined;
+        }) | undefined;
+    } | {
+        value: {
+            /** Vector database identifier or false to disable */
+            vector?: (string | false) | undefined;
+            /** Memory behavior configuration, excluding workingMemory and threads */
+            options?: {
+                readOnly?: boolean | undefined;
+                lastMessages?: (number | false) | undefined;
+                semanticRecall?: (boolean | {
+                    /** Number of semantically similar messages to retrieve */
+                    topK: number;
+                    /** Amount of surrounding context to include with each retrieved message */
+                    messageRange: number | {
+                        before: number;
+                        after: number;
+                    };
+                    /** Scope for semantic search queries */
+                    scope?: ('thread' | 'resource') | undefined;
+                    /** Minimum similarity score threshold */
+                    threshold?: number | undefined;
+                    /** Index name for the vector store */
+                    indexName?: string | undefined;
+                }) | undefined;
+                generateTitle?: (boolean | {
+                    /** Model ID in format provider/model-name (ModelRouterModelId) */
+                    model: string;
+                    /** Custom instructions for title generation */
+                    instructions?: string | undefined;
+                }) | undefined;
+            } | undefined;
+            /** Embedding model ID in the format "provider/model" (e.g., "openai/text-embedding-3-small") */
+            embedder?: string | undefined;
+            /** Options to pass to the embedder, omitting telemetry */
+            embedderOptions?: {
+                [key: string]: unknown;
+            } | undefined;
+            /** Serialized observational memory configuration */
+            observationalMemory?: (boolean | {
+                /** Model ID for both Observer and Reflector */
+                model?: string | undefined;
+                /** Memory scope */
+                scope?: ('resource' | 'thread') | undefined;
+                /** Share token budget between messages and observations */
+                shareTokenBudget?: boolean | undefined;
+                /** Observation step configuration */
+                observation?: {
+                    /** Observer model ID */
+                    model?: string | undefined;
+                    /** Token threshold that triggers observation */
+                    messageTokens?: number | undefined;
+                    /** Model settings (temperature, etc.) */
+                    modelSettings?: {
+                        [key: string]: unknown;
+                    } | undefined;
+                    /** Provider-specific options */
+                    providerOptions?: {
+                        [key: string]: {
+                            [key: string]: unknown;
+                        } | undefined;
+                    } | undefined;
+                    /** Maximum tokens per batch */
+                    maxTokensPerBatch?: number | undefined;
+                    /** Async buffering interval or false */
+                    bufferTokens?: (number | false) | undefined;
+                    /** Ratio of buffered observations to activate */
+                    bufferActivation?: number | undefined;
+                    /** Token threshold for synchronous blocking */
+                    blockAfter?: number | undefined;
+                } | undefined;
+                /** Reflection step configuration */
+                reflection?: {
+                    /** Reflector model ID */
+                    model?: string | undefined;
+                    /** Token threshold that triggers reflection */
+                    observationTokens?: number | undefined;
+                    /** Model settings (temperature, etc.) */
+                    modelSettings?: {
+                        [key: string]: unknown;
+                    } | undefined;
+                    /** Provider-specific options */
+                    providerOptions?: {
+                        [key: string]: {
+                            [key: string]: unknown;
+                        } | undefined;
+                    } | undefined;
+                    /** Token threshold for synchronous blocking */
+                    blockAfter?: number | undefined;
+                    /** Ratio for async reflection buffering */
+                    bufferActivation?: number | undefined;
+                } | undefined;
+            }) | undefined;
+        };
+        rules?: {
+            operator: 'AND' | 'OR';
+            conditions: ({
+                field: string;
+                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                value?: unknown | undefined;
+            } | {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: {
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+    }[]) | undefined;
+    /** Scorer keys with optional sampling config — static or conditional */
+    scorers?: ({
+        [key: string]: {
+            description?: string | undefined;
+            sampling?: ({
+                type: 'none';
+            } | {
+                type: 'ratio';
+                rate: number;
+            }) | undefined;
+            rules?: {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: ({
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    } | {
+                        operator: 'AND' | 'OR';
+                        conditions: {
+                            field: string;
+                            operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                            value?: unknown | undefined;
+                        }[];
+                    })[];
+                })[];
+            } | undefined;
+        };
+    } | {
+        value: {
+            [key: string]: {
+                description?: string | undefined;
+                sampling?: ({
+                    type: 'none';
+                } | {
+                    type: 'ratio';
+                    rate: number;
+                }) | undefined;
+                rules?: {
+                    operator: 'AND' | 'OR';
+                    conditions: ({
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    } | {
+                        operator: 'AND' | 'OR';
+                        conditions: ({
+                            field: string;
+                            operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                            value?: unknown | undefined;
+                        } | {
+                            operator: 'AND' | 'OR';
+                            conditions: {
+                                field: string;
+                                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                value?: unknown | undefined;
+                            }[];
+                        })[];
+                    })[];
+                } | undefined;
+            };
+        };
+        rules?: {
+            operator: 'AND' | 'OR';
+            conditions: ({
+                field: string;
+                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                value?: unknown | undefined;
+            } | {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: {
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+    }[]) | undefined;
+    /** Skill IDs mapped to per-skill config — static or conditional */
+    skills?: ({
+        [key: string]: {
+            description?: string | undefined;
+            instructions?: string | undefined;
+            pin?: string | undefined;
+            strategy?: ('latest' | 'live') | undefined;
+        };
+    } | {
+        value: {
+            [key: string]: {
+                description?: string | undefined;
+                instructions?: string | undefined;
+                pin?: string | undefined;
+                strategy?: ('latest' | 'live') | undefined;
+            };
+        };
+        rules?: {
+            operator: 'AND' | 'OR';
+            conditions: ({
+                field: string;
+                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                value?: unknown | undefined;
+            } | {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: {
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+    }[]) | undefined;
+    /** Workspace reference (stored ID or inline config) — static or conditional */
+    workspace?: (({
+        type: 'id';
+        workspaceId: string;
+    } | {
+        type: 'inline';
+        config: {
+            /** Name of the workspace */
+            name: string;
+            /** Description of the workspace */
+            description?: string | undefined;
+            /** Filesystem configuration */
+            filesystem?: {
+                /** Filesystem provider name */
+                provider: string;
+                /** Filesystem provider configuration */
+                config: {
+                    [key: string]: unknown;
+                };
+            } | undefined;
+            /** Sandbox configuration */
+            sandbox?: {
+                /** Sandbox provider name */
+                provider: string;
+                /** Sandbox provider configuration */
+                config: {
+                    [key: string]: unknown;
+                };
+            } | undefined;
+            /** Mounted filesystems keyed by mount path */
+            mounts?: {
+                [key: string]: {
+                    /** Filesystem provider name */
+                    provider: string;
+                    /** Filesystem provider configuration */
+                    config: {
+                        [key: string]: unknown;
+                    };
+                };
+            } | undefined;
+            /** Search configuration */
+            search?: {
+                /** Vector store provider identifier */
+                vectorProvider?: string | undefined;
+                /** Vector store provider-specific configuration */
+                vectorConfig?: {
+                    [key: string]: unknown;
+                } | undefined;
+                /** Embedder provider identifier */
+                embedderProvider?: string | undefined;
+                /** Embedder model name */
+                embedderModel?: string | undefined;
+                /** Embedder provider-specific configuration */
+                embedderConfig?: {
+                    [key: string]: unknown;
+                } | undefined;
+                /** BM25 keyword search config */
+                bm25?: (boolean | {
+                    k1?: number | undefined;
+                    b?: number | undefined;
+                }) | undefined;
+                /** Custom index name for the vector store */
+                searchIndexName?: string | undefined;
+                /** Paths to auto-index on init */
+                autoIndexPaths?: string[] | undefined;
+            } | undefined;
+            /** Array of skill IDs */
+            skills?: string[] | undefined;
+            /** Workspace tool configuration */
+            tools?: {
+                /** Default: whether all tools are enabled */
+                enabled?: boolean | undefined;
+                /** Default: whether all tools require user approval */
+                requireApproval?: boolean | undefined;
+                /** Per-tool overrides keyed by workspace tool name */
+                tools?: {
+                    [key: string]: {
+                        /** Whether the tool is enabled */
+                        enabled?: boolean | undefined;
+                        /** Whether the tool requires user approval before execution */
+                        requireApproval?: boolean | undefined;
+                        /** For write tools: require reading a file before writing to it */
+                        requireReadBeforeWrite?: boolean | undefined;
+                    };
+                } | undefined;
+            } | undefined;
+            /** Whether to automatically sync the workspace */
+            autoSync?: boolean | undefined;
+            /** Operation timeout in milliseconds */
+            operationTimeout?: number | undefined;
+        };
+    }) | {
+        value: {
+            type: 'id';
+            workspaceId: string;
+        } | {
+            type: 'inline';
+            config: {
+                /** Name of the workspace */
+                name: string;
+                /** Description of the workspace */
+                description?: string | undefined;
+                /** Filesystem configuration */
+                filesystem?: {
+                    /** Filesystem provider name */
+                    provider: string;
+                    /** Filesystem provider configuration */
+                    config: {
+                        [key: string]: unknown;
+                    };
+                } | undefined;
+                /** Sandbox configuration */
+                sandbox?: {
+                    /** Sandbox provider name */
+                    provider: string;
+                    /** Sandbox provider configuration */
+                    config: {
+                        [key: string]: unknown;
+                    };
+                } | undefined;
+                /** Mounted filesystems keyed by mount path */
+                mounts?: {
+                    [key: string]: {
+                        /** Filesystem provider name */
+                        provider: string;
+                        /** Filesystem provider configuration */
+                        config: {
+                            [key: string]: unknown;
+                        };
+                    };
+                } | undefined;
+                /** Search configuration */
+                search?: {
+                    /** Vector store provider identifier */
+                    vectorProvider?: string | undefined;
+                    /** Vector store provider-specific configuration */
+                    vectorConfig?: {
+                        [key: string]: unknown;
+                    } | undefined;
+                    /** Embedder provider identifier */
+                    embedderProvider?: string | undefined;
+                    /** Embedder model name */
+                    embedderModel?: string | undefined;
+                    /** Embedder provider-specific configuration */
+                    embedderConfig?: {
+                        [key: string]: unknown;
+                    } | undefined;
+                    /** BM25 keyword search config */
+                    bm25?: (boolean | {
+                        k1?: number | undefined;
+                        b?: number | undefined;
+                    }) | undefined;
+                    /** Custom index name for the vector store */
+                    searchIndexName?: string | undefined;
+                    /** Paths to auto-index on init */
+                    autoIndexPaths?: string[] | undefined;
+                } | undefined;
+                /** Array of skill IDs */
+                skills?: string[] | undefined;
+                /** Workspace tool configuration */
+                tools?: {
+                    /** Default: whether all tools are enabled */
+                    enabled?: boolean | undefined;
+                    /** Default: whether all tools require user approval */
+                    requireApproval?: boolean | undefined;
+                    /** Per-tool overrides keyed by workspace tool name */
+                    tools?: {
+                        [key: string]: {
+                            /** Whether the tool is enabled */
+                            enabled?: boolean | undefined;
+                            /** Whether the tool requires user approval before execution */
+                            requireApproval?: boolean | undefined;
+                            /** For write tools: require reading a file before writing to it */
+                            requireReadBeforeWrite?: boolean | undefined;
+                        };
+                    } | undefined;
+                } | undefined;
+                /** Whether to automatically sync the workspace */
+                autoSync?: boolean | undefined;
+                /** Operation timeout in milliseconds */
+                operationTimeout?: number | undefined;
+            };
+        };
+        rules?: {
+            operator: 'AND' | 'OR';
+            conditions: ({
+                field: string;
+                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                value?: unknown | undefined;
+            } | {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: {
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+    }[]) | undefined;
+    /** Browser configuration — object config, true (apply default), false/null (disable) */
+    browser?: (({
+        type: 'inline';
+        config: {
+            /** Browser provider type (e.g., stagehand, playwright) */
+            provider: string;
+            /** Run browser in headless mode (default: true) */
+            headless?: boolean | undefined;
+            /** Browser viewport dimensions */
+            viewport?: {
+                /** Viewport width in pixels */
+                width: number;
+                /** Viewport height in pixels */
+                height: number;
+            } | undefined;
+            /** Default timeout in milliseconds (default: 10000) */
+            timeout?: number | undefined;
+            /** Screencast options for streaming browser frames */
+            screencast?: {
+                /** Image format (default: jpeg) */
+                format?: ('jpeg' | 'png') | undefined;
+                /** JPEG quality 0-100 (default: 80) */
+                quality?: number | undefined;
+                /** Max width in pixels (default: 1280) */
+                maxWidth?: number | undefined;
+                /** Max height in pixels (default: 720) */
+                maxHeight?: number | undefined;
+                /** Capture every Nth frame (default: 1) */
+                everyNthFrame?: number | undefined;
+            } | undefined;
+        };
+    } | {
+        value: {
+            type: 'inline';
+            config: {
+                /** Browser provider type (e.g., stagehand, playwright) */
+                provider: string;
+                /** Run browser in headless mode (default: true) */
+                headless?: boolean | undefined;
+                /** Browser viewport dimensions */
+                viewport?: {
+                    /** Viewport width in pixels */
+                    width: number;
+                    /** Viewport height in pixels */
+                    height: number;
+                } | undefined;
+                /** Default timeout in milliseconds (default: 10000) */
+                timeout?: number | undefined;
+                /** Screencast options for streaming browser frames */
+                screencast?: {
+                    /** Image format (default: jpeg) */
+                    format?: ('jpeg' | 'png') | undefined;
+                    /** JPEG quality 0-100 (default: 80) */
+                    quality?: number | undefined;
+                    /** Max width in pixels (default: 1280) */
+                    maxWidth?: number | undefined;
+                    /** Max height in pixels (default: 720) */
+                    maxHeight?: number | undefined;
+                    /** Capture every Nth frame (default: 1) */
+                    everyNthFrame?: number | undefined;
+                } | undefined;
+            };
+        };
+        rules?: {
+            operator: 'AND' | 'OR';
+            conditions: ({
+                field: string;
+                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                value?: unknown | undefined;
+            } | {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: {
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+    }[]) | boolean | null) | undefined;
+    /** JSON Schema defining valid request context variables */
+    requestContextSchema?: {
+        [key: string]: unknown;
+    } | undefined;
+};
+export type GetStoredAgentsStoredAgentId_Request = Simplify<(GetStoredAgentsStoredAgentId_PathParams extends never ? {} : {
+    params: GetStoredAgentsStoredAgentId_PathParams;
+}) & (GetStoredAgentsStoredAgentId_QueryParams extends never ? {} : {} extends GetStoredAgentsStoredAgentId_QueryParams ? {
+    query?: GetStoredAgentsStoredAgentId_QueryParams;
+} : {
+    query: GetStoredAgentsStoredAgentId_QueryParams;
+}) & (never extends never ? {} : {} extends never ? {
+    body?: never;
+} : {
+    body: never;
+})>;
+export interface GetStoredAgentsStoredAgentId_RouteContract {
+    pathParams: GetStoredAgentsStoredAgentId_PathParams;
+    queryParams: GetStoredAgentsStoredAgentId_QueryParams;
+    body: never;
+    request: GetStoredAgentsStoredAgentId_Request;
+    response: GetStoredAgentsStoredAgentId_Response;
+    responseType: 'json';
+}
+export type PostStoredAgents_Body = {
+    /** Unique identifier for the agent. If not provided, derived from name. */
+    id?: string | undefined;
+    /** Author identifier for multi-tenant filtering */
+    authorId?: string | undefined;
+    /** Additional metadata for the agent */
+    metadata?: {
+        [key: string]: unknown;
+    } | undefined;
+    /** Agent visibility: private (owner/admin only) or public (any reader) */
+    visibility?: ('private' | 'public') | undefined;
+    /** Name of the agent */
+    name: string;
+    /** Description of the agent */
+    description?: string | undefined;
+    /** System instructions for the agent (string or array of instruction blocks) */
+    instructions: string | ({
+        type: 'text';
+        content: string;
+    } | {
+        type: 'prompt_block_ref';
+        id: string;
+    } | {
+        type: 'prompt_block';
+        content: string;
+        rules?: {
+            operator: 'AND' | 'OR';
+            conditions: ({
+                field: string;
+                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                value?: unknown | undefined;
+            } | {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: {
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+    })[];
+    /** Model configuration — static value or array of conditional variants. When omitted, the builder default model is applied server-side. */
+    model?: ({
+        /** Model provider (e.g., openai, anthropic) */
+        provider: string;
+        /** Model name (e.g., gpt-4o, claude-3-opus) */
+        name: string;
+        [x: string]: unknown;
+    } | {
+        value: {
+            /** Model provider (e.g., openai, anthropic) */
+            provider: string;
+            /** Model name (e.g., gpt-4o, claude-3-opus) */
+            name: string;
+            [x: string]: unknown;
+        };
+        rules?: {
+            operator: 'AND' | 'OR';
+            conditions: ({
+                field: string;
+                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                value?: unknown | undefined;
+            } | {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: {
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+    }[]) | undefined;
+    /** Tool keys mapped to per-tool config — static or conditional */
+    tools?: ({
+        [key: string]: {
+            description?: string | undefined;
+            rules?: {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: ({
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    } | {
+                        operator: 'AND' | 'OR';
+                        conditions: {
+                            field: string;
+                            operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                            value?: unknown | undefined;
+                        }[];
+                    })[];
+                })[];
+            } | undefined;
+        };
+    } | {
+        value: {
+            [key: string]: {
+                description?: string | undefined;
+                rules?: {
+                    operator: 'AND' | 'OR';
+                    conditions: ({
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    } | {
+                        operator: 'AND' | 'OR';
+                        conditions: ({
+                            field: string;
+                            operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                            value?: unknown | undefined;
+                        } | {
+                            operator: 'AND' | 'OR';
+                            conditions: {
+                                field: string;
+                                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                value?: unknown | undefined;
+                            }[];
+                        })[];
+                    })[];
+                } | undefined;
+            };
+        };
+        rules?: {
+            operator: 'AND' | 'OR';
+            conditions: ({
+                field: string;
+                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                value?: unknown | undefined;
+            } | {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: {
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+    }[]) | undefined;
+    /** Default options for generate/stream calls — static or conditional */
+    defaultOptions?: ({
+        runId?: string | undefined;
+        savePerStep?: boolean | undefined;
+        maxSteps?: number | undefined;
+        activeTools?: string[] | undefined;
+        maxProcessorRetries?: number | undefined;
+        toolChoice?: ('auto' | 'none' | 'required' | {
+            type: 'tool';
+            toolName: string;
+        }) | undefined;
+        modelSettings?: {
+            temperature?: number | undefined;
+            maxTokens?: number | undefined;
+            topP?: number | undefined;
+            topK?: number | undefined;
+            frequencyPenalty?: number | undefined;
+            presencePenalty?: number | undefined;
+            stopSequences?: string[] | undefined;
+            seed?: number | undefined;
+            maxRetries?: number | undefined;
+        } | undefined;
+        returnScorerData?: boolean | undefined;
+        tracingOptions?: {
+            traceName?: string | undefined;
+            attributes?: {
+                [key: string]: unknown;
+            } | undefined;
+            spanId?: string | undefined;
+            traceId?: string | undefined;
+        } | undefined;
+        requireToolApproval?: boolean | undefined;
+        autoResumeSuspendedTools?: boolean | undefined;
+        toolCallConcurrency?: number | undefined;
+        includeRawChunks?: boolean | undefined;
+        [x: string]: unknown;
+    } | {
+        /** Default options for agent execution */
+        value: {
+            runId?: string | undefined;
+            savePerStep?: boolean | undefined;
+            maxSteps?: number | undefined;
+            activeTools?: string[] | undefined;
+            maxProcessorRetries?: number | undefined;
+            toolChoice?: ('auto' | 'none' | 'required' | {
+                type: 'tool';
+                toolName: string;
+            }) | undefined;
+            modelSettings?: {
+                temperature?: number | undefined;
+                maxTokens?: number | undefined;
+                topP?: number | undefined;
+                topK?: number | undefined;
+                frequencyPenalty?: number | undefined;
+                presencePenalty?: number | undefined;
+                stopSequences?: string[] | undefined;
+                seed?: number | undefined;
+                maxRetries?: number | undefined;
+            } | undefined;
+            returnScorerData?: boolean | undefined;
+            tracingOptions?: {
+                traceName?: string | undefined;
+                attributes?: {
+                    [key: string]: unknown;
+                } | undefined;
+                spanId?: string | undefined;
+                traceId?: string | undefined;
+            } | undefined;
+            requireToolApproval?: boolean | undefined;
+            autoResumeSuspendedTools?: boolean | undefined;
+            toolCallConcurrency?: number | undefined;
+            includeRawChunks?: boolean | undefined;
+            [x: string]: unknown;
+        };
+        rules?: {
+            operator: 'AND' | 'OR';
+            conditions: ({
+                field: string;
+                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                value?: unknown | undefined;
+            } | {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: {
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+    }[]) | undefined;
+    /** Workflow keys with optional per-workflow config — static or conditional */
+    workflows?: ({
+        [key: string]: {
+            description?: string | undefined;
+            rules?: {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: ({
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    } | {
+                        operator: 'AND' | 'OR';
+                        conditions: {
+                            field: string;
+                            operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                            value?: unknown | undefined;
+                        }[];
+                    })[];
+                })[];
+            } | undefined;
+        };
+    } | {
+        value: {
+            [key: string]: {
+                description?: string | undefined;
+                rules?: {
+                    operator: 'AND' | 'OR';
+                    conditions: ({
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    } | {
+                        operator: 'AND' | 'OR';
+                        conditions: ({
+                            field: string;
+                            operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                            value?: unknown | undefined;
+                        } | {
+                            operator: 'AND' | 'OR';
+                            conditions: {
+                                field: string;
+                                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                value?: unknown | undefined;
+                            }[];
+                        })[];
+                    })[];
+                } | undefined;
+            };
+        };
+        rules?: {
+            operator: 'AND' | 'OR';
+            conditions: ({
+                field: string;
+                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                value?: unknown | undefined;
+            } | {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: {
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+    }[]) | undefined;
+    /** Agent keys with optional per-agent config — static or conditional */
+    agents?: ({
+        [key: string]: {
+            description?: string | undefined;
+            rules?: {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: ({
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    } | {
+                        operator: 'AND' | 'OR';
+                        conditions: {
+                            field: string;
+                            operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                            value?: unknown | undefined;
+                        }[];
+                    })[];
+                })[];
+            } | undefined;
+        };
+    } | {
+        value: {
+            [key: string]: {
+                description?: string | undefined;
+                rules?: {
+                    operator: 'AND' | 'OR';
+                    conditions: ({
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    } | {
+                        operator: 'AND' | 'OR';
+                        conditions: ({
+                            field: string;
+                            operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                            value?: unknown | undefined;
+                        } | {
+                            operator: 'AND' | 'OR';
+                            conditions: {
+                                field: string;
+                                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                value?: unknown | undefined;
+                            }[];
+                        })[];
+                    })[];
+                } | undefined;
+            };
+        };
+        rules?: {
+            operator: 'AND' | 'OR';
+            conditions: ({
+                field: string;
+                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                value?: unknown | undefined;
+            } | {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: {
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+    }[]) | undefined;
+    /** Map of tool provider IDs to their tool configurations — static or conditional */
+    integrationTools?: ({
+        [key: string]: {
+            tools?: {
+                [key: string]: {
+                    description?: string | undefined;
+                    rules?: {
+                        operator: 'AND' | 'OR';
+                        conditions: ({
+                            field: string;
+                            operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                            value?: unknown | undefined;
+                        } | {
+                            operator: 'AND' | 'OR';
+                            conditions: ({
+                                field: string;
+                                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                value?: unknown | undefined;
+                            } | {
+                                operator: 'AND' | 'OR';
+                                conditions: {
+                                    field: string;
+                                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                    value?: unknown | undefined;
+                                }[];
+                            })[];
+                        })[];
+                    } | undefined;
+                };
+            } | undefined;
+        };
+    } | {
+        value: {
+            [key: string]: {
+                tools?: {
+                    [key: string]: {
+                        description?: string | undefined;
+                        rules?: {
+                            operator: 'AND' | 'OR';
+                            conditions: ({
+                                field: string;
+                                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                value?: unknown | undefined;
+                            } | {
+                                operator: 'AND' | 'OR';
+                                conditions: ({
+                                    field: string;
+                                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                    value?: unknown | undefined;
+                                } | {
+                                    operator: 'AND' | 'OR';
+                                    conditions: {
+                                        field: string;
+                                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                                        value?: unknown | undefined;
+                                    }[];
+                                })[];
+                            })[];
+                        } | undefined;
+                    };
+                } | undefined;
+            };
+        };
+        rules?: {
+            operator: 'AND' | 'OR';
+            conditions: ({
+                field: string;
+                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                value?: unknown | undefined;
+            } | {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: {
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+    }[]) | undefined;
+    /** Tool provider connections and per-tool config (provider-agnostic). Coexists with the deprecated `integrationTools` field. */
+    toolProviders?: ({
+        [key: string]: {
+            tools: {
+                [key: string]: {
+                    toolkit?: string | undefined;
+                    description?: string | undefined;
+                };
+            };
+            connections: {
+                [key: string]: {
+                    kind: 'author' | 'invoker' | 'platform';
+                    toolkit: string;
+                    connectionId: string;
+                    label?: string | undefined;
+                    scope?: ('shared' | 'per-author' | 'caller-supplied') | undefined;
+                }[];
+            };
+        };
+    } | {
+        value: {
+            [key: string]: {
+                tools: {
+                    [key: string]: {
+                        toolkit?: string | undefined;
+                        description?: string | undefined;
+                    };
+                };
+                connections: {
+                    [key: string]: {
+                        kind: 'author' | 'invoker' | 'platform';
+                        toolkit: string;
+                        connectionId: string;
+                        label?: string | undefined;
+                        scope?: ('shared' | 'per-author' | 'caller-supplied') | undefined;
+                    }[];
+                };
+            };
+        };
+        rules?: {
+            operator: 'AND' | 'OR';
+            conditions: ({
+                field: string;
+                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                value?: unknown | undefined;
+            } | {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: {
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+    }[]) | undefined;
     /** Map of stored MCP client IDs to their tool configurations — static or conditional */
     mcpClients?: ({
         [key: string]: {
@@ -20418,6 +22782,68 @@ export type PostStoredAgents_Response = {
             })[];
         } | undefined;
     }[]) | undefined;
+    /** Tool provider connections and per-tool config (provider-agnostic). Coexists with the deprecated `integrationTools` field. */
+    toolProviders?: ({
+        [key: string]: {
+            tools: {
+                [key: string]: {
+                    toolkit?: string | undefined;
+                    description?: string | undefined;
+                };
+            };
+            connections: {
+                [key: string]: {
+                    kind: 'author' | 'invoker' | 'platform';
+                    toolkit: string;
+                    connectionId: string;
+                    label?: string | undefined;
+                    scope?: ('shared' | 'per-author' | 'caller-supplied') | undefined;
+                }[];
+            };
+        };
+    } | {
+        value: {
+            [key: string]: {
+                tools: {
+                    [key: string]: {
+                        toolkit?: string | undefined;
+                        description?: string | undefined;
+                    };
+                };
+                connections: {
+                    [key: string]: {
+                        kind: 'author' | 'invoker' | 'platform';
+                        toolkit: string;
+                        connectionId: string;
+                        label?: string | undefined;
+                        scope?: ('shared' | 'per-author' | 'caller-supplied') | undefined;
+                    }[];
+                };
+            };
+        };
+        rules?: {
+            operator: 'AND' | 'OR';
+            conditions: ({
+                field: string;
+                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                value?: unknown | undefined;
+            } | {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: {
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+    }[]) | undefined;
     /** Map of stored MCP client IDs to their tool configurations — static or conditional */
     mcpClients?: ({
         [key: string]: {
@@ -22465,6 +24891,67 @@ export type PatchStoredAgentsStoredAgentId_Body = {
             })[];
         } | undefined;
     }[]) | undefined) | undefined;
+    toolProviders?: (({
+        [key: string]: {
+            tools: {
+                [key: string]: {
+                    toolkit?: string | undefined;
+                    description?: string | undefined;
+                };
+            };
+            connections: {
+                [key: string]: {
+                    kind: 'author' | 'invoker' | 'platform';
+                    toolkit: string;
+                    connectionId: string;
+                    label?: string | undefined;
+                    scope?: ('shared' | 'per-author' | 'caller-supplied') | undefined;
+                }[];
+            };
+        };
+    } | {
+        value: {
+            [key: string]: {
+                tools: {
+                    [key: string]: {
+                        toolkit?: string | undefined;
+                        description?: string | undefined;
+                    };
+                };
+                connections: {
+                    [key: string]: {
+                        kind: 'author' | 'invoker' | 'platform';
+                        toolkit: string;
+                        connectionId: string;
+                        label?: string | undefined;
+                        scope?: ('shared' | 'per-author' | 'caller-supplied') | undefined;
+                    }[];
+                };
+            };
+        };
+        rules?: {
+            operator: 'AND' | 'OR';
+            conditions: ({
+                field: string;
+                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                value?: unknown | undefined;
+            } | {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: {
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+    }[]) | undefined) | undefined;
     mcpClients?: (({
         [key: string]: {
             tools?: {
@@ -24512,6 +26999,68 @@ export type PatchStoredAgentsStoredAgentId_Response = {
             })[];
         } | undefined;
     }[]) | undefined;
+    /** Tool provider connections and per-tool config (provider-agnostic). Coexists with the deprecated `integrationTools` field. */
+    toolProviders?: ({
+        [key: string]: {
+            tools: {
+                [key: string]: {
+                    toolkit?: string | undefined;
+                    description?: string | undefined;
+                };
+            };
+            connections: {
+                [key: string]: {
+                    kind: 'author' | 'invoker' | 'platform';
+                    toolkit: string;
+                    connectionId: string;
+                    label?: string | undefined;
+                    scope?: ('shared' | 'per-author' | 'caller-supplied') | undefined;
+                }[];
+            };
+        };
+    } | {
+        value: {
+            [key: string]: {
+                tools: {
+                    [key: string]: {
+                        toolkit?: string | undefined;
+                        description?: string | undefined;
+                    };
+                };
+                connections: {
+                    [key: string]: {
+                        kind: 'author' | 'invoker' | 'platform';
+                        toolkit: string;
+                        connectionId: string;
+                        label?: string | undefined;
+                        scope?: ('shared' | 'per-author' | 'caller-supplied') | undefined;
+                    }[];
+                };
+            };
+        };
+        rules?: {
+            operator: 'AND' | 'OR';
+            conditions: ({
+                field: string;
+                operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                value?: unknown | undefined;
+            } | {
+                operator: 'AND' | 'OR';
+                conditions: ({
+                    field: string;
+                    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                    value?: unknown | undefined;
+                } | {
+                    operator: 'AND' | 'OR';
+                    conditions: {
+                        field: string;
+                        operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'greater_than_or_equal' | 'less_than_or_equal' | 'in' | 'not_in' | 'exists' | 'not_exists';
+                        value?: unknown | undefined;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+    }[]) | undefined;
     /** Map of stored MCP client IDs to their tool configurations — static or conditional */
     mcpClients?: ({
         [key: string]: {
@@ -40361,6 +42910,13 @@ export type GetToolProviders_Response = {
         id: string;
         name: string;
         description?: string | undefined;
+        displayName?: string | undefined;
+        capabilities?: {
+            multipleConnectionsPerToolkit: boolean;
+            batchConnectionStatus: boolean;
+            reauthorizeReusesConnectionId: boolean;
+            supportsRevoke?: boolean | undefined;
+        } | undefined;
     }[];
 };
 export type GetToolProviders_Request = Simplify<(never extends never ? {} : {
@@ -40428,7 +42984,7 @@ export type GetToolProvidersProviderIdTools_QueryParams = {
     toolkit?: string | undefined;
     /** Search tools by name or description */
     search?: string | undefined;
-    /** Page number for pagination */
+    /** Page number for pagination (1-indexed) */
     page?: number | undefined;
     /** Number of items per page */
     perPage?: number | undefined;
@@ -40494,6 +43050,340 @@ export interface GetToolProvidersProviderIdToolsToolSlugSchema_RouteContract {
     response: GetToolProvidersProviderIdToolsToolSlugSchema_Response;
     responseType: 'json';
 }
+export type PostToolProvidersProviderIdAuthorize_PathParams = {
+    /** Unique identifier for the tool provider */
+    providerId: string;
+};
+export type PostToolProvidersProviderIdAuthorize_Body = {
+    /** Toolkit slug being authorized */
+    toolkit: string;
+    /** Existing or newly-minted connection bucket id */
+    connectionId: string;
+    /** Optional tool slug for tool-scoped authorization */
+    toolName?: string | undefined;
+    /** Provider-specific user-supplied connection fields (e.g. subdomain) */
+    config?: {
+        [key: string]: unknown;
+    } | undefined;
+    /** Optional human label to persist on the resulting tool_provider_connections row. Must match the stored connection label rules (≤ 32 chars, [A-Za-z0-9 _-]+). */
+    label?: (string | null) | undefined;
+    /** Identity bucket. "shared" pins under SHARED_BUCKET_ID. "caller-supplied" pins under the request-context resourceId (returns 400 when missing). Defaults to "per-author". */
+    scope?: ('shared' | 'per-author' | 'caller-supplied') | undefined;
+};
+export type PostToolProvidersProviderIdAuthorize_Response = {
+    url: string;
+    authId: string;
+};
+export type PostToolProvidersProviderIdAuthorize_Request = Simplify<(PostToolProvidersProviderIdAuthorize_PathParams extends never ? {} : {
+    params: PostToolProvidersProviderIdAuthorize_PathParams;
+}) & (never extends never ? {} : {} extends never ? {
+    query?: never;
+} : {
+    query: never;
+}) & (PostToolProvidersProviderIdAuthorize_Body extends never ? {} : {} extends PostToolProvidersProviderIdAuthorize_Body ? {
+    body?: PostToolProvidersProviderIdAuthorize_Body;
+} : {
+    body: PostToolProvidersProviderIdAuthorize_Body;
+})>;
+export interface PostToolProvidersProviderIdAuthorize_RouteContract {
+    pathParams: PostToolProvidersProviderIdAuthorize_PathParams;
+    queryParams: never;
+    body: PostToolProvidersProviderIdAuthorize_Body;
+    request: PostToolProvidersProviderIdAuthorize_Request;
+    response: PostToolProvidersProviderIdAuthorize_Response;
+    responseType: 'json';
+}
+export type GetToolProvidersProviderIdAuthStatusAuthId_PathParams = {
+    /** Unique identifier for the tool provider */
+    providerId: string;
+    /** Opaque auth handle returned by authorize */
+    authId: string;
+};
+export type GetToolProvidersProviderIdAuthStatusAuthId_Response = {
+    status: 'pending' | 'completed' | 'failed';
+};
+export type GetToolProvidersProviderIdAuthStatusAuthId_Request = Simplify<(GetToolProvidersProviderIdAuthStatusAuthId_PathParams extends never ? {} : {
+    params: GetToolProvidersProviderIdAuthStatusAuthId_PathParams;
+}) & (never extends never ? {} : {} extends never ? {
+    query?: never;
+} : {
+    query: never;
+}) & (never extends never ? {} : {} extends never ? {
+    body?: never;
+} : {
+    body: never;
+})>;
+export interface GetToolProvidersProviderIdAuthStatusAuthId_RouteContract {
+    pathParams: GetToolProvidersProviderIdAuthStatusAuthId_PathParams;
+    queryParams: never;
+    body: never;
+    request: GetToolProvidersProviderIdAuthStatusAuthId_Request;
+    response: GetToolProvidersProviderIdAuthStatusAuthId_Response;
+    responseType: 'json';
+}
+export type PostToolProvidersProviderIdConnectionStatus_PathParams = {
+    /** Unique identifier for the tool provider */
+    providerId: string;
+};
+export type PostToolProvidersProviderIdConnectionStatus_Body = {
+    /** Connection tuples to batch-check */
+    items: {
+        connectionId: string;
+        toolkit: string;
+    }[];
+};
+export type PostToolProvidersProviderIdConnectionStatus_Response = {
+    items: {
+        [key: string]: {
+            connected: boolean;
+        };
+    };
+};
+export type PostToolProvidersProviderIdConnectionStatus_Request = Simplify<(PostToolProvidersProviderIdConnectionStatus_PathParams extends never ? {} : {
+    params: PostToolProvidersProviderIdConnectionStatus_PathParams;
+}) & (never extends never ? {} : {} extends never ? {
+    query?: never;
+} : {
+    query: never;
+}) & (PostToolProvidersProviderIdConnectionStatus_Body extends never ? {} : {} extends PostToolProvidersProviderIdConnectionStatus_Body ? {
+    body?: PostToolProvidersProviderIdConnectionStatus_Body;
+} : {
+    body: PostToolProvidersProviderIdConnectionStatus_Body;
+})>;
+export interface PostToolProvidersProviderIdConnectionStatus_RouteContract {
+    pathParams: PostToolProvidersProviderIdConnectionStatus_PathParams;
+    queryParams: never;
+    body: PostToolProvidersProviderIdConnectionStatus_Body;
+    request: PostToolProvidersProviderIdConnectionStatus_Request;
+    response: PostToolProvidersProviderIdConnectionStatus_Response;
+    responseType: 'json';
+}
+export type GetToolProvidersProviderIdConnections_PathParams = {
+    /** Unique identifier for the tool provider */
+    providerId: string;
+};
+export type GetToolProvidersProviderIdConnections_QueryParams = {
+    /** Toolkit slug whose connections to list */
+    toolkit: string;
+    /** Admin-only: restrict listing to a specific author. Silently ignored for non-admin callers. */
+    authorId?: string | undefined;
+    /** Filter results by scope. Omit to include shared + per-author pins for the caller. */
+    scope?: ('shared' | 'per-author' | 'caller-supplied') | undefined;
+    /** Page number for pagination (1-indexed) */
+    page?: number | undefined;
+    /** Number of items per page (default 50, max 200) */
+    perPage?: number | undefined;
+};
+export type GetToolProvidersProviderIdConnections_Response = {
+    items: {
+        connectionId: string;
+        status: 'active' | 'pending' | 'failed' | 'inactive';
+        createdAt?: string | undefined;
+        /** Persisted display label from tool_provider_connections, if any */
+        label?: (string | null) | undefined;
+        /** Owner of the connection (when known) */
+        authorId?: string | undefined;
+        /** Persisted scope from tool_provider_connections. Missing for rows that predate the scope field. */
+        scope?: ('shared' | 'per-author' | 'caller-supplied') | undefined;
+    }[];
+    pagination?: {
+        total?: number | undefined;
+        page?: number | undefined;
+        perPage?: number | undefined;
+        hasMore: boolean;
+    } | undefined;
+};
+export type GetToolProvidersProviderIdConnections_Request = Simplify<(GetToolProvidersProviderIdConnections_PathParams extends never ? {} : {
+    params: GetToolProvidersProviderIdConnections_PathParams;
+}) & (GetToolProvidersProviderIdConnections_QueryParams extends never ? {} : {} extends GetToolProvidersProviderIdConnections_QueryParams ? {
+    query?: GetToolProvidersProviderIdConnections_QueryParams;
+} : {
+    query: GetToolProvidersProviderIdConnections_QueryParams;
+}) & (never extends never ? {} : {} extends never ? {
+    body?: never;
+} : {
+    body: never;
+})>;
+export interface GetToolProvidersProviderIdConnections_RouteContract {
+    pathParams: GetToolProvidersProviderIdConnections_PathParams;
+    queryParams: GetToolProvidersProviderIdConnections_QueryParams;
+    body: never;
+    request: GetToolProvidersProviderIdConnections_Request;
+    response: GetToolProvidersProviderIdConnections_Response;
+    responseType: 'json';
+}
+export type GetToolProvidersProviderIdConnectionFields_PathParams = {
+    /** Unique identifier for the tool provider */
+    providerId: string;
+};
+export type GetToolProvidersProviderIdConnectionFields_QueryParams = {
+    /** Toolkit slug whose connection field schema to list */
+    toolkit: string;
+};
+export type GetToolProvidersProviderIdConnectionFields_Response = {
+    fields: {
+        name: string;
+        displayName?: string | undefined;
+        description?: string | undefined;
+        type: 'string' | 'number' | 'boolean';
+        required: boolean;
+        default?: unknown | undefined;
+    }[];
+};
+export type GetToolProvidersProviderIdConnectionFields_Request = Simplify<(GetToolProvidersProviderIdConnectionFields_PathParams extends never ? {} : {
+    params: GetToolProvidersProviderIdConnectionFields_PathParams;
+}) & (GetToolProvidersProviderIdConnectionFields_QueryParams extends never ? {} : {} extends GetToolProvidersProviderIdConnectionFields_QueryParams ? {
+    query?: GetToolProvidersProviderIdConnectionFields_QueryParams;
+} : {
+    query: GetToolProvidersProviderIdConnectionFields_QueryParams;
+}) & (never extends never ? {} : {} extends never ? {
+    body?: never;
+} : {
+    body: never;
+})>;
+export interface GetToolProvidersProviderIdConnectionFields_RouteContract {
+    pathParams: GetToolProvidersProviderIdConnectionFields_PathParams;
+    queryParams: GetToolProvidersProviderIdConnectionFields_QueryParams;
+    body: never;
+    request: GetToolProvidersProviderIdConnectionFields_Request;
+    response: GetToolProvidersProviderIdConnectionFields_Response;
+    responseType: 'json';
+}
+export type DeleteToolProvidersProviderIdConnectionsConnectionId_PathParams = {
+    /** Unique identifier for the tool provider */
+    providerId: string;
+    /** Adapter-native connection id (e.g. Composio ca_...) */
+    connectionId: string;
+};
+export type DeleteToolProvidersProviderIdConnectionsConnectionId_QueryParams = {
+    /** When true, revoke at the provider and drop the row even if pinned by agents */
+    force?: (boolean | ('true' | 'false')) | undefined;
+    /** Toolkit slug for the connection (used when the row was upserted with one) */
+    toolkit?: string | undefined;
+};
+export type DeleteToolProvidersProviderIdConnectionsConnectionId_Response = {
+    ok: true;
+    /** Whether the provider-side connection was revoked */
+    revoked: boolean;
+};
+export type DeleteToolProvidersProviderIdConnectionsConnectionId_Request = Simplify<(DeleteToolProvidersProviderIdConnectionsConnectionId_PathParams extends never ? {} : {
+    params: DeleteToolProvidersProviderIdConnectionsConnectionId_PathParams;
+}) & (DeleteToolProvidersProviderIdConnectionsConnectionId_QueryParams extends never ? {} : {} extends DeleteToolProvidersProviderIdConnectionsConnectionId_QueryParams ? {
+    query?: DeleteToolProvidersProviderIdConnectionsConnectionId_QueryParams;
+} : {
+    query: DeleteToolProvidersProviderIdConnectionsConnectionId_QueryParams;
+}) & (never extends never ? {} : {} extends never ? {
+    body?: never;
+} : {
+    body: never;
+})>;
+export interface DeleteToolProvidersProviderIdConnectionsConnectionId_RouteContract {
+    pathParams: DeleteToolProvidersProviderIdConnectionsConnectionId_PathParams;
+    queryParams: DeleteToolProvidersProviderIdConnectionsConnectionId_QueryParams;
+    body: never;
+    request: DeleteToolProvidersProviderIdConnectionsConnectionId_Request;
+    response: DeleteToolProvidersProviderIdConnectionsConnectionId_Response;
+    responseType: 'json';
+}
+export type PatchToolProvidersProviderIdConnectionsConnectionId_PathParams = {
+    /** Unique identifier for the tool provider */
+    providerId: string;
+    /** Adapter-native connection id (e.g. Composio ca_...) */
+    connectionId: string;
+};
+export type PatchToolProvidersProviderIdConnectionsConnectionId_Body = {
+    /** New display label for the connection. Pass null (or empty string) to clear the existing label. */
+    label: string | '' | null;
+};
+export type PatchToolProvidersProviderIdConnectionsConnectionId_Response = {
+    ok: true;
+    /** The persisted label after the update (null when cleared) */
+    label: string | null;
+};
+export type PatchToolProvidersProviderIdConnectionsConnectionId_Request = Simplify<(PatchToolProvidersProviderIdConnectionsConnectionId_PathParams extends never ? {} : {
+    params: PatchToolProvidersProviderIdConnectionsConnectionId_PathParams;
+}) & (never extends never ? {} : {} extends never ? {
+    query?: never;
+} : {
+    query: never;
+}) & (PatchToolProvidersProviderIdConnectionsConnectionId_Body extends never ? {} : {} extends PatchToolProvidersProviderIdConnectionsConnectionId_Body ? {
+    body?: PatchToolProvidersProviderIdConnectionsConnectionId_Body;
+} : {
+    body: PatchToolProvidersProviderIdConnectionsConnectionId_Body;
+})>;
+export interface PatchToolProvidersProviderIdConnectionsConnectionId_RouteContract {
+    pathParams: PatchToolProvidersProviderIdConnectionsConnectionId_PathParams;
+    queryParams: never;
+    body: PatchToolProvidersProviderIdConnectionsConnectionId_Body;
+    request: PatchToolProvidersProviderIdConnectionsConnectionId_Request;
+    response: PatchToolProvidersProviderIdConnectionsConnectionId_Response;
+    responseType: 'json';
+}
+export type GetToolProvidersProviderIdConnectionsConnectionIdUsage_PathParams = {
+    /** Unique identifier for the tool provider */
+    providerId: string;
+    /** Adapter-native connection id (e.g. Composio ca_...) */
+    connectionId: string;
+};
+export type GetToolProvidersProviderIdConnectionsConnectionIdUsage_QueryParams = {
+    /** Optional toolkit slug to scope the usage scan */
+    toolkit?: string | undefined;
+};
+export type GetToolProvidersProviderIdConnectionsConnectionIdUsage_Response = {
+    agents: {
+        id: string;
+        name: string;
+    }[];
+};
+export type GetToolProvidersProviderIdConnectionsConnectionIdUsage_Request = Simplify<(GetToolProvidersProviderIdConnectionsConnectionIdUsage_PathParams extends never ? {} : {
+    params: GetToolProvidersProviderIdConnectionsConnectionIdUsage_PathParams;
+}) & (GetToolProvidersProviderIdConnectionsConnectionIdUsage_QueryParams extends never ? {} : {} extends GetToolProvidersProviderIdConnectionsConnectionIdUsage_QueryParams ? {
+    query?: GetToolProvidersProviderIdConnectionsConnectionIdUsage_QueryParams;
+} : {
+    query: GetToolProvidersProviderIdConnectionsConnectionIdUsage_QueryParams;
+}) & (never extends never ? {} : {} extends never ? {
+    body?: never;
+} : {
+    body: never;
+})>;
+export interface GetToolProvidersProviderIdConnectionsConnectionIdUsage_RouteContract {
+    pathParams: GetToolProvidersProviderIdConnectionsConnectionIdUsage_PathParams;
+    queryParams: GetToolProvidersProviderIdConnectionsConnectionIdUsage_QueryParams;
+    body: never;
+    request: GetToolProvidersProviderIdConnectionsConnectionIdUsage_Request;
+    response: GetToolProvidersProviderIdConnectionsConnectionIdUsage_Response;
+    responseType: 'json';
+}
+export type GetToolProvidersProviderIdHealth_PathParams = {
+    /** Unique identifier for the tool provider */
+    providerId: string;
+};
+export type GetToolProvidersProviderIdHealth_Response = {
+    ok: boolean;
+    message?: string | undefined;
+    details?: {
+        [key: string]: unknown;
+    } | undefined;
+};
+export type GetToolProvidersProviderIdHealth_Request = Simplify<(GetToolProvidersProviderIdHealth_PathParams extends never ? {} : {
+    params: GetToolProvidersProviderIdHealth_PathParams;
+}) & (never extends never ? {} : {} extends never ? {
+    query?: never;
+} : {
+    query: never;
+}) & (never extends never ? {} : {} extends never ? {
+    body?: never;
+} : {
+    body: never;
+})>;
+export interface GetToolProvidersProviderIdHealth_RouteContract {
+    pathParams: GetToolProvidersProviderIdHealth_PathParams;
+    queryParams: never;
+    body: never;
+    request: GetToolProvidersProviderIdHealth_Request;
+    response: GetToolProvidersProviderIdHealth_Response;
+    responseType: 'json';
+}
 export type GetProcessorProviders_Response = {
     providers: {
         id: string;
@@ -40560,6 +43450,7 @@ export type GetSystemPackages_Response = {
     }[];
     isDev: boolean;
     cmsEnabled: boolean;
+    editorSource?: ('code' | 'db') | undefined;
     observabilityEnabled: boolean;
     storageType?: string | undefined;
     observabilityStorageType?: string | undefined;
@@ -44372,6 +47263,7 @@ export interface RouteTypes {
     'POST /mcp/:serverId/messages': PostMcpServerIdMessages_RouteContract;
     'GET /stored/agents': GetStoredAgents_RouteContract;
     'POST /stored/agents/preview-instructions': PostStoredAgentsPreviewInstructions_RouteContract;
+    'POST /stored/agents/:storedAgentId/export': PostStoredAgentsStoredAgentIdExport_RouteContract;
     'GET /stored/agents/:storedAgentId': GetStoredAgentsStoredAgentId_RouteContract;
     'POST /stored/agents': PostStoredAgents_RouteContract;
     'PATCH /stored/agents/:storedAgentId': PatchStoredAgentsStoredAgentId_RouteContract;
@@ -44438,6 +47330,15 @@ export interface RouteTypes {
     'GET /tool-providers/:providerId/toolkits': GetToolProvidersProviderIdToolkits_RouteContract;
     'GET /tool-providers/:providerId/tools': GetToolProvidersProviderIdTools_RouteContract;
     'GET /tool-providers/:providerId/tools/:toolSlug/schema': GetToolProvidersProviderIdToolsToolSlugSchema_RouteContract;
+    'POST /tool-providers/:providerId/authorize': PostToolProvidersProviderIdAuthorize_RouteContract;
+    'GET /tool-providers/:providerId/auth-status/:authId': GetToolProvidersProviderIdAuthStatusAuthId_RouteContract;
+    'POST /tool-providers/:providerId/connection-status': PostToolProvidersProviderIdConnectionStatus_RouteContract;
+    'GET /tool-providers/:providerId/connections': GetToolProvidersProviderIdConnections_RouteContract;
+    'GET /tool-providers/:providerId/connection-fields': GetToolProvidersProviderIdConnectionFields_RouteContract;
+    'DELETE /tool-providers/:providerId/connections/:connectionId': DeleteToolProvidersProviderIdConnectionsConnectionId_RouteContract;
+    'PATCH /tool-providers/:providerId/connections/:connectionId': PatchToolProvidersProviderIdConnectionsConnectionId_RouteContract;
+    'GET /tool-providers/:providerId/connections/:connectionId/usage': GetToolProvidersProviderIdConnectionsConnectionIdUsage_RouteContract;
+    'GET /tool-providers/:providerId/health': GetToolProvidersProviderIdHealth_RouteContract;
     'GET /processor-providers': GetProcessorProviders_RouteContract;
     'GET /processor-providers/:providerId': GetProcessorProvidersProviderId_RouteContract;
     'GET /system/packages': GetSystemPackages_RouteContract;
@@ -45106,6 +48007,9 @@ export interface Client {
         GET: GetStoredAgentsStoredAgentId_RouteContract;
         PATCH: PatchStoredAgentsStoredAgentId_RouteContract;
     };
+    '/stored/agents/:storedAgentId/export': {
+        POST: PostStoredAgentsStoredAgentIdExport_RouteContract;
+    };
     '/stored/agents/:storedAgentId/favorite': {
         DELETE: DeleteStoredAgentsStoredAgentIdFavorite_RouteContract;
         PUT: PutStoredAgentsStoredAgentIdFavorite_RouteContract;
@@ -45225,6 +48129,31 @@ export interface Client {
     '/tool-providers': {
         GET: GetToolProviders_RouteContract;
     };
+    '/tool-providers/:providerId/auth-status/:authId': {
+        GET: GetToolProvidersProviderIdAuthStatusAuthId_RouteContract;
+    };
+    '/tool-providers/:providerId/authorize': {
+        POST: PostToolProvidersProviderIdAuthorize_RouteContract;
+    };
+    '/tool-providers/:providerId/connection-fields': {
+        GET: GetToolProvidersProviderIdConnectionFields_RouteContract;
+    };
+    '/tool-providers/:providerId/connection-status': {
+        POST: PostToolProvidersProviderIdConnectionStatus_RouteContract;
+    };
+    '/tool-providers/:providerId/connections': {
+        GET: GetToolProvidersProviderIdConnections_RouteContract;
+    };
+    '/tool-providers/:providerId/connections/:connectionId': {
+        DELETE: DeleteToolProvidersProviderIdConnectionsConnectionId_RouteContract;
+        PATCH: PatchToolProvidersProviderIdConnectionsConnectionId_RouteContract;
+    };
+    '/tool-providers/:providerId/connections/:connectionId/usage': {
+        GET: GetToolProvidersProviderIdConnectionsConnectionIdUsage_RouteContract;
+    };
+    '/tool-providers/:providerId/health': {
+        GET: GetToolProvidersProviderIdHealth_RouteContract;
+    };
     '/tool-providers/:providerId/toolkits': {
         GET: GetToolProvidersProviderIdToolkits_RouteContract;
     };