@gt-fe/eap-sdk 0.2.18 → 0.2.19

package/dist/schema/agent/manifest.d.ts

@@ -0,0 +1,3277 @@
+import { z } from 'zod';
+export declare const AgentManifestSchema: z.ZodObject<{
+    code: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    prompts: z.ZodOptional<z.ZodObject<{
+        system: z.ZodOptional<z.ZodString>;
+        assistant: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodString, z.objectOutputType<{
+        system: z.ZodOptional<z.ZodString>;
+        assistant: z.ZodOptional<z.ZodString>;
+    }, z.ZodString, "strip">, z.objectInputType<{
+        system: z.ZodOptional<z.ZodString>;
+        assistant: z.ZodOptional<z.ZodString>;
+    }, z.ZodString, "strip">>>;
+    toolRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        version: z.ZodString;
+        enabled: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        autoApprove: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        code: string;
+        version: string;
+        enabled?: string[] | undefined;
+        autoApprove?: string[] | undefined;
+    }, {
+        code: string;
+        version: string;
+        enabled?: string[] | undefined;
+        autoApprove?: string[] | undefined;
+    }>, "many">>;
+    skillRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        version: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        code: string;
+        version: string;
+    }, {
+        code: string;
+        version: string;
+    }>, "many">>;
+    subagentRefs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        version: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        code: string;
+        version: string;
+    }, {
+        code: string;
+        version: string;
+    }>, "many">>;
+    models: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+        default: z.ZodString;
+        allowed: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        default: string;
+        allowed?: string[] | undefined;
+    }, {
+        default: string;
+        allowed?: string[] | undefined;
+    }>, {
+        default: string;
+        allowed?: string[] | undefined;
+    }, {
+        default: string;
+        allowed?: string[] | undefined;
+    }>>;
+    config: z.ZodOptional<z.ZodObject<{
+        timeout: z.ZodOptional<z.ZodNumber>;
+        retryCount: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        timeout?: number | undefined;
+        retryCount?: number | undefined;
+    }, {
+        timeout?: number | undefined;
+        retryCount?: number | undefined;
+    }>>;
+    graph: z.ZodOptional<z.ZodUnion<[z.ZodString, 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;
+    }>]>>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        owner: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        category: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodUnknown, z.objectOutputType<{
+        owner: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        category: z.ZodOptional<z.ZodString>;
+    }, z.ZodUnknown, "strip">, z.objectInputType<{
+        owner: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        category: z.ZodOptional<z.ZodString>;
+    }, z.ZodUnknown, "strip">>>;
+}, "strict", z.ZodTypeAny, {
+    code: string;
+    name: string;
+    version: string;
+    toolRefs: {
+        code: string;
+        version: string;
+        enabled?: string[] | undefined;
+        autoApprove?: string[] | undefined;
+    }[];
+    skillRefs: {
+        code: string;
+        version: string;
+    }[];
+    description?: string | undefined;
+    config?: {
+        timeout?: number | undefined;
+        retryCount?: number | undefined;
+    } | undefined;
+    prompts?: z.objectOutputType<{
+        system: z.ZodOptional<z.ZodString>;
+        assistant: z.ZodOptional<z.ZodString>;
+    }, z.ZodString, "strip"> | undefined;
+    subagentRefs?: {
+        code: string;
+        version: string;
+    }[] | undefined;
+    models?: {
+        default: string;
+        allowed?: string[] | undefined;
+    } | undefined;
+    graph?: string | {
+        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;
+    } | undefined;
+    metadata?: z.objectOutputType<{
+        owner: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        category: z.ZodOptional<z.ZodString>;
+    }, z.ZodUnknown, "strip"> | undefined;
+}, {
+    code: string;
+    name: string;
+    version: string;
+    description?: string | undefined;
+    config?: {
+        timeout?: number | undefined;
+        retryCount?: number | undefined;
+    } | undefined;
+    prompts?: z.objectInputType<{
+        system: z.ZodOptional<z.ZodString>;
+        assistant: z.ZodOptional<z.ZodString>;
+    }, z.ZodString, "strip"> | undefined;
+    toolRefs?: {
+        code: string;
+        version: string;
+        enabled?: string[] | undefined;
+        autoApprove?: string[] | undefined;
+    }[] | undefined;
+    skillRefs?: {
+        code: string;
+        version: string;
+    }[] | undefined;
+    subagentRefs?: {
+        code: string;
+        version: string;
+    }[] | undefined;
+    models?: {
+        default: string;
+        allowed?: string[] | undefined;
+    } | undefined;
+    graph?: string | {
+        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;
+    } | undefined;
+    metadata?: z.objectInputType<{
+        owner: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        category: z.ZodOptional<z.ZodString>;
+    }, z.ZodUnknown, "strip"> | undefined;
+}>;
+export type AgentManifest = z.infer<typeof AgentManifestSchema>;
+//# sourceMappingURL=manifest.d.ts.map