@gt-fe/eap-sdk 0.2.18 → 0.2.19

package/dist/schema/graph.d.ts

@@ -0,0 +1,4106 @@
+import { z } from 'zod';
+export declare const GraphNodeSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    retry: z.ZodOptional<z.ZodObject<{
+        maxRetries: z.ZodNumber;
+        backoff: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+            baseDelay: z.ZodNumber;
+            maxDelay: z.ZodNumber;
+            jitter: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        }, {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    }, {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    }>>;
+    interrupt: z.ZodOptional<z.ZodObject<{
+        before: z.ZodOptional<z.ZodBoolean>;
+        after: z.ZodOptional<z.ZodBoolean>;
+        question: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    }, {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    }>>;
+} & {
+    type: z.ZodLiteral<"llm">;
+    config: z.ZodDefault<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        systemPrompt: z.ZodOptional<z.ZodString>;
+        systemPromptFile: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+        outputKey: z.ZodOptional<z.ZodString>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxRetries: z.ZodNumber;
+            backoff: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+                baseDelay: z.ZodNumber;
+                maxDelay: z.ZodNumber;
+                jitter: z.ZodOptional<z.ZodNumber>;
+            }, "strict", z.ZodTypeAny, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }>>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodLiteral<"function">;
+            function: z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, "strict", z.ZodTypeAny, {
+                name: string;
+                description?: string | undefined;
+                parameters?: Record<string, unknown> | undefined;
+            }, {
+                name: string;
+                description?: string | undefined;
+                parameters?: Record<string, unknown> | undefined;
+            }>;
+        }, "strict", z.ZodTypeAny, {
+            function: {
+                name: string;
+                description?: string | undefined;
+                parameters?: Record<string, unknown> | undefined;
+            };
+            type: "function";
+        }, {
+            function: {
+                name: string;
+                description?: string | undefined;
+                parameters?: Record<string, unknown> | undefined;
+            };
+            type: "function";
+        }>, "many">>;
+        toolChoice: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["auto", "none", "required"]>, z.ZodObject<{
+            type: z.ZodLiteral<"function">;
+            function: z.ZodObject<{
+                name: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                name: string;
+            }, {
+                name: string;
+            }>;
+        }, "strict", z.ZodTypeAny, {
+            function: {
+                name: string;
+            };
+            type: "function";
+        }, {
+            function: {
+                name: string;
+            };
+            type: "function";
+        }>]>>;
+        disableTools: z.ZodOptional<z.ZodBoolean>;
+        includeSkillCatalog: z.ZodOptional<z.ZodBoolean>;
+        silent: z.ZodOptional<z.ZodBoolean>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        model: z.ZodOptional<z.ZodString>;
+        systemPrompt: z.ZodOptional<z.ZodString>;
+        systemPromptFile: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+        outputKey: z.ZodOptional<z.ZodString>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxRetries: z.ZodNumber;
+            backoff: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+                baseDelay: z.ZodNumber;
+                maxDelay: z.ZodNumber;
+                jitter: z.ZodOptional<z.ZodNumber>;
+            }, "strict", z.ZodTypeAny, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }>>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodLiteral<"function">;
+            function: z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, "strict", z.ZodTypeAny, {
+                name: string;
+                description?: string | undefined;
+                parameters?: Record<string, unknown> | undefined;
+            }, {
+                name: string;
+                description?: string | undefined;
+                parameters?: Record<string, unknown> | undefined;
+            }>;
+        }, "strict", z.ZodTypeAny, {
+            function: {
+                name: string;
+                description?: string | undefined;
+                parameters?: Record<string, unknown> | undefined;
+            };
+            type: "function";
+        }, {
+            function: {
+                name: string;
+                description?: string | undefined;
+                parameters?: Record<string, unknown> | undefined;
+            };
+            type: "function";
+        }>, "many">>;
+        toolChoice: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["auto", "none", "required"]>, z.ZodObject<{
+            type: z.ZodLiteral<"function">;
+            function: z.ZodObject<{
+                name: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                name: string;
+            }, {
+                name: string;
+            }>;
+        }, "strict", z.ZodTypeAny, {
+            function: {
+                name: string;
+            };
+            type: "function";
+        }, {
+            function: {
+                name: string;
+            };
+            type: "function";
+        }>]>>;
+        disableTools: z.ZodOptional<z.ZodBoolean>;
+        includeSkillCatalog: z.ZodOptional<z.ZodBoolean>;
+        silent: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        model: z.ZodOptional<z.ZodString>;
+        systemPrompt: z.ZodOptional<z.ZodString>;
+        systemPromptFile: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+        outputKey: z.ZodOptional<z.ZodString>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxRetries: z.ZodNumber;
+            backoff: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+                baseDelay: z.ZodNumber;
+                maxDelay: z.ZodNumber;
+                jitter: z.ZodOptional<z.ZodNumber>;
+            }, "strict", z.ZodTypeAny, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }>>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodLiteral<"function">;
+            function: z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, "strict", z.ZodTypeAny, {
+                name: string;
+                description?: string | undefined;
+                parameters?: Record<string, unknown> | undefined;
+            }, {
+                name: string;
+                description?: string | undefined;
+                parameters?: Record<string, unknown> | undefined;
+            }>;
+        }, "strict", z.ZodTypeAny, {
+            function: {
+                name: string;
+                description?: string | undefined;
+                parameters?: Record<string, unknown> | undefined;
+            };
+            type: "function";
+        }, {
+            function: {
+                name: string;
+                description?: string | undefined;
+                parameters?: Record<string, unknown> | undefined;
+            };
+            type: "function";
+        }>, "many">>;
+        toolChoice: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["auto", "none", "required"]>, z.ZodObject<{
+            type: z.ZodLiteral<"function">;
+            function: z.ZodObject<{
+                name: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                name: string;
+            }, {
+                name: string;
+            }>;
+        }, "strict", z.ZodTypeAny, {
+            function: {
+                name: string;
+            };
+            type: "function";
+        }, {
+            function: {
+                name: string;
+            };
+            type: "function";
+        }>]>>;
+        disableTools: z.ZodOptional<z.ZodBoolean>;
+        includeSkillCatalog: z.ZodOptional<z.ZodBoolean>;
+        silent: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, "strict", z.ZodTypeAny, {
+    type: "llm";
+    id: string;
+    config: {
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        model?: string | undefined;
+        systemPrompt?: string | undefined;
+        systemPromptFile?: string | undefined;
+        temperature?: number | undefined;
+        maxTokens?: number | undefined;
+        outputKey?: string | undefined;
+        tools?: {
+            function: {
+                name: string;
+                description?: string | undefined;
+                parameters?: Record<string, unknown> | undefined;
+            };
+            type: "function";
+        }[] | undefined;
+        toolChoice?: "required" | "auto" | "none" | {
+            function: {
+                name: string;
+            };
+            type: "function";
+        } | undefined;
+        disableTools?: boolean | undefined;
+        includeSkillCatalog?: boolean | undefined;
+        silent?: boolean | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    description?: string | undefined;
+    label?: string | undefined;
+    retry?: {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    } | undefined;
+    interrupt?: {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    } | undefined;
+}, {
+    type: "llm";
+    id: string;
+    description?: string | undefined;
+    label?: string | undefined;
+    retry?: {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    } | undefined;
+    interrupt?: {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    } | undefined;
+    config?: z.objectInputType<{
+        model: z.ZodOptional<z.ZodString>;
+        systemPrompt: z.ZodOptional<z.ZodString>;
+        systemPromptFile: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+        outputKey: z.ZodOptional<z.ZodString>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxRetries: z.ZodNumber;
+            backoff: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+                baseDelay: z.ZodNumber;
+                maxDelay: z.ZodNumber;
+                jitter: z.ZodOptional<z.ZodNumber>;
+            }, "strict", z.ZodTypeAny, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }>>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodLiteral<"function">;
+            function: z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, "strict", z.ZodTypeAny, {
+                name: string;
+                description?: string | undefined;
+                parameters?: Record<string, unknown> | undefined;
+            }, {
+                name: string;
+                description?: string | undefined;
+                parameters?: Record<string, unknown> | undefined;
+            }>;
+        }, "strict", z.ZodTypeAny, {
+            function: {
+                name: string;
+                description?: string | undefined;
+                parameters?: Record<string, unknown> | undefined;
+            };
+            type: "function";
+        }, {
+            function: {
+                name: string;
+                description?: string | undefined;
+                parameters?: Record<string, unknown> | undefined;
+            };
+            type: "function";
+        }>, "many">>;
+        toolChoice: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["auto", "none", "required"]>, z.ZodObject<{
+            type: z.ZodLiteral<"function">;
+            function: z.ZodObject<{
+                name: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                name: string;
+            }, {
+                name: string;
+            }>;
+        }, "strict", z.ZodTypeAny, {
+            function: {
+                name: string;
+            };
+            type: "function";
+        }, {
+            function: {
+                name: string;
+            };
+            type: "function";
+        }>]>>;
+        disableTools: z.ZodOptional<z.ZodBoolean>;
+        includeSkillCatalog: z.ZodOptional<z.ZodBoolean>;
+        silent: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}>, z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    retry: z.ZodOptional<z.ZodObject<{
+        maxRetries: z.ZodNumber;
+        backoff: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+            baseDelay: z.ZodNumber;
+            maxDelay: z.ZodNumber;
+            jitter: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        }, {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    }, {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    }>>;
+    interrupt: z.ZodOptional<z.ZodObject<{
+        before: z.ZodOptional<z.ZodBoolean>;
+        after: z.ZodOptional<z.ZodBoolean>;
+        question: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    }, {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    }>>;
+} & {
+    type: z.ZodLiteral<"tool">;
+    config: z.ZodObject<{
+        tool: z.ZodString;
+        arguments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        tool: z.ZodString;
+        arguments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        tool: z.ZodString;
+        arguments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">>;
+}, "strict", z.ZodTypeAny, {
+    type: "tool";
+    id: string;
+    config: {
+        tool: string;
+        arguments?: Record<string, unknown> | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    description?: string | undefined;
+    label?: string | undefined;
+    retry?: {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    } | undefined;
+    interrupt?: {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    } | undefined;
+}, {
+    type: "tool";
+    id: string;
+    config: {
+        tool: string;
+        arguments?: Record<string, unknown> | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    description?: string | undefined;
+    label?: string | undefined;
+    retry?: {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    } | undefined;
+    interrupt?: {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    } | undefined;
+}>, z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    retry: z.ZodOptional<z.ZodObject<{
+        maxRetries: z.ZodNumber;
+        backoff: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+            baseDelay: z.ZodNumber;
+            maxDelay: z.ZodNumber;
+            jitter: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        }, {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    }, {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    }>>;
+    interrupt: z.ZodOptional<z.ZodObject<{
+        before: z.ZodOptional<z.ZodBoolean>;
+        after: z.ZodOptional<z.ZodBoolean>;
+        question: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    }, {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    }>>;
+} & {
+    type: z.ZodLiteral<"condition">;
+    config: z.ZodDefault<z.ZodObject<{
+        conditionExpr: z.ZodOptional<z.ZodString>;
+        conditionFn: z.ZodOptional<z.ZodString>;
+        branchValues: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        fallback: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        conditionExpr: z.ZodOptional<z.ZodString>;
+        conditionFn: z.ZodOptional<z.ZodString>;
+        branchValues: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        fallback: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        conditionExpr: z.ZodOptional<z.ZodString>;
+        conditionFn: z.ZodOptional<z.ZodString>;
+        branchValues: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        fallback: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, "strict", z.ZodTypeAny, {
+    type: "condition";
+    id: string;
+    config: {
+        conditionExpr?: string | undefined;
+        conditionFn?: string | undefined;
+        branchValues?: string[] | undefined;
+        fallback?: string | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    description?: string | undefined;
+    label?: string | undefined;
+    retry?: {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    } | undefined;
+    interrupt?: {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    } | undefined;
+}, {
+    type: "condition";
+    id: string;
+    description?: string | undefined;
+    label?: string | undefined;
+    retry?: {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    } | undefined;
+    interrupt?: {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    } | undefined;
+    config?: z.objectInputType<{
+        conditionExpr: z.ZodOptional<z.ZodString>;
+        conditionFn: z.ZodOptional<z.ZodString>;
+        branchValues: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        fallback: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}>, z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    retry: z.ZodOptional<z.ZodObject<{
+        maxRetries: z.ZodNumber;
+        backoff: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+            baseDelay: z.ZodNumber;
+            maxDelay: z.ZodNumber;
+            jitter: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        }, {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    }, {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    }>>;
+    interrupt: z.ZodOptional<z.ZodObject<{
+        before: z.ZodOptional<z.ZodBoolean>;
+        after: z.ZodOptional<z.ZodBoolean>;
+        question: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    }, {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    }>>;
+} & {
+    type: z.ZodLiteral<"subgraph">;
+    subgraphId: z.ZodOptional<z.ZodString>;
+    config: z.ZodDefault<z.ZodObject<{
+        skillId: z.ZodOptional<z.ZodString>;
+        skillCode: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        skillId: z.ZodOptional<z.ZodString>;
+        skillCode: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        skillId: z.ZodOptional<z.ZodString>;
+        skillCode: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, "strict", z.ZodTypeAny, {
+    type: "subgraph";
+    id: string;
+    config: {
+        skillId?: string | undefined;
+        skillCode?: string | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    description?: string | undefined;
+    label?: string | undefined;
+    retry?: {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    } | undefined;
+    interrupt?: {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    } | undefined;
+    subgraphId?: string | undefined;
+}, {
+    type: "subgraph";
+    id: string;
+    description?: string | undefined;
+    label?: string | undefined;
+    retry?: {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    } | undefined;
+    interrupt?: {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    } | undefined;
+    config?: z.objectInputType<{
+        skillId: z.ZodOptional<z.ZodString>;
+        skillCode: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    subgraphId?: string | undefined;
+}>, z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    retry: z.ZodOptional<z.ZodObject<{
+        maxRetries: z.ZodNumber;
+        backoff: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+            baseDelay: z.ZodNumber;
+            maxDelay: z.ZodNumber;
+            jitter: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        }, {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    }, {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    }>>;
+    interrupt: z.ZodOptional<z.ZodObject<{
+        before: z.ZodOptional<z.ZodBoolean>;
+        after: z.ZodOptional<z.ZodBoolean>;
+        question: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    }, {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    }>>;
+} & {
+    type: z.ZodLiteral<"human">;
+    config: z.ZodDefault<z.ZodObject<{
+        question: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        question: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        question: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, "strict", z.ZodTypeAny, {
+    type: "human";
+    id: string;
+    config: {
+        options?: string[] | undefined;
+        question?: string | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    description?: string | undefined;
+    label?: string | undefined;
+    retry?: {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    } | undefined;
+    interrupt?: {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    } | undefined;
+}, {
+    type: "human";
+    id: string;
+    description?: string | undefined;
+    label?: string | undefined;
+    retry?: {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    } | undefined;
+    interrupt?: {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    } | undefined;
+    config?: z.objectInputType<{
+        question: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}>, z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    retry: z.ZodOptional<z.ZodObject<{
+        maxRetries: z.ZodNumber;
+        backoff: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+            baseDelay: z.ZodNumber;
+            maxDelay: z.ZodNumber;
+            jitter: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        }, {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    }, {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    }>>;
+    interrupt: z.ZodOptional<z.ZodObject<{
+        before: z.ZodOptional<z.ZodBoolean>;
+        after: z.ZodOptional<z.ZodBoolean>;
+        question: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    }, {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    }>>;
+} & {
+    type: z.ZodLiteral<"code">;
+    config: z.ZodDefault<z.ZodObject<{
+        code: z.ZodOptional<z.ZodString>;
+        handler: z.ZodOptional<z.ZodString>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        bindSkill: z.ZodOptional<z.ZodBoolean>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        code: z.ZodOptional<z.ZodString>;
+        handler: z.ZodOptional<z.ZodString>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        bindSkill: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        code: z.ZodOptional<z.ZodString>;
+        handler: z.ZodOptional<z.ZodString>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        bindSkill: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, "strict", z.ZodTypeAny, {
+    type: "code";
+    id: string;
+    config: {
+        code?: string | undefined;
+        handler?: string | undefined;
+        timeoutMs?: number | undefined;
+        bindSkill?: boolean | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    description?: string | undefined;
+    label?: string | undefined;
+    retry?: {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    } | undefined;
+    interrupt?: {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    } | undefined;
+}, {
+    type: "code";
+    id: string;
+    description?: string | undefined;
+    label?: string | undefined;
+    retry?: {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    } | undefined;
+    interrupt?: {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    } | undefined;
+    config?: z.objectInputType<{
+        code: z.ZodOptional<z.ZodString>;
+        handler: z.ZodOptional<z.ZodString>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        bindSkill: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}>, z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    retry: z.ZodOptional<z.ZodObject<{
+        maxRetries: z.ZodNumber;
+        backoff: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+            baseDelay: z.ZodNumber;
+            maxDelay: z.ZodNumber;
+            jitter: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        }, {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    }, {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    }>>;
+    interrupt: z.ZodOptional<z.ZodObject<{
+        before: z.ZodOptional<z.ZodBoolean>;
+        after: z.ZodOptional<z.ZodBoolean>;
+        question: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    }, {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    }>>;
+} & {
+    type: z.ZodLiteral<"rag">;
+    config: z.ZodDefault<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        totalK: z.ZodOptional<z.ZodNumber>;
+        maxIterations: z.ZodOptional<z.ZodNumber>;
+        quota: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        nearDupThreshold: z.ZodOptional<z.ZodNumber>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxRetries: z.ZodNumber;
+            backoff: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+                baseDelay: z.ZodNumber;
+                maxDelay: z.ZodNumber;
+                jitter: z.ZodOptional<z.ZodNumber>;
+            }, "strict", z.ZodTypeAny, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }>>;
+        retrievalSources: z.ZodOptional<z.ZodObject<{
+            sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough">>>;
+        toolSources: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        model: z.ZodOptional<z.ZodString>;
+        totalK: z.ZodOptional<z.ZodNumber>;
+        maxIterations: z.ZodOptional<z.ZodNumber>;
+        quota: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        nearDupThreshold: z.ZodOptional<z.ZodNumber>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxRetries: z.ZodNumber;
+            backoff: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+                baseDelay: z.ZodNumber;
+                maxDelay: z.ZodNumber;
+                jitter: z.ZodOptional<z.ZodNumber>;
+            }, "strict", z.ZodTypeAny, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }>>;
+        retrievalSources: z.ZodOptional<z.ZodObject<{
+            sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough">>>;
+        toolSources: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        model: z.ZodOptional<z.ZodString>;
+        totalK: z.ZodOptional<z.ZodNumber>;
+        maxIterations: z.ZodOptional<z.ZodNumber>;
+        quota: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        nearDupThreshold: z.ZodOptional<z.ZodNumber>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxRetries: z.ZodNumber;
+            backoff: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+                baseDelay: z.ZodNumber;
+                maxDelay: z.ZodNumber;
+                jitter: z.ZodOptional<z.ZodNumber>;
+            }, "strict", z.ZodTypeAny, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }>>;
+        retrievalSources: z.ZodOptional<z.ZodObject<{
+            sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough">>>;
+        toolSources: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, "strict", z.ZodTypeAny, {
+    type: "rag";
+    id: string;
+    config: {
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        model?: string | undefined;
+        totalK?: number | undefined;
+        maxIterations?: number | undefined;
+        quota?: Record<string, number> | undefined;
+        nearDupThreshold?: number | undefined;
+        retrievalSources?: z.objectOutputType<{
+            sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+        toolSources?: Record<string, string> | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    description?: string | undefined;
+    label?: string | undefined;
+    retry?: {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    } | undefined;
+    interrupt?: {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    } | undefined;
+}, {
+    type: "rag";
+    id: string;
+    description?: string | undefined;
+    label?: string | undefined;
+    retry?: {
+        maxRetries: number;
+        backoff?: {
+            type: "exponential" | "linear" | "fixed";
+            baseDelay: number;
+            maxDelay: number;
+            jitter?: number | undefined;
+        } | undefined;
+    } | undefined;
+    interrupt?: {
+        options?: string[] | undefined;
+        before?: boolean | undefined;
+        after?: boolean | undefined;
+        question?: string | undefined;
+        timeout?: number | undefined;
+    } | undefined;
+    config?: z.objectInputType<{
+        model: z.ZodOptional<z.ZodString>;
+        totalK: z.ZodOptional<z.ZodNumber>;
+        maxIterations: z.ZodOptional<z.ZodNumber>;
+        quota: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        nearDupThreshold: z.ZodOptional<z.ZodNumber>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxRetries: z.ZodNumber;
+            backoff: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+                baseDelay: z.ZodNumber;
+                maxDelay: z.ZodNumber;
+                jitter: z.ZodOptional<z.ZodNumber>;
+            }, "strict", z.ZodTypeAny, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }>>;
+        retrievalSources: z.ZodOptional<z.ZodObject<{
+            sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                type: z.ZodString;
+                id: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                ref: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+        }, z.ZodTypeAny, "passthrough">>>;
+        toolSources: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}>]>;
+export declare const GraphSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    nodes: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxRetries: z.ZodNumber;
+            backoff: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+                baseDelay: z.ZodNumber;
+                maxDelay: z.ZodNumber;
+                jitter: z.ZodOptional<z.ZodNumber>;
+            }, "strict", z.ZodTypeAny, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }>>;
+        interrupt: z.ZodOptional<z.ZodObject<{
+            before: z.ZodOptional<z.ZodBoolean>;
+            after: z.ZodOptional<z.ZodBoolean>;
+            question: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            timeout: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        }, {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        }>>;
+    } & {
+        type: z.ZodLiteral<"llm">;
+        config: z.ZodDefault<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            systemPrompt: z.ZodOptional<z.ZodString>;
+            systemPromptFile: z.ZodOptional<z.ZodString>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+            outputKey: z.ZodOptional<z.ZodString>;
+            retry: z.ZodOptional<z.ZodObject<{
+                maxRetries: z.ZodNumber;
+                backoff: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+                    baseDelay: z.ZodNumber;
+                    maxDelay: z.ZodNumber;
+                    jitter: z.ZodOptional<z.ZodNumber>;
+                }, "strict", z.ZodTypeAny, {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                }, {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                }>>;
+            }, "strict", z.ZodTypeAny, {
+                maxRetries: number;
+                backoff?: {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                } | undefined;
+            }, {
+                maxRetries: number;
+                backoff?: {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                } | undefined;
+            }>>;
+            tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                type: z.ZodLiteral<"function">;
+                function: z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, "strict", z.ZodTypeAny, {
+                    name: string;
+                    description?: string | undefined;
+                    parameters?: Record<string, unknown> | undefined;
+                }, {
+                    name: string;
+                    description?: string | undefined;
+                    parameters?: Record<string, unknown> | undefined;
+                }>;
+            }, "strict", z.ZodTypeAny, {
+                function: {
+                    name: string;
+                    description?: string | undefined;
+                    parameters?: Record<string, unknown> | undefined;
+                };
+                type: "function";
+            }, {
+                function: {
+                    name: string;
+                    description?: string | undefined;
+                    parameters?: Record<string, unknown> | undefined;
+                };
+                type: "function";
+            }>, "many">>;
+            toolChoice: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["auto", "none", "required"]>, z.ZodObject<{
+                type: z.ZodLiteral<"function">;
+                function: z.ZodObject<{
+                    name: z.ZodString;
+                }, "strict", z.ZodTypeAny, {
+                    name: string;
+                }, {
+                    name: string;
+                }>;
+            }, "strict", z.ZodTypeAny, {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            }, {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            }>]>>;
+            disableTools: z.ZodOptional<z.ZodBoolean>;
+            includeSkillCatalog: z.ZodOptional<z.ZodBoolean>;
+            silent: z.ZodOptional<z.ZodBoolean>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            model: z.ZodOptional<z.ZodString>;
+            systemPrompt: z.ZodOptional<z.ZodString>;
+            systemPromptFile: z.ZodOptional<z.ZodString>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+            outputKey: z.ZodOptional<z.ZodString>;
+            retry: z.ZodOptional<z.ZodObject<{
+                maxRetries: z.ZodNumber;
+                backoff: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+                    baseDelay: z.ZodNumber;
+                    maxDelay: z.ZodNumber;
+                    jitter: z.ZodOptional<z.ZodNumber>;
+                }, "strict", z.ZodTypeAny, {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                }, {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                }>>;
+            }, "strict", z.ZodTypeAny, {
+                maxRetries: number;
+                backoff?: {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                } | undefined;
+            }, {
+                maxRetries: number;
+                backoff?: {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                } | undefined;
+            }>>;
+            tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                type: z.ZodLiteral<"function">;
+                function: z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, "strict", z.ZodTypeAny, {
+                    name: string;
+                    description?: string | undefined;
+                    parameters?: Record<string, unknown> | undefined;
+                }, {
+                    name: string;
+                    description?: string | undefined;
+                    parameters?: Record<string, unknown> | undefined;
+                }>;
+            }, "strict", z.ZodTypeAny, {
+                function: {
+                    name: string;
+                    description?: string | undefined;
+                    parameters?: Record<string, unknown> | undefined;
+                };
+                type: "function";
+            }, {
+                function: {
+                    name: string;
+                    description?: string | undefined;
+                    parameters?: Record<string, unknown> | undefined;
+                };
+                type: "function";
+            }>, "many">>;
+            toolChoice: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["auto", "none", "required"]>, z.ZodObject<{
+                type: z.ZodLiteral<"function">;
+                function: z.ZodObject<{
+                    name: z.ZodString;
+                }, "strict", z.ZodTypeAny, {
+                    name: string;
+                }, {
+                    name: string;
+                }>;
+            }, "strict", z.ZodTypeAny, {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            }, {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            }>]>>;
+            disableTools: z.ZodOptional<z.ZodBoolean>;
+            includeSkillCatalog: z.ZodOptional<z.ZodBoolean>;
+            silent: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            model: z.ZodOptional<z.ZodString>;
+            systemPrompt: z.ZodOptional<z.ZodString>;
+            systemPromptFile: z.ZodOptional<z.ZodString>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+            outputKey: z.ZodOptional<z.ZodString>;
+            retry: z.ZodOptional<z.ZodObject<{
+                maxRetries: z.ZodNumber;
+                backoff: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+                    baseDelay: z.ZodNumber;
+                    maxDelay: z.ZodNumber;
+                    jitter: z.ZodOptional<z.ZodNumber>;
+                }, "strict", z.ZodTypeAny, {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                }, {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                }>>;
+            }, "strict", z.ZodTypeAny, {
+                maxRetries: number;
+                backoff?: {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                } | undefined;
+            }, {
+                maxRetries: number;
+                backoff?: {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                } | undefined;
+            }>>;
+            tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                type: z.ZodLiteral<"function">;
+                function: z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, "strict", z.ZodTypeAny, {
+                    name: string;
+                    description?: string | undefined;
+                    parameters?: Record<string, unknown> | undefined;
+                }, {
+                    name: string;
+                    description?: string | undefined;
+                    parameters?: Record<string, unknown> | undefined;
+                }>;
+            }, "strict", z.ZodTypeAny, {
+                function: {
+                    name: string;
+                    description?: string | undefined;
+                    parameters?: Record<string, unknown> | undefined;
+                };
+                type: "function";
+            }, {
+                function: {
+                    name: string;
+                    description?: string | undefined;
+                    parameters?: Record<string, unknown> | undefined;
+                };
+                type: "function";
+            }>, "many">>;
+            toolChoice: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["auto", "none", "required"]>, z.ZodObject<{
+                type: z.ZodLiteral<"function">;
+                function: z.ZodObject<{
+                    name: z.ZodString;
+                }, "strict", z.ZodTypeAny, {
+                    name: string;
+                }, {
+                    name: string;
+                }>;
+            }, "strict", z.ZodTypeAny, {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            }, {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            }>]>>;
+            disableTools: z.ZodOptional<z.ZodBoolean>;
+            includeSkillCatalog: z.ZodOptional<z.ZodBoolean>;
+            silent: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, "strict", z.ZodTypeAny, {
+        type: "llm";
+        id: string;
+        config: {
+            retry?: {
+                maxRetries: number;
+                backoff?: {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                } | undefined;
+            } | undefined;
+            model?: string | undefined;
+            systemPrompt?: string | undefined;
+            systemPromptFile?: string | undefined;
+            temperature?: number | undefined;
+            maxTokens?: number | undefined;
+            outputKey?: string | undefined;
+            tools?: {
+                function: {
+                    name: string;
+                    description?: string | undefined;
+                    parameters?: Record<string, unknown> | undefined;
+                };
+                type: "function";
+            }[] | undefined;
+            toolChoice?: "required" | "auto" | "none" | {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            } | undefined;
+            disableTools?: boolean | undefined;
+            includeSkillCatalog?: boolean | undefined;
+            silent?: boolean | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+    }, {
+        type: "llm";
+        id: string;
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+        config?: z.objectInputType<{
+            model: z.ZodOptional<z.ZodString>;
+            systemPrompt: z.ZodOptional<z.ZodString>;
+            systemPromptFile: z.ZodOptional<z.ZodString>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+            outputKey: z.ZodOptional<z.ZodString>;
+            retry: z.ZodOptional<z.ZodObject<{
+                maxRetries: z.ZodNumber;
+                backoff: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+                    baseDelay: z.ZodNumber;
+                    maxDelay: z.ZodNumber;
+                    jitter: z.ZodOptional<z.ZodNumber>;
+                }, "strict", z.ZodTypeAny, {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                }, {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                }>>;
+            }, "strict", z.ZodTypeAny, {
+                maxRetries: number;
+                backoff?: {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                } | undefined;
+            }, {
+                maxRetries: number;
+                backoff?: {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                } | undefined;
+            }>>;
+            tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                type: z.ZodLiteral<"function">;
+                function: z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, "strict", z.ZodTypeAny, {
+                    name: string;
+                    description?: string | undefined;
+                    parameters?: Record<string, unknown> | undefined;
+                }, {
+                    name: string;
+                    description?: string | undefined;
+                    parameters?: Record<string, unknown> | undefined;
+                }>;
+            }, "strict", z.ZodTypeAny, {
+                function: {
+                    name: string;
+                    description?: string | undefined;
+                    parameters?: Record<string, unknown> | undefined;
+                };
+                type: "function";
+            }, {
+                function: {
+                    name: string;
+                    description?: string | undefined;
+                    parameters?: Record<string, unknown> | undefined;
+                };
+                type: "function";
+            }>, "many">>;
+            toolChoice: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["auto", "none", "required"]>, z.ZodObject<{
+                type: z.ZodLiteral<"function">;
+                function: z.ZodObject<{
+                    name: z.ZodString;
+                }, "strict", z.ZodTypeAny, {
+                    name: string;
+                }, {
+                    name: string;
+                }>;
+            }, "strict", z.ZodTypeAny, {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            }, {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            }>]>>;
+            disableTools: z.ZodOptional<z.ZodBoolean>;
+            includeSkillCatalog: z.ZodOptional<z.ZodBoolean>;
+            silent: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    }>, z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxRetries: z.ZodNumber;
+            backoff: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+                baseDelay: z.ZodNumber;
+                maxDelay: z.ZodNumber;
+                jitter: z.ZodOptional<z.ZodNumber>;
+            }, "strict", z.ZodTypeAny, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }>>;
+        interrupt: z.ZodOptional<z.ZodObject<{
+            before: z.ZodOptional<z.ZodBoolean>;
+            after: z.ZodOptional<z.ZodBoolean>;
+            question: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            timeout: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        }, {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        }>>;
+    } & {
+        type: z.ZodLiteral<"tool">;
+        config: z.ZodObject<{
+            tool: z.ZodString;
+            arguments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            tool: z.ZodString;
+            arguments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            tool: z.ZodString;
+            arguments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.ZodTypeAny, "passthrough">>;
+    }, "strict", z.ZodTypeAny, {
+        type: "tool";
+        id: string;
+        config: {
+            tool: string;
+            arguments?: Record<string, unknown> | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+    }, {
+        type: "tool";
+        id: string;
+        config: {
+            tool: string;
+            arguments?: Record<string, unknown> | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+    }>, z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxRetries: z.ZodNumber;
+            backoff: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+                baseDelay: z.ZodNumber;
+                maxDelay: z.ZodNumber;
+                jitter: z.ZodOptional<z.ZodNumber>;
+            }, "strict", z.ZodTypeAny, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }>>;
+        interrupt: z.ZodOptional<z.ZodObject<{
+            before: z.ZodOptional<z.ZodBoolean>;
+            after: z.ZodOptional<z.ZodBoolean>;
+            question: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            timeout: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        }, {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        }>>;
+    } & {
+        type: z.ZodLiteral<"condition">;
+        config: z.ZodDefault<z.ZodObject<{
+            conditionExpr: z.ZodOptional<z.ZodString>;
+            conditionFn: z.ZodOptional<z.ZodString>;
+            branchValues: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            fallback: z.ZodOptional<z.ZodString>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            conditionExpr: z.ZodOptional<z.ZodString>;
+            conditionFn: z.ZodOptional<z.ZodString>;
+            branchValues: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            fallback: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            conditionExpr: z.ZodOptional<z.ZodString>;
+            conditionFn: z.ZodOptional<z.ZodString>;
+            branchValues: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            fallback: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, "strict", z.ZodTypeAny, {
+        type: "condition";
+        id: string;
+        config: {
+            conditionExpr?: string | undefined;
+            conditionFn?: string | undefined;
+            branchValues?: string[] | undefined;
+            fallback?: string | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+    }, {
+        type: "condition";
+        id: string;
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+        config?: z.objectInputType<{
+            conditionExpr: z.ZodOptional<z.ZodString>;
+            conditionFn: z.ZodOptional<z.ZodString>;
+            branchValues: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            fallback: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    }>, z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxRetries: z.ZodNumber;
+            backoff: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+                baseDelay: z.ZodNumber;
+                maxDelay: z.ZodNumber;
+                jitter: z.ZodOptional<z.ZodNumber>;
+            }, "strict", z.ZodTypeAny, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }>>;
+        interrupt: z.ZodOptional<z.ZodObject<{
+            before: z.ZodOptional<z.ZodBoolean>;
+            after: z.ZodOptional<z.ZodBoolean>;
+            question: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            timeout: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        }, {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        }>>;
+    } & {
+        type: z.ZodLiteral<"subgraph">;
+        subgraphId: z.ZodOptional<z.ZodString>;
+        config: z.ZodDefault<z.ZodObject<{
+            skillId: z.ZodOptional<z.ZodString>;
+            skillCode: z.ZodOptional<z.ZodString>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            skillId: z.ZodOptional<z.ZodString>;
+            skillCode: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            skillId: z.ZodOptional<z.ZodString>;
+            skillCode: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, "strict", z.ZodTypeAny, {
+        type: "subgraph";
+        id: string;
+        config: {
+            skillId?: string | undefined;
+            skillCode?: string | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+        subgraphId?: string | undefined;
+    }, {
+        type: "subgraph";
+        id: string;
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+        config?: z.objectInputType<{
+            skillId: z.ZodOptional<z.ZodString>;
+            skillCode: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+        subgraphId?: string | undefined;
+    }>, z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxRetries: z.ZodNumber;
+            backoff: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+                baseDelay: z.ZodNumber;
+                maxDelay: z.ZodNumber;
+                jitter: z.ZodOptional<z.ZodNumber>;
+            }, "strict", z.ZodTypeAny, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }>>;
+        interrupt: z.ZodOptional<z.ZodObject<{
+            before: z.ZodOptional<z.ZodBoolean>;
+            after: z.ZodOptional<z.ZodBoolean>;
+            question: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            timeout: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        }, {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        }>>;
+    } & {
+        type: z.ZodLiteral<"human">;
+        config: z.ZodDefault<z.ZodObject<{
+            question: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            question: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            question: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, "strict", z.ZodTypeAny, {
+        type: "human";
+        id: string;
+        config: {
+            options?: string[] | undefined;
+            question?: string | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+    }, {
+        type: "human";
+        id: string;
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+        config?: z.objectInputType<{
+            question: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    }>, z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxRetries: z.ZodNumber;
+            backoff: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+                baseDelay: z.ZodNumber;
+                maxDelay: z.ZodNumber;
+                jitter: z.ZodOptional<z.ZodNumber>;
+            }, "strict", z.ZodTypeAny, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }>>;
+        interrupt: z.ZodOptional<z.ZodObject<{
+            before: z.ZodOptional<z.ZodBoolean>;
+            after: z.ZodOptional<z.ZodBoolean>;
+            question: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            timeout: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        }, {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        }>>;
+    } & {
+        type: z.ZodLiteral<"code">;
+        config: z.ZodDefault<z.ZodObject<{
+            code: z.ZodOptional<z.ZodString>;
+            handler: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+            bindSkill: z.ZodOptional<z.ZodBoolean>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            code: z.ZodOptional<z.ZodString>;
+            handler: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+            bindSkill: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            code: z.ZodOptional<z.ZodString>;
+            handler: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+            bindSkill: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, "strict", z.ZodTypeAny, {
+        type: "code";
+        id: string;
+        config: {
+            code?: string | undefined;
+            handler?: string | undefined;
+            timeoutMs?: number | undefined;
+            bindSkill?: boolean | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+    }, {
+        type: "code";
+        id: string;
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+        config?: z.objectInputType<{
+            code: z.ZodOptional<z.ZodString>;
+            handler: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+            bindSkill: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    }>, z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxRetries: z.ZodNumber;
+            backoff: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+                baseDelay: z.ZodNumber;
+                maxDelay: z.ZodNumber;
+                jitter: z.ZodOptional<z.ZodNumber>;
+            }, "strict", z.ZodTypeAny, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }, {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }, {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        }>>;
+        interrupt: z.ZodOptional<z.ZodObject<{
+            before: z.ZodOptional<z.ZodBoolean>;
+            after: z.ZodOptional<z.ZodBoolean>;
+            question: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            timeout: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        }, {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        }>>;
+    } & {
+        type: z.ZodLiteral<"rag">;
+        config: z.ZodDefault<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            totalK: z.ZodOptional<z.ZodNumber>;
+            maxIterations: z.ZodOptional<z.ZodNumber>;
+            quota: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+            nearDupThreshold: z.ZodOptional<z.ZodNumber>;
+            retry: z.ZodOptional<z.ZodObject<{
+                maxRetries: z.ZodNumber;
+                backoff: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+                    baseDelay: z.ZodNumber;
+                    maxDelay: z.ZodNumber;
+                    jitter: z.ZodOptional<z.ZodNumber>;
+                }, "strict", z.ZodTypeAny, {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                }, {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                }>>;
+            }, "strict", z.ZodTypeAny, {
+                maxRetries: number;
+                backoff?: {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                } | undefined;
+            }, {
+                maxRetries: number;
+                backoff?: {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                } | undefined;
+            }>>;
+            retrievalSources: z.ZodOptional<z.ZodObject<{
+                sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+            }, z.ZodTypeAny, "passthrough">>>;
+            toolSources: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            model: z.ZodOptional<z.ZodString>;
+            totalK: z.ZodOptional<z.ZodNumber>;
+            maxIterations: z.ZodOptional<z.ZodNumber>;
+            quota: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+            nearDupThreshold: z.ZodOptional<z.ZodNumber>;
+            retry: z.ZodOptional<z.ZodObject<{
+                maxRetries: z.ZodNumber;
+                backoff: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+                    baseDelay: z.ZodNumber;
+                    maxDelay: z.ZodNumber;
+                    jitter: z.ZodOptional<z.ZodNumber>;
+                }, "strict", z.ZodTypeAny, {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                }, {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                }>>;
+            }, "strict", z.ZodTypeAny, {
+                maxRetries: number;
+                backoff?: {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                } | undefined;
+            }, {
+                maxRetries: number;
+                backoff?: {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                } | undefined;
+            }>>;
+            retrievalSources: z.ZodOptional<z.ZodObject<{
+                sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+            }, z.ZodTypeAny, "passthrough">>>;
+            toolSources: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            model: z.ZodOptional<z.ZodString>;
+            totalK: z.ZodOptional<z.ZodNumber>;
+            maxIterations: z.ZodOptional<z.ZodNumber>;
+            quota: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+            nearDupThreshold: z.ZodOptional<z.ZodNumber>;
+            retry: z.ZodOptional<z.ZodObject<{
+                maxRetries: z.ZodNumber;
+                backoff: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+                    baseDelay: z.ZodNumber;
+                    maxDelay: z.ZodNumber;
+                    jitter: z.ZodOptional<z.ZodNumber>;
+                }, "strict", z.ZodTypeAny, {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                }, {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                }>>;
+            }, "strict", z.ZodTypeAny, {
+                maxRetries: number;
+                backoff?: {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                } | undefined;
+            }, {
+                maxRetries: number;
+                backoff?: {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                } | undefined;
+            }>>;
+            retrievalSources: z.ZodOptional<z.ZodObject<{
+                sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+            }, z.ZodTypeAny, "passthrough">>>;
+            toolSources: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, "strict", z.ZodTypeAny, {
+        type: "rag";
+        id: string;
+        config: {
+            retry?: {
+                maxRetries: number;
+                backoff?: {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                } | undefined;
+            } | undefined;
+            model?: string | undefined;
+            totalK?: number | undefined;
+            maxIterations?: number | undefined;
+            quota?: Record<string, number> | undefined;
+            nearDupThreshold?: number | undefined;
+            retrievalSources?: z.objectOutputType<{
+                sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+            }, z.ZodTypeAny, "passthrough"> | undefined;
+            toolSources?: Record<string, string> | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+    }, {
+        type: "rag";
+        id: string;
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+        config?: z.objectInputType<{
+            model: z.ZodOptional<z.ZodString>;
+            totalK: z.ZodOptional<z.ZodNumber>;
+            maxIterations: z.ZodOptional<z.ZodNumber>;
+            quota: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+            nearDupThreshold: z.ZodOptional<z.ZodNumber>;
+            retry: z.ZodOptional<z.ZodObject<{
+                maxRetries: z.ZodNumber;
+                backoff: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+                    baseDelay: z.ZodNumber;
+                    maxDelay: z.ZodNumber;
+                    jitter: z.ZodOptional<z.ZodNumber>;
+                }, "strict", z.ZodTypeAny, {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                }, {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                }>>;
+            }, "strict", z.ZodTypeAny, {
+                maxRetries: number;
+                backoff?: {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                } | undefined;
+            }, {
+                maxRetries: number;
+                backoff?: {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                } | undefined;
+            }>>;
+            retrievalSources: z.ZodOptional<z.ZodObject<{
+                sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+            }, z.ZodTypeAny, "passthrough">>>;
+            toolSources: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    }>]>, "many">;
+    edges: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        condition: z.ZodOptional<z.ZodString>;
+        priority: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        from: string;
+        to: string;
+        condition?: string | undefined;
+        priority?: number | undefined;
+    }, {
+        from: string;
+        to: string;
+        condition?: string | undefined;
+        priority?: number | undefined;
+    }>, "many">;
+    conditionalEdges: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        branches: z.ZodArray<z.ZodObject<{
+            value: z.ZodString;
+            to: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            value: string;
+            to: string;
+            description?: string | undefined;
+        }, {
+            value: string;
+            to: string;
+            description?: string | undefined;
+        }>, "many">;
+        conditionFn: z.ZodOptional<z.ZodString>;
+        fallback: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        from: string;
+        branches: {
+            value: string;
+            to: string;
+            description?: string | undefined;
+        }[];
+        conditionFn?: string | undefined;
+        fallback?: string | undefined;
+    }, {
+        from: string;
+        branches: {
+            value: string;
+            to: string;
+            description?: string | undefined;
+        }[];
+        conditionFn?: string | undefined;
+        fallback?: string | undefined;
+    }>, "many">>;
+    entryPoint: z.ZodOptional<z.ZodString>;
+    finishPoints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    description: z.ZodOptional<z.ZodString>;
+    config: z.ZodOptional<z.ZodObject<{
+        maxIterations: z.ZodOptional<z.ZodNumber>;
+        maxRetries: z.ZodOptional<z.ZodNumber>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+        checkpointStore: z.ZodOptional<z.ZodEnum<["redis", "memory", "postgres", "mysql", "file"]>>;
+    }, "strict", z.ZodTypeAny, {
+        maxRetries?: number | undefined;
+        timeout?: number | undefined;
+        maxIterations?: number | undefined;
+        checkpointStore?: "redis" | "memory" | "postgres" | "mysql" | "file" | undefined;
+    }, {
+        maxRetries?: number | undefined;
+        timeout?: number | undefined;
+        maxIterations?: number | undefined;
+        checkpointStore?: "redis" | "memory" | "postgres" | "mysql" | "file" | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    nodes: ({
+        type: "llm";
+        id: string;
+        config: {
+            retry?: {
+                maxRetries: number;
+                backoff?: {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                } | undefined;
+            } | undefined;
+            model?: string | undefined;
+            systemPrompt?: string | undefined;
+            systemPromptFile?: string | undefined;
+            temperature?: number | undefined;
+            maxTokens?: number | undefined;
+            outputKey?: string | undefined;
+            tools?: {
+                function: {
+                    name: string;
+                    description?: string | undefined;
+                    parameters?: Record<string, unknown> | undefined;
+                };
+                type: "function";
+            }[] | undefined;
+            toolChoice?: "required" | "auto" | "none" | {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            } | undefined;
+            disableTools?: boolean | undefined;
+            includeSkillCatalog?: boolean | undefined;
+            silent?: boolean | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+    } | {
+        type: "tool";
+        id: string;
+        config: {
+            tool: string;
+            arguments?: Record<string, unknown> | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+    } | {
+        type: "condition";
+        id: string;
+        config: {
+            conditionExpr?: string | undefined;
+            conditionFn?: string | undefined;
+            branchValues?: string[] | undefined;
+            fallback?: string | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+    } | {
+        type: "subgraph";
+        id: string;
+        config: {
+            skillId?: string | undefined;
+            skillCode?: string | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+        subgraphId?: string | undefined;
+    } | {
+        type: "human";
+        id: string;
+        config: {
+            options?: string[] | undefined;
+            question?: string | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+    } | {
+        type: "code";
+        id: string;
+        config: {
+            code?: string | undefined;
+            handler?: string | undefined;
+            timeoutMs?: number | undefined;
+            bindSkill?: boolean | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+    } | {
+        type: "rag";
+        id: string;
+        config: {
+            retry?: {
+                maxRetries: number;
+                backoff?: {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                } | undefined;
+            } | undefined;
+            model?: string | undefined;
+            totalK?: number | undefined;
+            maxIterations?: number | undefined;
+            quota?: Record<string, number> | undefined;
+            nearDupThreshold?: number | undefined;
+            retrievalSources?: z.objectOutputType<{
+                sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+            }, z.ZodTypeAny, "passthrough"> | undefined;
+            toolSources?: Record<string, string> | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+    })[];
+    edges: {
+        from: string;
+        to: string;
+        condition?: string | undefined;
+        priority?: number | undefined;
+    }[];
+    description?: string | undefined;
+    name?: string | undefined;
+    config?: {
+        maxRetries?: number | undefined;
+        timeout?: number | undefined;
+        maxIterations?: number | undefined;
+        checkpointStore?: "redis" | "memory" | "postgres" | "mysql" | "file" | undefined;
+    } | undefined;
+    version?: string | undefined;
+    state?: Record<string, string> | undefined;
+    conditionalEdges?: {
+        from: string;
+        branches: {
+            value: string;
+            to: string;
+            description?: string | undefined;
+        }[];
+        conditionFn?: string | undefined;
+        fallback?: string | undefined;
+    }[] | undefined;
+    entryPoint?: string | undefined;
+    finishPoints?: string[] | undefined;
+}, {
+    nodes: ({
+        type: "llm";
+        id: string;
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+        config?: z.objectInputType<{
+            model: z.ZodOptional<z.ZodString>;
+            systemPrompt: z.ZodOptional<z.ZodString>;
+            systemPromptFile: z.ZodOptional<z.ZodString>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+            outputKey: z.ZodOptional<z.ZodString>;
+            retry: z.ZodOptional<z.ZodObject<{
+                maxRetries: z.ZodNumber;
+                backoff: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+                    baseDelay: z.ZodNumber;
+                    maxDelay: z.ZodNumber;
+                    jitter: z.ZodOptional<z.ZodNumber>;
+                }, "strict", z.ZodTypeAny, {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                }, {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                }>>;
+            }, "strict", z.ZodTypeAny, {
+                maxRetries: number;
+                backoff?: {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                } | undefined;
+            }, {
+                maxRetries: number;
+                backoff?: {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                } | undefined;
+            }>>;
+            tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                type: z.ZodLiteral<"function">;
+                function: z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, "strict", z.ZodTypeAny, {
+                    name: string;
+                    description?: string | undefined;
+                    parameters?: Record<string, unknown> | undefined;
+                }, {
+                    name: string;
+                    description?: string | undefined;
+                    parameters?: Record<string, unknown> | undefined;
+                }>;
+            }, "strict", z.ZodTypeAny, {
+                function: {
+                    name: string;
+                    description?: string | undefined;
+                    parameters?: Record<string, unknown> | undefined;
+                };
+                type: "function";
+            }, {
+                function: {
+                    name: string;
+                    description?: string | undefined;
+                    parameters?: Record<string, unknown> | undefined;
+                };
+                type: "function";
+            }>, "many">>;
+            toolChoice: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["auto", "none", "required"]>, z.ZodObject<{
+                type: z.ZodLiteral<"function">;
+                function: z.ZodObject<{
+                    name: z.ZodString;
+                }, "strict", z.ZodTypeAny, {
+                    name: string;
+                }, {
+                    name: string;
+                }>;
+            }, "strict", z.ZodTypeAny, {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            }, {
+                function: {
+                    name: string;
+                };
+                type: "function";
+            }>]>>;
+            disableTools: z.ZodOptional<z.ZodBoolean>;
+            includeSkillCatalog: z.ZodOptional<z.ZodBoolean>;
+            silent: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    } | {
+        type: "tool";
+        id: string;
+        config: {
+            tool: string;
+            arguments?: Record<string, unknown> | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+    } | {
+        type: "condition";
+        id: string;
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+        config?: z.objectInputType<{
+            conditionExpr: z.ZodOptional<z.ZodString>;
+            conditionFn: z.ZodOptional<z.ZodString>;
+            branchValues: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            fallback: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    } | {
+        type: "subgraph";
+        id: string;
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+        config?: z.objectInputType<{
+            skillId: z.ZodOptional<z.ZodString>;
+            skillCode: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+        subgraphId?: string | undefined;
+    } | {
+        type: "human";
+        id: string;
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+        config?: z.objectInputType<{
+            question: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    } | {
+        type: "code";
+        id: string;
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+        config?: z.objectInputType<{
+            code: z.ZodOptional<z.ZodString>;
+            handler: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+            bindSkill: z.ZodOptional<z.ZodBoolean>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    } | {
+        type: "rag";
+        id: string;
+        description?: string | undefined;
+        label?: string | undefined;
+        retry?: {
+            maxRetries: number;
+            backoff?: {
+                type: "exponential" | "linear" | "fixed";
+                baseDelay: number;
+                maxDelay: number;
+                jitter?: number | undefined;
+            } | undefined;
+        } | undefined;
+        interrupt?: {
+            options?: string[] | undefined;
+            before?: boolean | undefined;
+            after?: boolean | undefined;
+            question?: string | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+        config?: z.objectInputType<{
+            model: z.ZodOptional<z.ZodString>;
+            totalK: z.ZodOptional<z.ZodNumber>;
+            maxIterations: z.ZodOptional<z.ZodNumber>;
+            quota: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+            nearDupThreshold: z.ZodOptional<z.ZodNumber>;
+            retry: z.ZodOptional<z.ZodObject<{
+                maxRetries: z.ZodNumber;
+                backoff: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodEnum<["exponential", "linear", "fixed"]>;
+                    baseDelay: z.ZodNumber;
+                    maxDelay: z.ZodNumber;
+                    jitter: z.ZodOptional<z.ZodNumber>;
+                }, "strict", z.ZodTypeAny, {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                }, {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                }>>;
+            }, "strict", z.ZodTypeAny, {
+                maxRetries: number;
+                backoff?: {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                } | undefined;
+            }, {
+                maxRetries: number;
+                backoff?: {
+                    type: "exponential" | "linear" | "fixed";
+                    baseDelay: number;
+                    maxDelay: number;
+                    jitter?: number | undefined;
+                } | undefined;
+            }>>;
+            retrievalSources: z.ZodOptional<z.ZodObject<{
+                sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                sources: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                    source: z.ZodOptional<z.ZodString>;
+                    ref: z.ZodOptional<z.ZodString>;
+                }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+            }, z.ZodTypeAny, "passthrough">>>;
+            toolSources: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    })[];
+    edges: {
+        from: string;
+        to: string;
+        condition?: string | undefined;
+        priority?: number | undefined;
+    }[];
+    description?: string | undefined;
+    name?: string | undefined;
+    config?: {
+        maxRetries?: number | undefined;
+        timeout?: number | undefined;
+        maxIterations?: number | undefined;
+        checkpointStore?: "redis" | "memory" | "postgres" | "mysql" | "file" | undefined;
+    } | undefined;
+    version?: string | undefined;
+    state?: Record<string, string> | undefined;
+    conditionalEdges?: {
+        from: string;
+        branches: {
+            value: string;
+            to: string;
+            description?: string | undefined;
+        }[];
+        conditionFn?: string | undefined;
+        fallback?: string | undefined;
+    }[] | undefined;
+    entryPoint?: string | undefined;
+    finishPoints?: string[] | undefined;
+}>;
+export type Graph = z.infer<typeof GraphSchema>;
+export type GraphNode = z.infer<typeof GraphNodeSchema>;
+//# sourceMappingURL=graph.d.ts.map