npm - @mastra/server - Versions diffs - 1.38.0-alpha.4 → 1.38.0-alpha.5 - Mend

@mastra/server 1.38.0-alpha.4 → 1.38.0-alpha.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (176) hide show

package/dist/server/schemas/stored-agents.d.ts CHANGED Viewed

@@ -12469,6 +12469,3768 @@ export declare const updateStoredAgentBodySchema: z.ZodObject<{
     }, z.core.$strip>>]>, z.ZodNull]>>>;
     changeMessage: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+export declare const exportStoredAgentBodySchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    instructions: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        content: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"prompt_block_ref">;
+        id: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"prompt_block">;
+        content: z.ZodString;
+        rules: z.ZodOptional<z.ZodObject<{
+            operator: z.ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>], "type">>]>>;
+    model: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        provider: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$loose>, z.ZodArray<z.ZodObject<{
+        value: z.ZodObject<{
+            provider: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$loose>;
+        rules: z.ZodOptional<z.ZodObject<{
+            operator: z.ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>]>>;
+    tools: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        rules: z.ZodOptional<z.ZodObject<{
+            operator: z.ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>, z.ZodArray<z.ZodObject<{
+        value: z.ZodRecord<z.ZodString, z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            rules: z.ZodOptional<z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        operator: z.ZodEnum<{
+                            AND: "AND";
+                            OR: "OR";
+                        }>;
+                        conditions: z.ZodArray<z.ZodObject<{
+                            field: z.ZodString;
+                            operator: z.ZodEnum<{
+                                in: "in";
+                                equals: "equals";
+                                not_equals: "not_equals";
+                                contains: "contains";
+                                not_contains: "not_contains";
+                                greater_than: "greater_than";
+                                less_than: "less_than";
+                                greater_than_or_equal: "greater_than_or_equal";
+                                less_than_or_equal: "less_than_or_equal";
+                                not_in: "not_in";
+                                exists: "exists";
+                                not_exists: "not_exists";
+                            }>;
+                            value: z.ZodOptional<z.ZodUnknown>;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>]>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        rules: z.ZodOptional<z.ZodObject<{
+            operator: z.ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>]>>>;
+    defaultOptions: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        runId: z.ZodOptional<z.ZodString>;
+        savePerStep: z.ZodOptional<z.ZodBoolean>;
+        maxSteps: z.ZodOptional<z.ZodNumber>;
+        activeTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        maxProcessorRetries: z.ZodOptional<z.ZodNumber>;
+        toolChoice: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodLiteral<"required">, z.ZodObject<{
+            type: z.ZodLiteral<"tool">;
+            toolName: z.ZodString;
+        }, z.core.$strip>]>>;
+        modelSettings: z.ZodOptional<z.ZodObject<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+            topP: z.ZodOptional<z.ZodNumber>;
+            topK: z.ZodOptional<z.ZodNumber>;
+            frequencyPenalty: z.ZodOptional<z.ZodNumber>;
+            presencePenalty: z.ZodOptional<z.ZodNumber>;
+            stopSequences: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            seed: z.ZodOptional<z.ZodNumber>;
+            maxRetries: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        returnScorerData: z.ZodOptional<z.ZodBoolean>;
+        tracingOptions: z.ZodOptional<z.ZodObject<{
+            traceName: z.ZodOptional<z.ZodString>;
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            spanId: z.ZodOptional<z.ZodString>;
+            traceId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        requireToolApproval: z.ZodOptional<z.ZodBoolean>;
+        autoResumeSuspendedTools: z.ZodOptional<z.ZodBoolean>;
+        toolCallConcurrency: z.ZodOptional<z.ZodNumber>;
+        includeRawChunks: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>, z.ZodArray<z.ZodObject<{
+        value: z.ZodObject<{
+            runId: z.ZodOptional<z.ZodString>;
+            savePerStep: z.ZodOptional<z.ZodBoolean>;
+            maxSteps: z.ZodOptional<z.ZodNumber>;
+            activeTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            maxProcessorRetries: z.ZodOptional<z.ZodNumber>;
+            toolChoice: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodLiteral<"required">, z.ZodObject<{
+                type: z.ZodLiteral<"tool">;
+                toolName: z.ZodString;
+            }, z.core.$strip>]>>;
+            modelSettings: z.ZodOptional<z.ZodObject<{
+                temperature: z.ZodOptional<z.ZodNumber>;
+                maxTokens: z.ZodOptional<z.ZodNumber>;
+                topP: z.ZodOptional<z.ZodNumber>;
+                topK: z.ZodOptional<z.ZodNumber>;
+                frequencyPenalty: z.ZodOptional<z.ZodNumber>;
+                presencePenalty: z.ZodOptional<z.ZodNumber>;
+                stopSequences: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                seed: z.ZodOptional<z.ZodNumber>;
+                maxRetries: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            returnScorerData: z.ZodOptional<z.ZodBoolean>;
+            tracingOptions: z.ZodOptional<z.ZodObject<{
+                traceName: z.ZodOptional<z.ZodString>;
+                attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                spanId: z.ZodOptional<z.ZodString>;
+                traceId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            requireToolApproval: z.ZodOptional<z.ZodBoolean>;
+            autoResumeSuspendedTools: z.ZodOptional<z.ZodBoolean>;
+            toolCallConcurrency: z.ZodOptional<z.ZodNumber>;
+            includeRawChunks: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$loose>;
+        rules: z.ZodOptional<z.ZodObject<{
+            operator: z.ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>]>>>;
+    workflows: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        rules: z.ZodOptional<z.ZodObject<{
+            operator: z.ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>, z.ZodArray<z.ZodObject<{
+        value: z.ZodRecord<z.ZodString, z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            rules: z.ZodOptional<z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        operator: z.ZodEnum<{
+                            AND: "AND";
+                            OR: "OR";
+                        }>;
+                        conditions: z.ZodArray<z.ZodObject<{
+                            field: z.ZodString;
+                            operator: z.ZodEnum<{
+                                in: "in";
+                                equals: "equals";
+                                not_equals: "not_equals";
+                                contains: "contains";
+                                not_contains: "not_contains";
+                                greater_than: "greater_than";
+                                less_than: "less_than";
+                                greater_than_or_equal: "greater_than_or_equal";
+                                less_than_or_equal: "less_than_or_equal";
+                                not_in: "not_in";
+                                exists: "exists";
+                                not_exists: "not_exists";
+                            }>;
+                            value: z.ZodOptional<z.ZodUnknown>;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>]>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        rules: z.ZodOptional<z.ZodObject<{
+            operator: z.ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>]>>>;
+    agents: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        rules: z.ZodOptional<z.ZodObject<{
+            operator: z.ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>, z.ZodArray<z.ZodObject<{
+        value: z.ZodRecord<z.ZodString, z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            rules: z.ZodOptional<z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        operator: z.ZodEnum<{
+                            AND: "AND";
+                            OR: "OR";
+                        }>;
+                        conditions: z.ZodArray<z.ZodObject<{
+                            field: z.ZodString;
+                            operator: z.ZodEnum<{
+                                in: "in";
+                                equals: "equals";
+                                not_equals: "not_equals";
+                                contains: "contains";
+                                not_contains: "not_contains";
+                                greater_than: "greater_than";
+                                less_than: "less_than";
+                                greater_than_or_equal: "greater_than_or_equal";
+                                less_than_or_equal: "less_than_or_equal";
+                                not_in: "not_in";
+                                exists: "exists";
+                                not_exists: "not_exists";
+                            }>;
+                            value: z.ZodOptional<z.ZodUnknown>;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>]>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        rules: z.ZodOptional<z.ZodObject<{
+            operator: z.ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>]>>>;
+    integrationTools: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodObject<{
+        tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            rules: z.ZodOptional<z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        operator: z.ZodEnum<{
+                            AND: "AND";
+                            OR: "OR";
+                        }>;
+                        conditions: z.ZodArray<z.ZodObject<{
+                            field: z.ZodString;
+                            operator: z.ZodEnum<{
+                                in: "in";
+                                equals: "equals";
+                                not_equals: "not_equals";
+                                contains: "contains";
+                                not_contains: "not_contains";
+                                greater_than: "greater_than";
+                                less_than: "less_than";
+                                greater_than_or_equal: "greater_than_or_equal";
+                                less_than_or_equal: "less_than_or_equal";
+                                not_in: "not_in";
+                                exists: "exists";
+                                not_exists: "not_exists";
+                            }>;
+                            value: z.ZodOptional<z.ZodUnknown>;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>]>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>, z.ZodArray<z.ZodObject<{
+        value: z.ZodRecord<z.ZodString, z.ZodObject<{
+            tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                description: z.ZodOptional<z.ZodString>;
+                rules: z.ZodOptional<z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        operator: z.ZodEnum<{
+                            AND: "AND";
+                            OR: "OR";
+                        }>;
+                        conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                            field: z.ZodString;
+                            operator: z.ZodEnum<{
+                                in: "in";
+                                equals: "equals";
+                                not_equals: "not_equals";
+                                contains: "contains";
+                                not_contains: "not_contains";
+                                greater_than: "greater_than";
+                                less_than: "less_than";
+                                greater_than_or_equal: "greater_than_or_equal";
+                                less_than_or_equal: "less_than_or_equal";
+                                not_in: "not_in";
+                                exists: "exists";
+                                not_exists: "not_exists";
+                            }>;
+                            value: z.ZodOptional<z.ZodUnknown>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            operator: z.ZodEnum<{
+                                AND: "AND";
+                                OR: "OR";
+                            }>;
+                            conditions: z.ZodArray<z.ZodObject<{
+                                field: z.ZodString;
+                                operator: z.ZodEnum<{
+                                    in: "in";
+                                    equals: "equals";
+                                    not_equals: "not_equals";
+                                    contains: "contains";
+                                    not_contains: "not_contains";
+                                    greater_than: "greater_than";
+                                    less_than: "less_than";
+                                    greater_than_or_equal: "greater_than_or_equal";
+                                    less_than_or_equal: "less_than_or_equal";
+                                    not_in: "not_in";
+                                    exists: "exists";
+                                    not_exists: "not_exists";
+                                }>;
+                                value: z.ZodOptional<z.ZodUnknown>;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>]>>;
+                    }, z.core.$strip>]>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        rules: z.ZodOptional<z.ZodObject<{
+            operator: z.ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>]>>>;
+    toolProviders: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodObject<{
+        tools: z.ZodRecord<z.ZodString, z.ZodObject<{
+            toolkit: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        connections: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                author: "author";
+                invoker: "invoker";
+                platform: "platform";
+            }>;
+            toolkit: z.ZodString;
+            connectionId: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            scope: z.ZodOptional<z.ZodEnum<{
+                shared: "shared";
+                "per-author": "per-author";
+                "caller-supplied": "caller-supplied";
+            }>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>, z.ZodArray<z.ZodObject<{
+        value: z.ZodRecord<z.ZodString, z.ZodObject<{
+            tools: z.ZodRecord<z.ZodString, z.ZodObject<{
+                toolkit: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            connections: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    author: "author";
+                    invoker: "invoker";
+                    platform: "platform";
+                }>;
+                toolkit: z.ZodString;
+                connectionId: z.ZodString;
+                label: z.ZodOptional<z.ZodString>;
+                scope: z.ZodOptional<z.ZodEnum<{
+                    shared: "shared";
+                    "per-author": "per-author";
+                    "caller-supplied": "caller-supplied";
+                }>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        rules: z.ZodOptional<z.ZodObject<{
+            operator: z.ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>]>>>;
+    mcpClients: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodObject<{
+        tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            rules: z.ZodOptional<z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        operator: z.ZodEnum<{
+                            AND: "AND";
+                            OR: "OR";
+                        }>;
+                        conditions: z.ZodArray<z.ZodObject<{
+                            field: z.ZodString;
+                            operator: z.ZodEnum<{
+                                in: "in";
+                                equals: "equals";
+                                not_equals: "not_equals";
+                                contains: "contains";
+                                not_contains: "not_contains";
+                                greater_than: "greater_than";
+                                less_than: "less_than";
+                                greater_than_or_equal: "greater_than_or_equal";
+                                less_than_or_equal: "less_than_or_equal";
+                                not_in: "not_in";
+                                exists: "exists";
+                                not_exists: "not_exists";
+                            }>;
+                            value: z.ZodOptional<z.ZodUnknown>;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>]>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>, z.ZodArray<z.ZodObject<{
+        value: z.ZodRecord<z.ZodString, z.ZodObject<{
+            tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                description: z.ZodOptional<z.ZodString>;
+                rules: z.ZodOptional<z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        operator: z.ZodEnum<{
+                            AND: "AND";
+                            OR: "OR";
+                        }>;
+                        conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                            field: z.ZodString;
+                            operator: z.ZodEnum<{
+                                in: "in";
+                                equals: "equals";
+                                not_equals: "not_equals";
+                                contains: "contains";
+                                not_contains: "not_contains";
+                                greater_than: "greater_than";
+                                less_than: "less_than";
+                                greater_than_or_equal: "greater_than_or_equal";
+                                less_than_or_equal: "less_than_or_equal";
+                                not_in: "not_in";
+                                exists: "exists";
+                                not_exists: "not_exists";
+                            }>;
+                            value: z.ZodOptional<z.ZodUnknown>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            operator: z.ZodEnum<{
+                                AND: "AND";
+                                OR: "OR";
+                            }>;
+                            conditions: z.ZodArray<z.ZodObject<{
+                                field: z.ZodString;
+                                operator: z.ZodEnum<{
+                                    in: "in";
+                                    equals: "equals";
+                                    not_equals: "not_equals";
+                                    contains: "contains";
+                                    not_contains: "not_contains";
+                                    greater_than: "greater_than";
+                                    less_than: "less_than";
+                                    greater_than_or_equal: "greater_than_or_equal";
+                                    less_than_or_equal: "less_than_or_equal";
+                                    not_in: "not_in";
+                                    exists: "exists";
+                                    not_exists: "not_exists";
+                                }>;
+                                value: z.ZodOptional<z.ZodUnknown>;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>]>>;
+                    }, z.core.$strip>]>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        rules: z.ZodOptional<z.ZodObject<{
+            operator: z.ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>]>>>;
+    inputProcessors: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"step">;
+            step: z.ZodObject<{
+                id: z.ZodString;
+                providerId: z.ZodString;
+                config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                enabledPhases: z.ZodArray<z.ZodEnum<{
+                    processInput: "processInput";
+                    processInputStep: "processInputStep";
+                    processOutputStream: "processOutputStream";
+                    processOutputResult: "processOutputResult";
+                    processOutputStep: "processOutputStep";
+                }>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"parallel">;
+            branches: z.ZodArray<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"step">;
+                step: z.ZodObject<{
+                    id: z.ZodString;
+                    providerId: z.ZodString;
+                    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                    enabledPhases: z.ZodArray<z.ZodEnum<{
+                        processInput: "processInput";
+                        processInputStep: "processInputStep";
+                        processOutputStream: "processOutputStream";
+                        processOutputResult: "processOutputResult";
+                        processOutputStep: "processOutputStep";
+                    }>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"parallel">;
+                branches: z.ZodArray<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"step">;
+                    step: z.ZodObject<{
+                        id: z.ZodString;
+                        providerId: z.ZodString;
+                        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        enabledPhases: z.ZodArray<z.ZodEnum<{
+                            processInput: "processInput";
+                            processInputStep: "processInputStep";
+                            processOutputStream: "processOutputStream";
+                            processOutputResult: "processOutputResult";
+                            processOutputStep: "processOutputStep";
+                        }>>;
+                    }, z.core.$strip>;
+                }, z.core.$strip>], "type">>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"conditional">;
+                conditions: z.ZodArray<z.ZodObject<{
+                    steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"step">;
+                        step: z.ZodObject<{
+                            id: z.ZodString;
+                            providerId: z.ZodString;
+                            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                            enabledPhases: z.ZodArray<z.ZodEnum<{
+                                processInput: "processInput";
+                                processInputStep: "processInputStep";
+                                processOutputStream: "processOutputStream";
+                                processOutputResult: "processOutputResult";
+                                processOutputStep: "processOutputStep";
+                            }>>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>], "type">>;
+                    rules: z.ZodOptional<z.ZodObject<{
+                        operator: z.ZodEnum<{
+                            AND: "AND";
+                            OR: "OR";
+                        }>;
+                        conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                            field: z.ZodString;
+                            operator: z.ZodEnum<{
+                                in: "in";
+                                equals: "equals";
+                                not_equals: "not_equals";
+                                contains: "contains";
+                                not_contains: "not_contains";
+                                greater_than: "greater_than";
+                                less_than: "less_than";
+                                greater_than_or_equal: "greater_than_or_equal";
+                                less_than_or_equal: "less_than_or_equal";
+                                not_in: "not_in";
+                                exists: "exists";
+                                not_exists: "not_exists";
+                            }>;
+                            value: z.ZodOptional<z.ZodUnknown>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            operator: z.ZodEnum<{
+                                AND: "AND";
+                                OR: "OR";
+                            }>;
+                            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                                field: z.ZodString;
+                                operator: z.ZodEnum<{
+                                    in: "in";
+                                    equals: "equals";
+                                    not_equals: "not_equals";
+                                    contains: "contains";
+                                    not_contains: "not_contains";
+                                    greater_than: "greater_than";
+                                    less_than: "less_than";
+                                    greater_than_or_equal: "greater_than_or_equal";
+                                    less_than_or_equal: "less_than_or_equal";
+                                    not_in: "not_in";
+                                    exists: "exists";
+                                    not_exists: "not_exists";
+                                }>;
+                                value: z.ZodOptional<z.ZodUnknown>;
+                            }, z.core.$strip>, z.ZodObject<{
+                                operator: z.ZodEnum<{
+                                    AND: "AND";
+                                    OR: "OR";
+                                }>;
+                                conditions: z.ZodArray<z.ZodObject<{
+                                    field: z.ZodString;
+                                    operator: z.ZodEnum<{
+                                        in: "in";
+                                        equals: "equals";
+                                        not_equals: "not_equals";
+                                        contains: "contains";
+                                        not_contains: "not_contains";
+                                        greater_than: "greater_than";
+                                        less_than: "less_than";
+                                        greater_than_or_equal: "greater_than_or_equal";
+                                        less_than_or_equal: "less_than_or_equal";
+                                        not_in: "not_in";
+                                        exists: "exists";
+                                        not_exists: "not_exists";
+                                    }>;
+                                    value: z.ZodOptional<z.ZodUnknown>;
+                                }, z.core.$strip>>;
+                            }, z.core.$strip>]>>;
+                        }, z.core.$strip>]>>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>], "type">>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"conditional">;
+            conditions: z.ZodArray<z.ZodObject<{
+                steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"step">;
+                    step: z.ZodObject<{
+                        id: z.ZodString;
+                        providerId: z.ZodString;
+                        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        enabledPhases: z.ZodArray<z.ZodEnum<{
+                            processInput: "processInput";
+                            processInputStep: "processInputStep";
+                            processOutputStream: "processOutputStream";
+                            processOutputResult: "processOutputResult";
+                            processOutputStep: "processOutputStep";
+                        }>>;
+                    }, z.core.$strip>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"parallel">;
+                    branches: z.ZodArray<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"step">;
+                        step: z.ZodObject<{
+                            id: z.ZodString;
+                            providerId: z.ZodString;
+                            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                            enabledPhases: z.ZodArray<z.ZodEnum<{
+                                processInput: "processInput";
+                                processInputStep: "processInputStep";
+                                processOutputStream: "processOutputStream";
+                                processOutputResult: "processOutputResult";
+                                processOutputStep: "processOutputStep";
+                            }>>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>], "type">>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"conditional">;
+                    conditions: z.ZodArray<z.ZodObject<{
+                        steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                            type: z.ZodLiteral<"step">;
+                            step: z.ZodObject<{
+                                id: z.ZodString;
+                                providerId: z.ZodString;
+                                config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                                enabledPhases: z.ZodArray<z.ZodEnum<{
+                                    processInput: "processInput";
+                                    processInputStep: "processInputStep";
+                                    processOutputStream: "processOutputStream";
+                                    processOutputResult: "processOutputResult";
+                                    processOutputStep: "processOutputStep";
+                                }>>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>], "type">>;
+                        rules: z.ZodOptional<z.ZodObject<{
+                            operator: z.ZodEnum<{
+                                AND: "AND";
+                                OR: "OR";
+                            }>;
+                            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                                field: z.ZodString;
+                                operator: z.ZodEnum<{
+                                    in: "in";
+                                    equals: "equals";
+                                    not_equals: "not_equals";
+                                    contains: "contains";
+                                    not_contains: "not_contains";
+                                    greater_than: "greater_than";
+                                    less_than: "less_than";
+                                    greater_than_or_equal: "greater_than_or_equal";
+                                    less_than_or_equal: "less_than_or_equal";
+                                    not_in: "not_in";
+                                    exists: "exists";
+                                    not_exists: "not_exists";
+                                }>;
+                                value: z.ZodOptional<z.ZodUnknown>;
+                            }, z.core.$strip>, z.ZodObject<{
+                                operator: z.ZodEnum<{
+                                    AND: "AND";
+                                    OR: "OR";
+                                }>;
+                                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                                    field: z.ZodString;
+                                    operator: z.ZodEnum<{
+                                        in: "in";
+                                        equals: "equals";
+                                        not_equals: "not_equals";
+                                        contains: "contains";
+                                        not_contains: "not_contains";
+                                        greater_than: "greater_than";
+                                        less_than: "less_than";
+                                        greater_than_or_equal: "greater_than_or_equal";
+                                        less_than_or_equal: "less_than_or_equal";
+                                        not_in: "not_in";
+                                        exists: "exists";
+                                        not_exists: "not_exists";
+                                    }>;
+                                    value: z.ZodOptional<z.ZodUnknown>;
+                                }, z.core.$strip>, z.ZodObject<{
+                                    operator: z.ZodEnum<{
+                                        AND: "AND";
+                                        OR: "OR";
+                                    }>;
+                                    conditions: z.ZodArray<z.ZodObject<{
+                                        field: z.ZodString;
+                                        operator: z.ZodEnum<{
+                                            in: "in";
+                                            equals: "equals";
+                                            not_equals: "not_equals";
+                                            contains: "contains";
+                                            not_contains: "not_contains";
+                                            greater_than: "greater_than";
+                                            less_than: "less_than";
+                                            greater_than_or_equal: "greater_than_or_equal";
+                                            less_than_or_equal: "less_than_or_equal";
+                                            not_in: "not_in";
+                                            exists: "exists";
+                                            not_exists: "not_exists";
+                                        }>;
+                                        value: z.ZodOptional<z.ZodUnknown>;
+                                    }, z.core.$strip>>;
+                                }, z.core.$strip>]>>;
+                            }, z.core.$strip>]>>;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>], "type">>;
+                rules: z.ZodOptional<z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        operator: z.ZodEnum<{
+                            AND: "AND";
+                            OR: "OR";
+                        }>;
+                        conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                            field: z.ZodString;
+                            operator: z.ZodEnum<{
+                                in: "in";
+                                equals: "equals";
+                                not_equals: "not_equals";
+                                contains: "contains";
+                                not_contains: "not_contains";
+                                greater_than: "greater_than";
+                                less_than: "less_than";
+                                greater_than_or_equal: "greater_than_or_equal";
+                                less_than_or_equal: "less_than_or_equal";
+                                not_in: "not_in";
+                                exists: "exists";
+                                not_exists: "not_exists";
+                            }>;
+                            value: z.ZodOptional<z.ZodUnknown>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            operator: z.ZodEnum<{
+                                AND: "AND";
+                                OR: "OR";
+                            }>;
+                            conditions: z.ZodArray<z.ZodObject<{
+                                field: z.ZodString;
+                                operator: z.ZodEnum<{
+                                    in: "in";
+                                    equals: "equals";
+                                    not_equals: "not_equals";
+                                    contains: "contains";
+                                    not_contains: "not_contains";
+                                    greater_than: "greater_than";
+                                    less_than: "less_than";
+                                    greater_than_or_equal: "greater_than_or_equal";
+                                    less_than_or_equal: "less_than_or_equal";
+                                    not_in: "not_in";
+                                    exists: "exists";
+                                    not_exists: "not_exists";
+                                }>;
+                                value: z.ZodOptional<z.ZodUnknown>;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>]>>;
+                    }, z.core.$strip>]>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>], "type">>;
+    }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+        value: z.ZodObject<{
+            steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"step">;
+                step: z.ZodObject<{
+                    id: z.ZodString;
+                    providerId: z.ZodString;
+                    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                    enabledPhases: z.ZodArray<z.ZodEnum<{
+                        processInput: "processInput";
+                        processInputStep: "processInputStep";
+                        processOutputStream: "processOutputStream";
+                        processOutputResult: "processOutputResult";
+                        processOutputStep: "processOutputStep";
+                    }>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"parallel">;
+                branches: z.ZodArray<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"step">;
+                    step: z.ZodObject<{
+                        id: z.ZodString;
+                        providerId: z.ZodString;
+                        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        enabledPhases: z.ZodArray<z.ZodEnum<{
+                            processInput: "processInput";
+                            processInputStep: "processInputStep";
+                            processOutputStream: "processOutputStream";
+                            processOutputResult: "processOutputResult";
+                            processOutputStep: "processOutputStep";
+                        }>>;
+                    }, z.core.$strip>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"parallel">;
+                    branches: z.ZodArray<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"step">;
+                        step: z.ZodObject<{
+                            id: z.ZodString;
+                            providerId: z.ZodString;
+                            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                            enabledPhases: z.ZodArray<z.ZodEnum<{
+                                processInput: "processInput";
+                                processInputStep: "processInputStep";
+                                processOutputStream: "processOutputStream";
+                                processOutputResult: "processOutputResult";
+                                processOutputStep: "processOutputStep";
+                            }>>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>], "type">>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"conditional">;
+                    conditions: z.ZodArray<z.ZodObject<{
+                        steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                            type: z.ZodLiteral<"step">;
+                            step: z.ZodObject<{
+                                id: z.ZodString;
+                                providerId: z.ZodString;
+                                config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                                enabledPhases: z.ZodArray<z.ZodEnum<{
+                                    processInput: "processInput";
+                                    processInputStep: "processInputStep";
+                                    processOutputStream: "processOutputStream";
+                                    processOutputResult: "processOutputResult";
+                                    processOutputStep: "processOutputStep";
+                                }>>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>], "type">>;
+                        rules: z.ZodOptional<z.ZodObject<{
+                            operator: z.ZodEnum<{
+                                AND: "AND";
+                                OR: "OR";
+                            }>;
+                            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                                field: z.ZodString;
+                                operator: z.ZodEnum<{
+                                    in: "in";
+                                    equals: "equals";
+                                    not_equals: "not_equals";
+                                    contains: "contains";
+                                    not_contains: "not_contains";
+                                    greater_than: "greater_than";
+                                    less_than: "less_than";
+                                    greater_than_or_equal: "greater_than_or_equal";
+                                    less_than_or_equal: "less_than_or_equal";
+                                    not_in: "not_in";
+                                    exists: "exists";
+                                    not_exists: "not_exists";
+                                }>;
+                                value: z.ZodOptional<z.ZodUnknown>;
+                            }, z.core.$strip>, z.ZodObject<{
+                                operator: z.ZodEnum<{
+                                    AND: "AND";
+                                    OR: "OR";
+                                }>;
+                                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                                    field: z.ZodString;
+                                    operator: z.ZodEnum<{
+                                        in: "in";
+                                        equals: "equals";
+                                        not_equals: "not_equals";
+                                        contains: "contains";
+                                        not_contains: "not_contains";
+                                        greater_than: "greater_than";
+                                        less_than: "less_than";
+                                        greater_than_or_equal: "greater_than_or_equal";
+                                        less_than_or_equal: "less_than_or_equal";
+                                        not_in: "not_in";
+                                        exists: "exists";
+                                        not_exists: "not_exists";
+                                    }>;
+                                    value: z.ZodOptional<z.ZodUnknown>;
+                                }, z.core.$strip>, z.ZodObject<{
+                                    operator: z.ZodEnum<{
+                                        AND: "AND";
+                                        OR: "OR";
+                                    }>;
+                                    conditions: z.ZodArray<z.ZodObject<{
+                                        field: z.ZodString;
+                                        operator: z.ZodEnum<{
+                                            in: "in";
+                                            equals: "equals";
+                                            not_equals: "not_equals";
+                                            contains: "contains";
+                                            not_contains: "not_contains";
+                                            greater_than: "greater_than";
+                                            less_than: "less_than";
+                                            greater_than_or_equal: "greater_than_or_equal";
+                                            less_than_or_equal: "less_than_or_equal";
+                                            not_in: "not_in";
+                                            exists: "exists";
+                                            not_exists: "not_exists";
+                                        }>;
+                                        value: z.ZodOptional<z.ZodUnknown>;
+                                    }, z.core.$strip>>;
+                                }, z.core.$strip>]>>;
+                            }, z.core.$strip>]>>;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>], "type">>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"conditional">;
+                conditions: z.ZodArray<z.ZodObject<{
+                    steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"step">;
+                        step: z.ZodObject<{
+                            id: z.ZodString;
+                            providerId: z.ZodString;
+                            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                            enabledPhases: z.ZodArray<z.ZodEnum<{
+                                processInput: "processInput";
+                                processInputStep: "processInputStep";
+                                processOutputStream: "processOutputStream";
+                                processOutputResult: "processOutputResult";
+                                processOutputStep: "processOutputStep";
+                            }>>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        type: z.ZodLiteral<"parallel">;
+                        branches: z.ZodArray<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                            type: z.ZodLiteral<"step">;
+                            step: z.ZodObject<{
+                                id: z.ZodString;
+                                providerId: z.ZodString;
+                                config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                                enabledPhases: z.ZodArray<z.ZodEnum<{
+                                    processInput: "processInput";
+                                    processInputStep: "processInputStep";
+                                    processOutputStream: "processOutputStream";
+                                    processOutputResult: "processOutputResult";
+                                    processOutputStep: "processOutputStep";
+                                }>>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>], "type">>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        type: z.ZodLiteral<"conditional">;
+                        conditions: z.ZodArray<z.ZodObject<{
+                            steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                                type: z.ZodLiteral<"step">;
+                                step: z.ZodObject<{
+                                    id: z.ZodString;
+                                    providerId: z.ZodString;
+                                    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                                    enabledPhases: z.ZodArray<z.ZodEnum<{
+                                        processInput: "processInput";
+                                        processInputStep: "processInputStep";
+                                        processOutputStream: "processOutputStream";
+                                        processOutputResult: "processOutputResult";
+                                        processOutputStep: "processOutputStep";
+                                    }>>;
+                                }, z.core.$strip>;
+                            }, z.core.$strip>], "type">>;
+                            rules: z.ZodOptional<z.ZodObject<{
+                                operator: z.ZodEnum<{
+                                    AND: "AND";
+                                    OR: "OR";
+                                }>;
+                                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                                    field: z.ZodString;
+                                    operator: z.ZodEnum<{
+                                        in: "in";
+                                        equals: "equals";
+                                        not_equals: "not_equals";
+                                        contains: "contains";
+                                        not_contains: "not_contains";
+                                        greater_than: "greater_than";
+                                        less_than: "less_than";
+                                        greater_than_or_equal: "greater_than_or_equal";
+                                        less_than_or_equal: "less_than_or_equal";
+                                        not_in: "not_in";
+                                        exists: "exists";
+                                        not_exists: "not_exists";
+                                    }>;
+                                    value: z.ZodOptional<z.ZodUnknown>;
+                                }, z.core.$strip>, z.ZodObject<{
+                                    operator: z.ZodEnum<{
+                                        AND: "AND";
+                                        OR: "OR";
+                                    }>;
+                                    conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                                        field: z.ZodString;
+                                        operator: z.ZodEnum<{
+                                            in: "in";
+                                            equals: "equals";
+                                            not_equals: "not_equals";
+                                            contains: "contains";
+                                            not_contains: "not_contains";
+                                            greater_than: "greater_than";
+                                            less_than: "less_than";
+                                            greater_than_or_equal: "greater_than_or_equal";
+                                            less_than_or_equal: "less_than_or_equal";
+                                            not_in: "not_in";
+                                            exists: "exists";
+                                            not_exists: "not_exists";
+                                        }>;
+                                        value: z.ZodOptional<z.ZodUnknown>;
+                                    }, z.core.$strip>, z.ZodObject<{
+                                        operator: z.ZodEnum<{
+                                            AND: "AND";
+                                            OR: "OR";
+                                        }>;
+                                        conditions: z.ZodArray<z.ZodObject<{
+                                            field: z.ZodString;
+                                            operator: z.ZodEnum<{
+                                                in: "in";
+                                                equals: "equals";
+                                                not_equals: "not_equals";
+                                                contains: "contains";
+                                                not_contains: "not_contains";
+                                                greater_than: "greater_than";
+                                                less_than: "less_than";
+                                                greater_than_or_equal: "greater_than_or_equal";
+                                                less_than_or_equal: "less_than_or_equal";
+                                                not_in: "not_in";
+                                                exists: "exists";
+                                                not_exists: "not_exists";
+                                            }>;
+                                            value: z.ZodOptional<z.ZodUnknown>;
+                                        }, z.core.$strip>>;
+                                    }, z.core.$strip>]>>;
+                                }, z.core.$strip>]>>;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>], "type">>;
+                    rules: z.ZodOptional<z.ZodObject<{
+                        operator: z.ZodEnum<{
+                            AND: "AND";
+                            OR: "OR";
+                        }>;
+                        conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                            field: z.ZodString;
+                            operator: z.ZodEnum<{
+                                in: "in";
+                                equals: "equals";
+                                not_equals: "not_equals";
+                                contains: "contains";
+                                not_contains: "not_contains";
+                                greater_than: "greater_than";
+                                less_than: "less_than";
+                                greater_than_or_equal: "greater_than_or_equal";
+                                less_than_or_equal: "less_than_or_equal";
+                                not_in: "not_in";
+                                exists: "exists";
+                                not_exists: "not_exists";
+                            }>;
+                            value: z.ZodOptional<z.ZodUnknown>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            operator: z.ZodEnum<{
+                                AND: "AND";
+                                OR: "OR";
+                            }>;
+                            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                                field: z.ZodString;
+                                operator: z.ZodEnum<{
+                                    in: "in";
+                                    equals: "equals";
+                                    not_equals: "not_equals";
+                                    contains: "contains";
+                                    not_contains: "not_contains";
+                                    greater_than: "greater_than";
+                                    less_than: "less_than";
+                                    greater_than_or_equal: "greater_than_or_equal";
+                                    less_than_or_equal: "less_than_or_equal";
+                                    not_in: "not_in";
+                                    exists: "exists";
+                                    not_exists: "not_exists";
+                                }>;
+                                value: z.ZodOptional<z.ZodUnknown>;
+                            }, z.core.$strip>, z.ZodObject<{
+                                operator: z.ZodEnum<{
+                                    AND: "AND";
+                                    OR: "OR";
+                                }>;
+                                conditions: z.ZodArray<z.ZodObject<{
+                                    field: z.ZodString;
+                                    operator: z.ZodEnum<{
+                                        in: "in";
+                                        equals: "equals";
+                                        not_equals: "not_equals";
+                                        contains: "contains";
+                                        not_contains: "not_contains";
+                                        greater_than: "greater_than";
+                                        less_than: "less_than";
+                                        greater_than_or_equal: "greater_than_or_equal";
+                                        less_than_or_equal: "less_than_or_equal";
+                                        not_in: "not_in";
+                                        exists: "exists";
+                                        not_exists: "not_exists";
+                                    }>;
+                                    value: z.ZodOptional<z.ZodUnknown>;
+                                }, z.core.$strip>>;
+                            }, z.core.$strip>]>>;
+                        }, z.core.$strip>]>>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>], "type">>;
+        }, z.core.$strip>;
+        rules: z.ZodOptional<z.ZodObject<{
+            operator: z.ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>]>>>;
+    outputProcessors: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"step">;
+            step: z.ZodObject<{
+                id: z.ZodString;
+                providerId: z.ZodString;
+                config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                enabledPhases: z.ZodArray<z.ZodEnum<{
+                    processInput: "processInput";
+                    processInputStep: "processInputStep";
+                    processOutputStream: "processOutputStream";
+                    processOutputResult: "processOutputResult";
+                    processOutputStep: "processOutputStep";
+                }>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"parallel">;
+            branches: z.ZodArray<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"step">;
+                step: z.ZodObject<{
+                    id: z.ZodString;
+                    providerId: z.ZodString;
+                    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                    enabledPhases: z.ZodArray<z.ZodEnum<{
+                        processInput: "processInput";
+                        processInputStep: "processInputStep";
+                        processOutputStream: "processOutputStream";
+                        processOutputResult: "processOutputResult";
+                        processOutputStep: "processOutputStep";
+                    }>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"parallel">;
+                branches: z.ZodArray<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"step">;
+                    step: z.ZodObject<{
+                        id: z.ZodString;
+                        providerId: z.ZodString;
+                        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        enabledPhases: z.ZodArray<z.ZodEnum<{
+                            processInput: "processInput";
+                            processInputStep: "processInputStep";
+                            processOutputStream: "processOutputStream";
+                            processOutputResult: "processOutputResult";
+                            processOutputStep: "processOutputStep";
+                        }>>;
+                    }, z.core.$strip>;
+                }, z.core.$strip>], "type">>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"conditional">;
+                conditions: z.ZodArray<z.ZodObject<{
+                    steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"step">;
+                        step: z.ZodObject<{
+                            id: z.ZodString;
+                            providerId: z.ZodString;
+                            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                            enabledPhases: z.ZodArray<z.ZodEnum<{
+                                processInput: "processInput";
+                                processInputStep: "processInputStep";
+                                processOutputStream: "processOutputStream";
+                                processOutputResult: "processOutputResult";
+                                processOutputStep: "processOutputStep";
+                            }>>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>], "type">>;
+                    rules: z.ZodOptional<z.ZodObject<{
+                        operator: z.ZodEnum<{
+                            AND: "AND";
+                            OR: "OR";
+                        }>;
+                        conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                            field: z.ZodString;
+                            operator: z.ZodEnum<{
+                                in: "in";
+                                equals: "equals";
+                                not_equals: "not_equals";
+                                contains: "contains";
+                                not_contains: "not_contains";
+                                greater_than: "greater_than";
+                                less_than: "less_than";
+                                greater_than_or_equal: "greater_than_or_equal";
+                                less_than_or_equal: "less_than_or_equal";
+                                not_in: "not_in";
+                                exists: "exists";
+                                not_exists: "not_exists";
+                            }>;
+                            value: z.ZodOptional<z.ZodUnknown>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            operator: z.ZodEnum<{
+                                AND: "AND";
+                                OR: "OR";
+                            }>;
+                            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                                field: z.ZodString;
+                                operator: z.ZodEnum<{
+                                    in: "in";
+                                    equals: "equals";
+                                    not_equals: "not_equals";
+                                    contains: "contains";
+                                    not_contains: "not_contains";
+                                    greater_than: "greater_than";
+                                    less_than: "less_than";
+                                    greater_than_or_equal: "greater_than_or_equal";
+                                    less_than_or_equal: "less_than_or_equal";
+                                    not_in: "not_in";
+                                    exists: "exists";
+                                    not_exists: "not_exists";
+                                }>;
+                                value: z.ZodOptional<z.ZodUnknown>;
+                            }, z.core.$strip>, z.ZodObject<{
+                                operator: z.ZodEnum<{
+                                    AND: "AND";
+                                    OR: "OR";
+                                }>;
+                                conditions: z.ZodArray<z.ZodObject<{
+                                    field: z.ZodString;
+                                    operator: z.ZodEnum<{
+                                        in: "in";
+                                        equals: "equals";
+                                        not_equals: "not_equals";
+                                        contains: "contains";
+                                        not_contains: "not_contains";
+                                        greater_than: "greater_than";
+                                        less_than: "less_than";
+                                        greater_than_or_equal: "greater_than_or_equal";
+                                        less_than_or_equal: "less_than_or_equal";
+                                        not_in: "not_in";
+                                        exists: "exists";
+                                        not_exists: "not_exists";
+                                    }>;
+                                    value: z.ZodOptional<z.ZodUnknown>;
+                                }, z.core.$strip>>;
+                            }, z.core.$strip>]>>;
+                        }, z.core.$strip>]>>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>], "type">>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"conditional">;
+            conditions: z.ZodArray<z.ZodObject<{
+                steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"step">;
+                    step: z.ZodObject<{
+                        id: z.ZodString;
+                        providerId: z.ZodString;
+                        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        enabledPhases: z.ZodArray<z.ZodEnum<{
+                            processInput: "processInput";
+                            processInputStep: "processInputStep";
+                            processOutputStream: "processOutputStream";
+                            processOutputResult: "processOutputResult";
+                            processOutputStep: "processOutputStep";
+                        }>>;
+                    }, z.core.$strip>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"parallel">;
+                    branches: z.ZodArray<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"step">;
+                        step: z.ZodObject<{
+                            id: z.ZodString;
+                            providerId: z.ZodString;
+                            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                            enabledPhases: z.ZodArray<z.ZodEnum<{
+                                processInput: "processInput";
+                                processInputStep: "processInputStep";
+                                processOutputStream: "processOutputStream";
+                                processOutputResult: "processOutputResult";
+                                processOutputStep: "processOutputStep";
+                            }>>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>], "type">>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"conditional">;
+                    conditions: z.ZodArray<z.ZodObject<{
+                        steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                            type: z.ZodLiteral<"step">;
+                            step: z.ZodObject<{
+                                id: z.ZodString;
+                                providerId: z.ZodString;
+                                config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                                enabledPhases: z.ZodArray<z.ZodEnum<{
+                                    processInput: "processInput";
+                                    processInputStep: "processInputStep";
+                                    processOutputStream: "processOutputStream";
+                                    processOutputResult: "processOutputResult";
+                                    processOutputStep: "processOutputStep";
+                                }>>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>], "type">>;
+                        rules: z.ZodOptional<z.ZodObject<{
+                            operator: z.ZodEnum<{
+                                AND: "AND";
+                                OR: "OR";
+                            }>;
+                            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                                field: z.ZodString;
+                                operator: z.ZodEnum<{
+                                    in: "in";
+                                    equals: "equals";
+                                    not_equals: "not_equals";
+                                    contains: "contains";
+                                    not_contains: "not_contains";
+                                    greater_than: "greater_than";
+                                    less_than: "less_than";
+                                    greater_than_or_equal: "greater_than_or_equal";
+                                    less_than_or_equal: "less_than_or_equal";
+                                    not_in: "not_in";
+                                    exists: "exists";
+                                    not_exists: "not_exists";
+                                }>;
+                                value: z.ZodOptional<z.ZodUnknown>;
+                            }, z.core.$strip>, z.ZodObject<{
+                                operator: z.ZodEnum<{
+                                    AND: "AND";
+                                    OR: "OR";
+                                }>;
+                                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                                    field: z.ZodString;
+                                    operator: z.ZodEnum<{
+                                        in: "in";
+                                        equals: "equals";
+                                        not_equals: "not_equals";
+                                        contains: "contains";
+                                        not_contains: "not_contains";
+                                        greater_than: "greater_than";
+                                        less_than: "less_than";
+                                        greater_than_or_equal: "greater_than_or_equal";
+                                        less_than_or_equal: "less_than_or_equal";
+                                        not_in: "not_in";
+                                        exists: "exists";
+                                        not_exists: "not_exists";
+                                    }>;
+                                    value: z.ZodOptional<z.ZodUnknown>;
+                                }, z.core.$strip>, z.ZodObject<{
+                                    operator: z.ZodEnum<{
+                                        AND: "AND";
+                                        OR: "OR";
+                                    }>;
+                                    conditions: z.ZodArray<z.ZodObject<{
+                                        field: z.ZodString;
+                                        operator: z.ZodEnum<{
+                                            in: "in";
+                                            equals: "equals";
+                                            not_equals: "not_equals";
+                                            contains: "contains";
+                                            not_contains: "not_contains";
+                                            greater_than: "greater_than";
+                                            less_than: "less_than";
+                                            greater_than_or_equal: "greater_than_or_equal";
+                                            less_than_or_equal: "less_than_or_equal";
+                                            not_in: "not_in";
+                                            exists: "exists";
+                                            not_exists: "not_exists";
+                                        }>;
+                                        value: z.ZodOptional<z.ZodUnknown>;
+                                    }, z.core.$strip>>;
+                                }, z.core.$strip>]>>;
+                            }, z.core.$strip>]>>;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>], "type">>;
+                rules: z.ZodOptional<z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        operator: z.ZodEnum<{
+                            AND: "AND";
+                            OR: "OR";
+                        }>;
+                        conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                            field: z.ZodString;
+                            operator: z.ZodEnum<{
+                                in: "in";
+                                equals: "equals";
+                                not_equals: "not_equals";
+                                contains: "contains";
+                                not_contains: "not_contains";
+                                greater_than: "greater_than";
+                                less_than: "less_than";
+                                greater_than_or_equal: "greater_than_or_equal";
+                                less_than_or_equal: "less_than_or_equal";
+                                not_in: "not_in";
+                                exists: "exists";
+                                not_exists: "not_exists";
+                            }>;
+                            value: z.ZodOptional<z.ZodUnknown>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            operator: z.ZodEnum<{
+                                AND: "AND";
+                                OR: "OR";
+                            }>;
+                            conditions: z.ZodArray<z.ZodObject<{
+                                field: z.ZodString;
+                                operator: z.ZodEnum<{
+                                    in: "in";
+                                    equals: "equals";
+                                    not_equals: "not_equals";
+                                    contains: "contains";
+                                    not_contains: "not_contains";
+                                    greater_than: "greater_than";
+                                    less_than: "less_than";
+                                    greater_than_or_equal: "greater_than_or_equal";
+                                    less_than_or_equal: "less_than_or_equal";
+                                    not_in: "not_in";
+                                    exists: "exists";
+                                    not_exists: "not_exists";
+                                }>;
+                                value: z.ZodOptional<z.ZodUnknown>;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>]>>;
+                    }, z.core.$strip>]>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>], "type">>;
+    }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+        value: z.ZodObject<{
+            steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"step">;
+                step: z.ZodObject<{
+                    id: z.ZodString;
+                    providerId: z.ZodString;
+                    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                    enabledPhases: z.ZodArray<z.ZodEnum<{
+                        processInput: "processInput";
+                        processInputStep: "processInputStep";
+                        processOutputStream: "processOutputStream";
+                        processOutputResult: "processOutputResult";
+                        processOutputStep: "processOutputStep";
+                    }>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"parallel">;
+                branches: z.ZodArray<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"step">;
+                    step: z.ZodObject<{
+                        id: z.ZodString;
+                        providerId: z.ZodString;
+                        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        enabledPhases: z.ZodArray<z.ZodEnum<{
+                            processInput: "processInput";
+                            processInputStep: "processInputStep";
+                            processOutputStream: "processOutputStream";
+                            processOutputResult: "processOutputResult";
+                            processOutputStep: "processOutputStep";
+                        }>>;
+                    }, z.core.$strip>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"parallel">;
+                    branches: z.ZodArray<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"step">;
+                        step: z.ZodObject<{
+                            id: z.ZodString;
+                            providerId: z.ZodString;
+                            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                            enabledPhases: z.ZodArray<z.ZodEnum<{
+                                processInput: "processInput";
+                                processInputStep: "processInputStep";
+                                processOutputStream: "processOutputStream";
+                                processOutputResult: "processOutputResult";
+                                processOutputStep: "processOutputStep";
+                            }>>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>], "type">>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"conditional">;
+                    conditions: z.ZodArray<z.ZodObject<{
+                        steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                            type: z.ZodLiteral<"step">;
+                            step: z.ZodObject<{
+                                id: z.ZodString;
+                                providerId: z.ZodString;
+                                config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                                enabledPhases: z.ZodArray<z.ZodEnum<{
+                                    processInput: "processInput";
+                                    processInputStep: "processInputStep";
+                                    processOutputStream: "processOutputStream";
+                                    processOutputResult: "processOutputResult";
+                                    processOutputStep: "processOutputStep";
+                                }>>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>], "type">>;
+                        rules: z.ZodOptional<z.ZodObject<{
+                            operator: z.ZodEnum<{
+                                AND: "AND";
+                                OR: "OR";
+                            }>;
+                            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                                field: z.ZodString;
+                                operator: z.ZodEnum<{
+                                    in: "in";
+                                    equals: "equals";
+                                    not_equals: "not_equals";
+                                    contains: "contains";
+                                    not_contains: "not_contains";
+                                    greater_than: "greater_than";
+                                    less_than: "less_than";
+                                    greater_than_or_equal: "greater_than_or_equal";
+                                    less_than_or_equal: "less_than_or_equal";
+                                    not_in: "not_in";
+                                    exists: "exists";
+                                    not_exists: "not_exists";
+                                }>;
+                                value: z.ZodOptional<z.ZodUnknown>;
+                            }, z.core.$strip>, z.ZodObject<{
+                                operator: z.ZodEnum<{
+                                    AND: "AND";
+                                    OR: "OR";
+                                }>;
+                                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                                    field: z.ZodString;
+                                    operator: z.ZodEnum<{
+                                        in: "in";
+                                        equals: "equals";
+                                        not_equals: "not_equals";
+                                        contains: "contains";
+                                        not_contains: "not_contains";
+                                        greater_than: "greater_than";
+                                        less_than: "less_than";
+                                        greater_than_or_equal: "greater_than_or_equal";
+                                        less_than_or_equal: "less_than_or_equal";
+                                        not_in: "not_in";
+                                        exists: "exists";
+                                        not_exists: "not_exists";
+                                    }>;
+                                    value: z.ZodOptional<z.ZodUnknown>;
+                                }, z.core.$strip>, z.ZodObject<{
+                                    operator: z.ZodEnum<{
+                                        AND: "AND";
+                                        OR: "OR";
+                                    }>;
+                                    conditions: z.ZodArray<z.ZodObject<{
+                                        field: z.ZodString;
+                                        operator: z.ZodEnum<{
+                                            in: "in";
+                                            equals: "equals";
+                                            not_equals: "not_equals";
+                                            contains: "contains";
+                                            not_contains: "not_contains";
+                                            greater_than: "greater_than";
+                                            less_than: "less_than";
+                                            greater_than_or_equal: "greater_than_or_equal";
+                                            less_than_or_equal: "less_than_or_equal";
+                                            not_in: "not_in";
+                                            exists: "exists";
+                                            not_exists: "not_exists";
+                                        }>;
+                                        value: z.ZodOptional<z.ZodUnknown>;
+                                    }, z.core.$strip>>;
+                                }, z.core.$strip>]>>;
+                            }, z.core.$strip>]>>;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>], "type">>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"conditional">;
+                conditions: z.ZodArray<z.ZodObject<{
+                    steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"step">;
+                        step: z.ZodObject<{
+                            id: z.ZodString;
+                            providerId: z.ZodString;
+                            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                            enabledPhases: z.ZodArray<z.ZodEnum<{
+                                processInput: "processInput";
+                                processInputStep: "processInputStep";
+                                processOutputStream: "processOutputStream";
+                                processOutputResult: "processOutputResult";
+                                processOutputStep: "processOutputStep";
+                            }>>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        type: z.ZodLiteral<"parallel">;
+                        branches: z.ZodArray<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                            type: z.ZodLiteral<"step">;
+                            step: z.ZodObject<{
+                                id: z.ZodString;
+                                providerId: z.ZodString;
+                                config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                                enabledPhases: z.ZodArray<z.ZodEnum<{
+                                    processInput: "processInput";
+                                    processInputStep: "processInputStep";
+                                    processOutputStream: "processOutputStream";
+                                    processOutputResult: "processOutputResult";
+                                    processOutputStep: "processOutputStep";
+                                }>>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>], "type">>>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        type: z.ZodLiteral<"conditional">;
+                        conditions: z.ZodArray<z.ZodObject<{
+                            steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                                type: z.ZodLiteral<"step">;
+                                step: z.ZodObject<{
+                                    id: z.ZodString;
+                                    providerId: z.ZodString;
+                                    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                                    enabledPhases: z.ZodArray<z.ZodEnum<{
+                                        processInput: "processInput";
+                                        processInputStep: "processInputStep";
+                                        processOutputStream: "processOutputStream";
+                                        processOutputResult: "processOutputResult";
+                                        processOutputStep: "processOutputStep";
+                                    }>>;
+                                }, z.core.$strip>;
+                            }, z.core.$strip>], "type">>;
+                            rules: z.ZodOptional<z.ZodObject<{
+                                operator: z.ZodEnum<{
+                                    AND: "AND";
+                                    OR: "OR";
+                                }>;
+                                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                                    field: z.ZodString;
+                                    operator: z.ZodEnum<{
+                                        in: "in";
+                                        equals: "equals";
+                                        not_equals: "not_equals";
+                                        contains: "contains";
+                                        not_contains: "not_contains";
+                                        greater_than: "greater_than";
+                                        less_than: "less_than";
+                                        greater_than_or_equal: "greater_than_or_equal";
+                                        less_than_or_equal: "less_than_or_equal";
+                                        not_in: "not_in";
+                                        exists: "exists";
+                                        not_exists: "not_exists";
+                                    }>;
+                                    value: z.ZodOptional<z.ZodUnknown>;
+                                }, z.core.$strip>, z.ZodObject<{
+                                    operator: z.ZodEnum<{
+                                        AND: "AND";
+                                        OR: "OR";
+                                    }>;
+                                    conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                                        field: z.ZodString;
+                                        operator: z.ZodEnum<{
+                                            in: "in";
+                                            equals: "equals";
+                                            not_equals: "not_equals";
+                                            contains: "contains";
+                                            not_contains: "not_contains";
+                                            greater_than: "greater_than";
+                                            less_than: "less_than";
+                                            greater_than_or_equal: "greater_than_or_equal";
+                                            less_than_or_equal: "less_than_or_equal";
+                                            not_in: "not_in";
+                                            exists: "exists";
+                                            not_exists: "not_exists";
+                                        }>;
+                                        value: z.ZodOptional<z.ZodUnknown>;
+                                    }, z.core.$strip>, z.ZodObject<{
+                                        operator: z.ZodEnum<{
+                                            AND: "AND";
+                                            OR: "OR";
+                                        }>;
+                                        conditions: z.ZodArray<z.ZodObject<{
+                                            field: z.ZodString;
+                                            operator: z.ZodEnum<{
+                                                in: "in";
+                                                equals: "equals";
+                                                not_equals: "not_equals";
+                                                contains: "contains";
+                                                not_contains: "not_contains";
+                                                greater_than: "greater_than";
+                                                less_than: "less_than";
+                                                greater_than_or_equal: "greater_than_or_equal";
+                                                less_than_or_equal: "less_than_or_equal";
+                                                not_in: "not_in";
+                                                exists: "exists";
+                                                not_exists: "not_exists";
+                                            }>;
+                                            value: z.ZodOptional<z.ZodUnknown>;
+                                        }, z.core.$strip>>;
+                                    }, z.core.$strip>]>>;
+                                }, z.core.$strip>]>>;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>], "type">>;
+                    rules: z.ZodOptional<z.ZodObject<{
+                        operator: z.ZodEnum<{
+                            AND: "AND";
+                            OR: "OR";
+                        }>;
+                        conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                            field: z.ZodString;
+                            operator: z.ZodEnum<{
+                                in: "in";
+                                equals: "equals";
+                                not_equals: "not_equals";
+                                contains: "contains";
+                                not_contains: "not_contains";
+                                greater_than: "greater_than";
+                                less_than: "less_than";
+                                greater_than_or_equal: "greater_than_or_equal";
+                                less_than_or_equal: "less_than_or_equal";
+                                not_in: "not_in";
+                                exists: "exists";
+                                not_exists: "not_exists";
+                            }>;
+                            value: z.ZodOptional<z.ZodUnknown>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            operator: z.ZodEnum<{
+                                AND: "AND";
+                                OR: "OR";
+                            }>;
+                            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                                field: z.ZodString;
+                                operator: z.ZodEnum<{
+                                    in: "in";
+                                    equals: "equals";
+                                    not_equals: "not_equals";
+                                    contains: "contains";
+                                    not_contains: "not_contains";
+                                    greater_than: "greater_than";
+                                    less_than: "less_than";
+                                    greater_than_or_equal: "greater_than_or_equal";
+                                    less_than_or_equal: "less_than_or_equal";
+                                    not_in: "not_in";
+                                    exists: "exists";
+                                    not_exists: "not_exists";
+                                }>;
+                                value: z.ZodOptional<z.ZodUnknown>;
+                            }, z.core.$strip>, z.ZodObject<{
+                                operator: z.ZodEnum<{
+                                    AND: "AND";
+                                    OR: "OR";
+                                }>;
+                                conditions: z.ZodArray<z.ZodObject<{
+                                    field: z.ZodString;
+                                    operator: z.ZodEnum<{
+                                        in: "in";
+                                        equals: "equals";
+                                        not_equals: "not_equals";
+                                        contains: "contains";
+                                        not_contains: "not_contains";
+                                        greater_than: "greater_than";
+                                        less_than: "less_than";
+                                        greater_than_or_equal: "greater_than_or_equal";
+                                        less_than_or_equal: "less_than_or_equal";
+                                        not_in: "not_in";
+                                        exists: "exists";
+                                        not_exists: "not_exists";
+                                    }>;
+                                    value: z.ZodOptional<z.ZodUnknown>;
+                                }, z.core.$strip>>;
+                            }, z.core.$strip>]>>;
+                        }, z.core.$strip>]>>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>], "type">>;
+        }, z.core.$strip>;
+        rules: z.ZodOptional<z.ZodObject<{
+            operator: z.ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>]>>>;
+    scorers: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        sampling: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"none">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"ratio">;
+            rate: z.ZodNumber;
+        }, z.core.$strip>]>>;
+        rules: z.ZodOptional<z.ZodObject<{
+            operator: z.ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>, z.ZodArray<z.ZodObject<{
+        value: z.ZodRecord<z.ZodString, z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            sampling: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                type: z.ZodLiteral<"none">;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"ratio">;
+                rate: z.ZodNumber;
+            }, z.core.$strip>]>>;
+            rules: z.ZodOptional<z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        operator: z.ZodEnum<{
+                            AND: "AND";
+                            OR: "OR";
+                        }>;
+                        conditions: z.ZodArray<z.ZodObject<{
+                            field: z.ZodString;
+                            operator: z.ZodEnum<{
+                                in: "in";
+                                equals: "equals";
+                                not_equals: "not_equals";
+                                contains: "contains";
+                                not_contains: "not_contains";
+                                greater_than: "greater_than";
+                                less_than: "less_than";
+                                greater_than_or_equal: "greater_than_or_equal";
+                                less_than_or_equal: "less_than_or_equal";
+                                not_in: "not_in";
+                                exists: "exists";
+                                not_exists: "not_exists";
+                            }>;
+                            value: z.ZodOptional<z.ZodUnknown>;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>]>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        rules: z.ZodOptional<z.ZodObject<{
+            operator: z.ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>]>>>;
+    skills: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        instructions: z.ZodOptional<z.ZodString>;
+        pin: z.ZodOptional<z.ZodString>;
+        strategy: z.ZodOptional<z.ZodEnum<{
+            latest: "latest";
+            live: "live";
+        }>>;
+    }, z.core.$strip>>, z.ZodArray<z.ZodObject<{
+        value: z.ZodRecord<z.ZodString, z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            instructions: z.ZodOptional<z.ZodString>;
+            pin: z.ZodOptional<z.ZodString>;
+            strategy: z.ZodOptional<z.ZodEnum<{
+                latest: "latest";
+                live: "live";
+            }>>;
+        }, z.core.$strip>>;
+        rules: z.ZodOptional<z.ZodObject<{
+            operator: z.ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>]>>>;
+    workspace: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"id">;
+        workspaceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"inline">;
+        config: z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            filesystem: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodString;
+                config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>>;
+            sandbox: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodString;
+                config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>>;
+            mounts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                provider: z.ZodString;
+                config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>>>;
+            search: z.ZodOptional<z.ZodObject<{
+                vectorProvider: z.ZodOptional<z.ZodString>;
+                vectorConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                embedderProvider: z.ZodOptional<z.ZodString>;
+                embedderModel: z.ZodOptional<z.ZodString>;
+                embedderConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                bm25: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+                    k1: z.ZodOptional<z.ZodNumber>;
+                    b: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>]>>;
+                searchIndexName: z.ZodOptional<z.ZodString>;
+                autoIndexPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            tools: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                requireApproval: z.ZodOptional<z.ZodBoolean>;
+                tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    enabled: z.ZodOptional<z.ZodBoolean>;
+                    requireApproval: z.ZodOptional<z.ZodBoolean>;
+                    requireReadBeforeWrite: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+            autoSync: z.ZodOptional<z.ZodBoolean>;
+            operationTimeout: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>], "type">, z.ZodArray<z.ZodObject<{
+        value: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"id">;
+            workspaceId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"inline">;
+            config: z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                filesystem: z.ZodOptional<z.ZodObject<{
+                    provider: z.ZodString;
+                    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                }, z.core.$strip>>;
+                sandbox: z.ZodOptional<z.ZodObject<{
+                    provider: z.ZodString;
+                    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                }, z.core.$strip>>;
+                mounts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    provider: z.ZodString;
+                    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                }, z.core.$strip>>>;
+                search: z.ZodOptional<z.ZodObject<{
+                    vectorProvider: z.ZodOptional<z.ZodString>;
+                    vectorConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    embedderProvider: z.ZodOptional<z.ZodString>;
+                    embedderModel: z.ZodOptional<z.ZodString>;
+                    embedderConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    bm25: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+                        k1: z.ZodOptional<z.ZodNumber>;
+                        b: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strip>]>>;
+                    searchIndexName: z.ZodOptional<z.ZodString>;
+                    autoIndexPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+                skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                tools: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodOptional<z.ZodBoolean>;
+                    requireApproval: z.ZodOptional<z.ZodBoolean>;
+                    tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                        enabled: z.ZodOptional<z.ZodBoolean>;
+                        requireApproval: z.ZodOptional<z.ZodBoolean>;
+                        requireReadBeforeWrite: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>>;
+                autoSync: z.ZodOptional<z.ZodBoolean>;
+                operationTimeout: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>], "type">;
+        rules: z.ZodOptional<z.ZodObject<{
+            operator: z.ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>]>>>;
+    browser: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"inline">;
+        config: z.ZodObject<{
+            provider: z.ZodString;
+            headless: z.ZodOptional<z.ZodBoolean>;
+            viewport: z.ZodOptional<z.ZodObject<{
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strip>>;
+            timeout: z.ZodOptional<z.ZodNumber>;
+            screencast: z.ZodOptional<z.ZodObject<{
+                format: z.ZodOptional<z.ZodEnum<{
+                    jpeg: "jpeg";
+                    png: "png";
+                }>>;
+                quality: z.ZodOptional<z.ZodNumber>;
+                maxWidth: z.ZodOptional<z.ZodNumber>;
+                maxHeight: z.ZodOptional<z.ZodNumber>;
+                everyNthFrame: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+        value: z.ZodObject<{
+            type: z.ZodLiteral<"inline">;
+            config: z.ZodObject<{
+                provider: z.ZodString;
+                headless: z.ZodOptional<z.ZodBoolean>;
+                viewport: z.ZodOptional<z.ZodObject<{
+                    width: z.ZodNumber;
+                    height: z.ZodNumber;
+                }, z.core.$strip>>;
+                timeout: z.ZodOptional<z.ZodNumber>;
+                screencast: z.ZodOptional<z.ZodObject<{
+                    format: z.ZodOptional<z.ZodEnum<{
+                        jpeg: "jpeg";
+                        png: "png";
+                    }>>;
+                    quality: z.ZodOptional<z.ZodNumber>;
+                    maxWidth: z.ZodOptional<z.ZodNumber>;
+                    maxHeight: z.ZodOptional<z.ZodNumber>;
+                    everyNthFrame: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        rules: z.ZodOptional<z.ZodObject<{
+            operator: z.ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>]>, z.ZodBoolean, z.ZodNull]>>>;
+    requestContextSchema: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    memory: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+        vector: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<false>]>>;
+        options: z.ZodOptional<z.ZodObject<{
+            readOnly: z.ZodOptional<z.ZodBoolean>;
+            lastMessages: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<false>]>>;
+            semanticRecall: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+                topK: z.ZodNumber;
+                messageRange: z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+                    before: z.ZodNumber;
+                    after: z.ZodNumber;
+                }, z.core.$strip>]>;
+                scope: z.ZodOptional<z.ZodEnum<{
+                    thread: "thread";
+                    resource: "resource";
+                }>>;
+                threshold: z.ZodOptional<z.ZodNumber>;
+                indexName: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>]>>;
+            generateTitle: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+                model: z.ZodString;
+                instructions: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+        embedder: z.ZodOptional<z.ZodString>;
+        embedderOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        observationalMemory: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            scope: z.ZodOptional<z.ZodEnum<{
+                thread: "thread";
+                resource: "resource";
+            }>>;
+            shareTokenBudget: z.ZodOptional<z.ZodBoolean>;
+            observation: z.ZodOptional<z.ZodObject<{
+                model: z.ZodOptional<z.ZodString>;
+                messageTokens: z.ZodOptional<z.ZodNumber>;
+                modelSettings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>>;
+                maxTokensPerBatch: z.ZodOptional<z.ZodNumber>;
+                bufferTokens: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<false>]>>;
+                bufferActivation: z.ZodOptional<z.ZodNumber>;
+                blockAfter: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            reflection: z.ZodOptional<z.ZodObject<{
+                model: z.ZodOptional<z.ZodString>;
+                observationTokens: z.ZodOptional<z.ZodNumber>;
+                modelSettings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>>;
+                blockAfter: z.ZodOptional<z.ZodNumber>;
+                bufferActivation: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>]>>;
+    }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+        value: z.ZodObject<{
+            vector: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<false>]>>;
+            options: z.ZodOptional<z.ZodObject<{
+                readOnly: z.ZodOptional<z.ZodBoolean>;
+                lastMessages: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<false>]>>;
+                semanticRecall: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+                    topK: z.ZodNumber;
+                    messageRange: z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+                        before: z.ZodNumber;
+                        after: z.ZodNumber;
+                    }, z.core.$strip>]>;
+                    scope: z.ZodOptional<z.ZodEnum<{
+                        thread: "thread";
+                        resource: "resource";
+                    }>>;
+                    threshold: z.ZodOptional<z.ZodNumber>;
+                    indexName: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>]>>;
+                generateTitle: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+                    model: z.ZodString;
+                    instructions: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>>;
+            embedder: z.ZodOptional<z.ZodString>;
+            embedderOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            observationalMemory: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+                model: z.ZodOptional<z.ZodString>;
+                scope: z.ZodOptional<z.ZodEnum<{
+                    thread: "thread";
+                    resource: "resource";
+                }>>;
+                shareTokenBudget: z.ZodOptional<z.ZodBoolean>;
+                observation: z.ZodOptional<z.ZodObject<{
+                    model: z.ZodOptional<z.ZodString>;
+                    messageTokens: z.ZodOptional<z.ZodNumber>;
+                    modelSettings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>>;
+                    maxTokensPerBatch: z.ZodOptional<z.ZodNumber>;
+                    bufferTokens: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<false>]>>;
+                    bufferActivation: z.ZodOptional<z.ZodNumber>;
+                    blockAfter: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+                reflection: z.ZodOptional<z.ZodObject<{
+                    model: z.ZodOptional<z.ZodString>;
+                    observationTokens: z.ZodOptional<z.ZodNumber>;
+                    modelSettings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>>;
+                    blockAfter: z.ZodOptional<z.ZodNumber>;
+                    bufferActivation: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>;
+        rules: z.ZodOptional<z.ZodObject<{
+            operator: z.ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>, z.ZodObject<{
+                operator: z.ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    field: z.ZodString;
+                    operator: z.ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: z.ZodOptional<z.ZodUnknown>;
+                }, z.core.$strip>, z.ZodObject<{
+                    operator: z.ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: z.ZodArray<z.ZodObject<{
+                        field: z.ZodString;
+                        operator: z.ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: z.ZodOptional<z.ZodUnknown>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>]>, z.ZodNull]>>>;
+}, z.core.$strip>;
 /**
  * Stored agent object schema (resolved response: thin record + version config)
  * Represents StorageResolvedAgentType
@@ -31391,6 +35153,12 @@ export declare const deleteStoredAgentResponseSchema: z.ZodObject<{
     success: z.ZodBoolean;
     message: z.ZodString;
 }, z.core.$strip>;
+export declare const exportStoredAgentResponseSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    fileName: z.ZodString;
+    content: z.ZodString;
+    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
 /**
  * POST /stored/agents/preview-instructions - Preview resolved instructions
  */