@xpert-ai/plugin-sdk 3.18.4 → 3.18.6

package/index.cjs.js

@@ -24,6 +24,7 @@ var yaml = require('yaml');
 var Ajv = require('ajv');
 var schemaDraft04 = require('ajv/dist/refs/json-schema-draft-06.json');
 var _axios = require('axios');
+var dataWorkbench = require('./data-workbench.cjs.js');
 var base = require('@langchain/core/callbacks/base');
 var outputs = require('@langchain/core/outputs');
 var messages = require('@langchain/core/messages');
@@ -3651,6 +3652,44 @@ class Speech2TextChatModel extends chat_models.BaseChatModel {
 }
 
 const encodingCache = new Map();
+/** Exact, model-independent text count for hard chunk limits. Treat special-token spellings as literal document text. */ function textEncoding() {
+    const cacheKey = 'encoding:cl100k_base';
+    let encoder = encodingCache.get(cacheKey);
+    if (!encoder) {
+        encoder = jsTiktoken.getEncoding('cl100k_base');
+        encodingCache.set(cacheKey, encoder);
+    }
+    return encoder;
+}
+function countTextTokens(text) {
+    if (!text) return 0;
+    // A hard limit must fail if tokenization fails, never fall back to an estimate.
+    return textEncoding().encode(text, [], []).length;
+}
+/** Token boundaries that also end on complete Unicode characters, in UTF-16 source offsets. */ function textTokenBoundaries(text) {
+    const encoder = textEncoding();
+    const tokens = encoder.encode(text, [], []);
+    const boundaries = [
+        {
+            offset: 0,
+            tokens: 0
+        }
+    ];
+    let offset = 0;
+    let start = 0;
+    for(let end = 1; end <= tokens.length; end++){
+        const decoded = encoder.decode(tokens.slice(start, end));
+        if (!decoded || !text.startsWith(decoded, offset)) continue;
+        offset += decoded.length;
+        boundaries.push({
+            offset,
+            tokens: end
+        });
+        start = end;
+    }
+    if (offset !== text.length) throw new Error('Tokenization could not preserve the source text.');
+    return boundaries;
+}
 /**
  * Fallback token estimation method.
  *
@@ -5928,9 +5967,164 @@ function freezeItems(items) {
 const XPERT_TOOL_PROVIDER = 'XPERT_TOOL_PROVIDER';
 const XPERT_TOOL_PROVIDER_METADATA = 'XPERT_TOOL_PROVIDER_METADATA';
 const XPERT_TOOL_METHOD_METADATA = 'XPERT_TOOL_METHOD_METADATA';
-/** Marks one injectable business service as a reusable Tool provider and one native MCP service. */ const XpertToolProvider = (options)=>common.applyDecorators(common.Injectable(), common.SetMetadata(XPERT_TOOL_PROVIDER, options.provider), common.SetMetadata(XPERT_TOOL_PROVIDER_METADATA, Object.freeze(_extends._extends({}, options))), common.SetMetadata(STRATEGY_META_KEY, XPERT_TOOL_PROVIDER));
+/** Marks one injectable business service as a shared Tool, Resource and Prompt provider. */ const XpertToolProvider = (options)=>common.applyDecorators(common.Injectable(), common.SetMetadata(XPERT_TOOL_PROVIDER, options.provider), common.SetMetadata(XPERT_TOOL_PROVIDER_METADATA, Object.freeze(_extends._extends({}, options))), common.SetMetadata(STRATEGY_META_KEY, XPERT_TOOL_PROVIDER));
 /** Exposes one business method through an Agent Middleware, native MCP, or both. */ const XpertTool = (options)=>common.SetMetadata(XPERT_TOOL_METHOD_METADATA, Object.freeze(_extends._extends({}, options)));
 
+/** Child overrides hide parent declarations, including undecorated overrides and accessors. */ function collectProviderMethods(instance) {
+    const methods = [];
+    const seen = new Set();
+    let prototype = Object.getPrototypeOf(instance);
+    while(prototype && prototype !== Object.prototype){
+        for (const methodName of Object.getOwnPropertyNames(prototype)){
+            var _Object_getOwnPropertyDescriptor;
+            if (methodName === 'constructor' || seen.has(methodName)) continue;
+            seen.add(methodName);
+            const method = (_Object_getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor(prototype, methodName)) == null ? void 0 : _Object_getOwnPropertyDescriptor.value;
+            if (typeof method === 'function') methods.push({
+                methodName,
+                method
+            });
+        }
+        prototype = Object.getPrototypeOf(prototype);
+    }
+    return methods;
+}
+
+function _object_without_properties_loose$2(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+
+const MCP_METHOD_METADATA = 'XPERT_MCP_METHOD_METADATA';
+/** The decorated method receives ResourceReadContext and returns McpResourceReadResult. */ const XpertResource = (options)=>common.SetMetadata(MCP_METHOD_METADATA, {
+        kind: 'resource',
+        options: Object.freeze(_extends._extends({}, options))
+    });
+/** The decorated method receives URI arguments and ResourceReadContext. */ const XpertResourceTemplate = (options)=>common.SetMetadata(MCP_METHOD_METADATA, {
+        kind: 'resource-template',
+        options: Object.freeze(_extends._extends({}, options))
+    });
+/** The decorated method receives prompt arguments and ToolExecutionContext. */ const XpertPrompt = (options)=>common.SetMetadata(MCP_METHOD_METADATA, {
+        kind: 'prompt',
+        options: Object.freeze(_extends._extends({}, options))
+    });
+function describeXpertMcpMethods(instance) {
+    const result = [];
+    for (const { methodName, method } of collectProviderMethods(instance)){
+        var _metadata_options_uri, _metadata_options_uriTemplate, _metadata_options_name;
+        const metadata = Reflect.getMetadata(MCP_METHOD_METADATA, method);
+        if (!metadata) continue;
+        const { options } = metadata;
+        if (!/^[A-Za-z0-9_-]{1,191}$/.test(options.key)) throw new Error(`Invalid MCP capability key '${options.key}'.`);
+        var _options_requiredContext;
+        const contexts = (_options_requiredContext = options.requiredContext) != null ? _options_requiredContext : [];
+        if (new Set(contexts).size !== contexts.length || contexts.some((context)=>!contracts.MCP_REQUIRED_CONTEXTS.includes(context))) {
+            throw new Error(`MCP capability '${options.key}' declares invalid execution contexts.`);
+        }
+        if (metadata.kind === 'resource' && !((_metadata_options_uri = metadata.options.uri) == null ? void 0 : _metadata_options_uri.trim())) {
+            throw new Error(`Resource '${options.key}' requires a URI.`);
+        }
+        if (metadata.kind === 'resource-template' && !((_metadata_options_uriTemplate = metadata.options.uriTemplate) == null ? void 0 : _metadata_options_uriTemplate.trim())) {
+            throw new Error(`Resource template '${options.key}' requires a URI template.`);
+        }
+        if (metadata.kind === 'prompt' && !((_metadata_options_name = metadata.options.name) == null ? void 0 : _metadata_options_name.trim())) {
+            throw new Error(`Prompt '${options.key}' requires a name.`);
+        }
+        if (metadata.kind !== 'resource' && metadata.options.completionMethod) {
+            callable(instance, metadata.options.completionMethod);
+        }
+        result.push(Object.freeze(_extends._extends({}, metadata, {
+            methodName
+        })));
+    }
+    return Object.freeze(result);
+}
+/** One catalog for runtime publication and fingerprinting; legacy declarations remain supported. */ function resolveXpertMcpExtensions(instance, descriptor) {
+    const legacy = 'getMcpExtensions' in instance && typeof instance.getMcpExtensions === 'function' ? instance.getMcpExtensions == null ? void 0 : instance.getMcpExtensions.call(instance) : undefined;
+    var _legacy_resources;
+    const resources = [
+        ...(_legacy_resources = legacy == null ? void 0 : legacy.resources) != null ? _legacy_resources : []
+    ];
+    var _legacy_resourceTemplates;
+    const resourceTemplates = [
+        ...(_legacy_resourceTemplates = legacy == null ? void 0 : legacy.resourceTemplates) != null ? _legacy_resourceTemplates : []
+    ];
+    var _legacy_prompts;
+    const prompts = [
+        ...(_legacy_prompts = legacy == null ? void 0 : legacy.prompts) != null ? _legacy_prompts : []
+    ];
+    var _descriptor_mcpMethods;
+    for (const _ref of (_descriptor_mcpMethods = descriptor == null ? void 0 : descriptor.mcpMethods) != null ? _descriptor_mcpMethods : describeXpertMcpMethods(instance)){
+        let definition = _ref;
+        const method = callable(instance, definition.methodName);
+        switch(definition.kind){
+            case 'resource':
+                resources.push(_extends._extends({}, definition.options, {
+                    read: method
+                }));
+                break;
+            case 'resource-template':
+                {
+                    const _definition_options = definition.options, { completionMethod } = _definition_options, options = _object_without_properties_loose$2(_definition_options, [
+                        "completionMethod"
+                    ]);
+                    resourceTemplates.push(_extends._extends({}, options, {
+                        read: method
+                    }, completionMethod ? {
+                        complete: callable(instance, completionMethod)
+                    } : {}));
+                    break;
+                }
+            case 'prompt':
+                {
+                    const _definition_options = definition.options, { completionMethod } = _definition_options, options = _object_without_properties_loose$2(_definition_options, [
+                        "completionMethod"
+                    ]);
+                    prompts.push(_extends._extends({}, options, {
+                        get: method
+                    }, completionMethod ? {
+                        complete: callable(instance, completionMethod)
+                    } : {}));
+                    break;
+                }
+        }
+    }
+    assertUnique(resources, (item)=>item.key, 'resource key');
+    assertUnique(resources, (item)=>item.uri, 'resource URI');
+    assertUnique(resourceTemplates, (item)=>item.key, 'resource template key');
+    assertUnique(resourceTemplates, (item)=>item.uriTemplate, 'resource template URI');
+    assertUnique(prompts, (item)=>item.key, 'prompt key');
+    assertUnique(prompts, (item)=>item.name, 'prompt name');
+    return {
+        resources,
+        resourceTemplates,
+        prompts
+    };
+}
+function callable(instance, name) {
+    var _collectProviderMethods_find;
+    // Match discovery semantics: accessors and non-method overrides are not executable handlers.
+    const method = (_collectProviderMethods_find = collectProviderMethods(instance).find((item)=>item.methodName === name)) == null ? void 0 : _collectProviderMethods_find.method;
+    if (typeof method !== 'function') throw new Error(`MCP method '${name}' is not callable.`);
+    return method.bind(instance);
+}
+function assertUnique(items, key, label) {
+    const seen = new Set();
+    for (const item of items){
+        const value = key(item);
+        if (seen.has(value)) throw new Error(`MCP ${label} '${value}' is declared more than once.`);
+        seen.add(value);
+    }
+}
+
 const PROVIDER_PATTERN = /^[a-z][a-z0-9_]*$/;
 const MIDDLEWARE_PROVIDER_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/;
 const COMPONENT_KEY_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
@@ -5973,31 +6167,24 @@ function describeXpertToolProvider(instance) {
             options: toolOptions
         });
     });
-    if (!tools.length) {
-        throw new Error(`Provider '${options.provider}' does not declare any @XpertTool methods.`);
+    const mcpMethods = describeXpertMcpMethods(instance);
+    if (!tools.length && !mcpMethods.length) {
+        throw new Error(`Provider '${options.provider}' does not declare any decorated capability methods.`);
     }
     return Object.freeze({
         options: Object.freeze(_extends._extends({}, options)),
-        tools: Object.freeze(tools)
+        tools: Object.freeze(tools),
+        mcpMethods
     });
 }
 function collectDecoratedMethods(instance) {
     const result = [];
-    const seen = new Set();
-    let prototype = Object.getPrototypeOf(instance);
-    while(prototype && prototype !== Object.prototype){
-        for (const methodName of Object.getOwnPropertyNames(prototype)){
-            if (methodName === 'constructor' || seen.has(methodName)) continue;
-            seen.add(methodName);
-            const method = Reflect.get(prototype, methodName);
-            if (typeof method !== 'function') continue;
-            const options = Reflect.getMetadata(XPERT_TOOL_METHOD_METADATA, method);
-            if (options) result.push({
-                methodName,
-                options
-            });
-        }
-        prototype = Object.getPrototypeOf(prototype);
+    for (const { methodName, method } of collectProviderMethods(instance)){
+        const options = Reflect.getMetadata(XPERT_TOOL_METHOD_METADATA, method);
+        if (options) result.push({
+            methodName,
+            options
+        });
     }
     return result;
 }
@@ -6050,15 +6237,12 @@ function validateToolOptions(options, methodName) {
     if (options.resultFormat && options.resultFormat !== 'dto' && options.resultFormat !== 'tool_result') {
         throw new Error(`Tool '${options.name}' declares an invalid resultFormat.`);
     }
-    if (options.resultFormat === 'tool_result' && !options.outputSchema) {
-        throw new Error(`Tool '${options.name}' requires outputSchema for tool_result.`);
-    }
     if (!TOOL_NAME_PATTERN.test(options.name) || options.name.length > 191) {
         throw new Error(`Method '${methodName}' declares invalid Tool name '${options.name}'.`);
     }
     if (!((_options_description = options.description) == null ? void 0 : _options_description.trim())) throw new Error(`Tool '${options.name}' requires a description.`);
     assertStrictObjectSchema(options.inputSchema, options.name, 'input');
-    if (options.mcp && !options.outputSchema) {
+    if (options.mcp && !options.outputSchema && options.resultFormat !== 'tool_result') {
         throw new Error(`MCP Tool '${options.name}' requires an outputSchema.`);
     }
     if (options.mcp && options.outputSchema) {
@@ -6068,6 +6252,14 @@ function validateToolOptions(options, methodName) {
         throw new Error(`MCP Tool '${options.name}' requires at least one execution context.`);
     }
     if (options.mcp) {
+        const transportSchema = options.mcp.inputSchema;
+        if (transportSchema && typeof transportSchema.parseAsync !== 'function') {
+            throw new Error(`MCP Tool '${options.name}' requires a Zod transport input schema.`);
+        }
+        const task = options.mcp.task;
+        if (task && (task.mode !== 'optional' && task.mode !== 'required' || task.maxLifetimeMs !== undefined && (!Number.isSafeInteger(task.maxLifetimeMs) || task.maxLifetimeMs <= 0))) {
+            throw new Error(`MCP Tool '${options.name}' declares invalid task execution policy.`);
+        }
         if (options.mcp.defaultApprovalMode !== undefined && !includesValue(contracts.MCP_CAPABILITY_APPROVAL_MODES, options.mcp.defaultApprovalMode)) {
             throw new Error(`MCP Tool '${options.name}' declares invalid defaultApprovalMode.`);
         }
@@ -6250,7 +6442,7 @@ const contentSchema = v3.z.discriminatedUnion('type', [
     var _result_content;
     const envelope = v3.z.object({
         content: v3.z.array(contentSchema).max(32).optional(),
-        structuredContent: outputSchema,
+        structuredContent: outputSchema != null ? outputSchema : v3.z.unknown().optional(),
         isError: v3.z.boolean().optional()
     }).strict();
     const result = await envelope.parseAsync(value);
@@ -6286,7 +6478,7 @@ const contentSchema = v3.z.discriminatedUnion('type', [
     // MCP clients may expose only content to the model. Keep the validated DTO
     // readable there too, while retaining binary blocks and App structured data.
     const text = JSON.stringify(result.structuredContent);
-    if (!content.some((item)=>item.type === 'text' && item.text === text)) content.push({
+    if (text !== undefined && !content.some((item)=>item.type === 'text' && item.text === text)) content.push({
         type: 'text',
         text
     });
@@ -6407,7 +6599,11 @@ let DecoratedBuiltinToolset = class DecoratedBuiltinToolset extends modelProvide
         this.pluginName = pluginName;
         this.pluginVersion = pluginVersion;
         this.tools = [];
+        const extensions = resolveXpertMcpExtensions(instance, descriptor);
         _class_private_field_loose_base(this, _definitions)[_definitions] = _extends._extends({
+            resources: extensions == null ? void 0 : extensions.resources,
+            resourceTemplates: extensions == null ? void 0 : extensions.resourceTemplates,
+            prompts: extensions == null ? void 0 : extensions.prompts,
             instructions: descriptor.options.instructions,
             tools: descriptor.tools.filter((item)=>!!item.options.mcp).map((item)=>createMcpTool(instance, item))
         }, ((_descriptor_options_apps = descriptor.options.apps) == null ? void 0 : _descriptor_options_apps.length) ? {
@@ -6422,7 +6618,7 @@ function createAgentTool(instance, descriptor, middlewareContext, middlewareOpti
     return tools.tool(async (input, config)=>{
         const parsedInput = await descriptor.options.inputSchema.parseAsync(input);
         const output = await invoke(parsedInput, agentExecutionContext(middlewareContext, middlewareOptions, config));
-        if (descriptor.options.resultFormat === 'tool_result' && descriptor.options.outputSchema) {
+        if (descriptor.options.resultFormat === 'tool_result') {
             const result = await resolveToolResult(output, (value)=>parseDecoratedToolResult(value, descriptor.options.outputSchema));
             var _result_isError;
             return [
@@ -6450,24 +6646,28 @@ function createAgentTool(instance, descriptor, middlewareContext, middlewareOpti
 function createMcpTool(instance, descriptor) {
     const mcp = descriptor.options.mcp;
     const outputSchema = descriptor.options.outputSchema;
-    if (!mcp || !outputSchema) throw new Error(`MCP Tool '${descriptor.options.name}' is incomplete.`);
+    if (!mcp) throw new Error(`MCP Tool '${descriptor.options.name}' is incomplete.`);
     const invoke = getXpertToolMethod(instance, descriptor);
-    var _mcp_visibility;
+    var _mcp_inputSchema, _mcp_visibility;
     return _extends._extends({
         name: descriptor.options.name
     }, descriptor.options.title ? {
         title: descriptor.options.title
     } : {}, {
         description: descriptor.options.description,
-        inputSchema: descriptor.options.inputSchema,
-        outputSchema,
+        inputSchema: (_mcp_inputSchema = mcp.inputSchema) != null ? _mcp_inputSchema : descriptor.options.inputSchema
+    }, outputSchema ? {
+        outputSchema
+    } : {}, {
         exposure: {
             mcp: {
                 eligible: true
             }
         },
         behavior: mcp.behavior
-    }, mcp.defaultApprovalMode ? {
+    }, mcp.task ? {
+        task: mcp.task
+    } : {}, mcp.defaultApprovalMode ? {
         defaultApprovalMode: mcp.defaultApprovalMode
     } : {}, {
         requiredContext: [
@@ -6488,12 +6688,13 @@ function createMcpTool(instance, descriptor) {
     } : {}, {
         execute: async (input, context)=>{
             const parsedInput = await descriptor.options.inputSchema.parseAsync(input);
-            const output = await invoke(parsedInput, mcpExecutionContext(context));
+            const transportInput = mcp.inputSchema ? await mcp.inputSchema.parseAsync(parsedInput) : parsedInput;
+            const output = await invoke(transportInput, mcpExecutionContext(context));
             if (descriptor.options.resultFormat === 'tool_result') {
                 return resolveToolResult(output, (value)=>parseDecoratedToolResult(value, outputSchema));
             }
             return resolveToolResult(output, async (value)=>{
-                const parsedOutput = await outputSchema.parseAsync(value);
+                const parsedOutput = outputSchema ? await outputSchema.parseAsync(value) : value;
                 // Serialize once so text-only clients and MCP Apps receive the same JSON-safe DTO.
                 const text = stringifyDto(parsedOutput, descriptor.options.name);
                 return {
@@ -6510,6 +6711,7 @@ function createMcpTool(instance, descriptor) {
     });
 }
 function agentExecutionContext(context, middlewareOptions, config) {
+    var _context_runtime_capabilities;
     const configurable = config.configurable;
     const requestId = readString(configurable, 'tool_call_id');
     const executionId = readString(configurable, 'executionId');
@@ -6538,11 +6740,13 @@ function agentExecutionContext(context, middlewareOptions, config) {
     } : {}, {
         signal: config.signal,
         host: {
+            files: (_context_runtime_capabilities = context.runtime.capabilities) == null ? void 0 : _context_runtime_capabilities.get(modelProvider.WorkspaceFilesRuntimeCapability),
             models: {
                 createModelClient: context.runtime.createModelClient,
                 getModelProvider: context.runtime.getModelProvider
             }
         },
+        xpertFeatures: context.xpertFeatures,
         middlewareOptions
     });
 }
@@ -6649,6 +6853,2872 @@ exports.XpertToolProviderCoordinator = __decorate([
     ])
 ], exports.XpertToolProviderCoordinator);
 
+function _define_property$h(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread$h(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$h(target, key, source[key]);
+        });
+    }
+    return target;
+}
+var ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
+var defaultOptions = {
+    name: undefined,
+    $refStrategy: "root",
+    basePath: [
+        "#"
+    ],
+    effectStrategy: "input",
+    pipeStrategy: "all",
+    dateStrategy: "format:date-time",
+    mapStrategy: "entries",
+    removeAdditionalStrategy: "passthrough",
+    allowedAdditionalProperties: true,
+    rejectedAdditionalProperties: false,
+    definitionPath: "definitions",
+    target: "jsonSchema7",
+    strictUnions: false,
+    definitions: {},
+    errorMessages: false,
+    markdownDescription: false,
+    patternStrategy: "escape",
+    applyRegexFlags: false,
+    emailStrategy: "format:email",
+    base64Strategy: "contentEncoding:base64",
+    nameStrategy: "ref",
+    openAiAnyTypeName: "OpenAiAnyType"
+};
+var getDefaultOptions = function(options) {
+    return _object_spread$h({}, defaultOptions, options);
+};
+
+function _array_like_to_array$f(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes$f(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$f(arr);
+}
+function _define_property$g(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array$f(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread$f() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread$g(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$g(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$f(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$f(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$f(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array$f(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array$f(arr) {
+    return _array_without_holes$f(arr) || _iterable_to_array$f(arr) || _unsupported_iterable_to_array$f(arr) || _non_iterable_spread$f();
+}
+function _unsupported_iterable_to_array$f(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$f(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$f(o, minLen);
+}
+var getRefs = function(options) {
+    var _options = getDefaultOptions(options);
+    var currentPath = _options.name !== undefined ? _to_consumable_array$f(_options.basePath).concat([
+        _options.definitionPath,
+        _options.name
+    ]) : _options.basePath;
+    return _object_spread_props$f(_object_spread$g({}, _options), {
+        flags: {
+            hasReferencedOpenAiAnyType: false
+        },
+        currentPath: currentPath,
+        propertyPath: undefined,
+        seen: new Map(Object.entries(_options.definitions).map(function(param) {
+            var _param = _sliced_to_array(param, 2), name = _param[0], def = _param[1];
+            return [
+                def._def,
+                {
+                    def: def._def,
+                    path: _to_consumable_array$f(_options.basePath).concat([
+                        _options.definitionPath,
+                        name
+                    ]),
+                    // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
+                    jsonSchema: undefined
+                }
+            ];
+        }))
+    });
+};
+
+function _define_property$f(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread$f(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$f(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$e(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$e(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$e(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function addErrorMessage(res, key, errorMessage, refs) {
+    if (!(refs === null || refs === void 0 ? void 0 : refs.errorMessages)) return;
+    if (errorMessage) {
+        res.errorMessage = _object_spread_props$e(_object_spread$f({}, res.errorMessage), _define_property$f({}, key, errorMessage));
+    }
+}
+function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
+    res[key] = value;
+    addErrorMessage(res, key, errorMessage, refs);
+}
+
+function _array_like_to_array$e(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$e(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$e(arr);
+}
+function _iterable_to_array$e(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread$e() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array$e(arr) {
+    return _array_without_holes$e(arr) || _iterable_to_array$e(arr) || _unsupported_iterable_to_array$e(arr) || _non_iterable_spread$e();
+}
+function _unsupported_iterable_to_array$e(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$e(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$e(o, minLen);
+}
+var getRelativePath = function(pathA, pathB) {
+    var i = 0;
+    for(; i < pathA.length && i < pathB.length; i++){
+        if (pathA[i] !== pathB[i]) break;
+    }
+    return [
+        (pathA.length - i).toString()
+    ].concat(_to_consumable_array$e(pathB.slice(i))).join("/");
+};
+
+function _array_like_to_array$d(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$d(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$d(arr);
+}
+function _iterable_to_array$d(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread$d() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array$d(arr) {
+    return _array_without_holes$d(arr) || _iterable_to_array$d(arr) || _unsupported_iterable_to_array$d(arr) || _non_iterable_spread$d();
+}
+function _unsupported_iterable_to_array$d(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$d(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$d(o, minLen);
+}
+function parseAnyDef(refs) {
+    if (refs.target !== "openAi") {
+        return {};
+    }
+    var anyDefinitionPath = _to_consumable_array$d(refs.basePath).concat([
+        refs.definitionPath,
+        refs.openAiAnyTypeName
+    ]);
+    refs.flags.hasReferencedOpenAiAnyType = true;
+    return {
+        $ref: refs.$refStrategy === "relative" ? getRelativePath(anyDefinitionPath, refs.currentPath) : anyDefinitionPath.join("/")
+    };
+}
+
+function _array_like_to_array$c(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$c(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$c(arr);
+}
+function _define_property$e(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array$c(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread$c() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread$e(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$e(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$d(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$d(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$d(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _to_consumable_array$c(arr) {
+    return _array_without_holes$c(arr) || _iterable_to_array$c(arr) || _unsupported_iterable_to_array$c(arr) || _non_iterable_spread$c();
+}
+function _unsupported_iterable_to_array$c(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$c(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$c(o, minLen);
+}
+function parseArrayDef(def, refs) {
+    var _def_type, _def_type__def, _def_type1;
+    var res = {
+        type: "array"
+    };
+    if (((_def_type = def.type) === null || _def_type === void 0 ? void 0 : _def_type._def) && ((_def_type1 = def.type) === null || _def_type1 === void 0 ? void 0 : (_def_type__def = _def_type1._def) === null || _def_type__def === void 0 ? void 0 : _def_type__def.typeName) !== v3.ZodFirstPartyTypeKind.ZodAny) {
+        res.items = parseDef(def.type._def, _object_spread_props$d(_object_spread$e({}, refs), {
+            currentPath: _to_consumable_array$c(refs.currentPath).concat([
+                "items"
+            ])
+        }));
+    }
+    if (def.minLength) {
+        setResponseValueAndErrors(res, "minItems", def.minLength.value, def.minLength.message, refs);
+    }
+    if (def.maxLength) {
+        setResponseValueAndErrors(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
+    }
+    if (def.exactLength) {
+        setResponseValueAndErrors(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
+        setResponseValueAndErrors(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
+    }
+    return res;
+}
+
+function parseBigintDef(def, refs) {
+    var res = {
+        type: "integer",
+        format: "int64"
+    };
+    if (!def.checks) return res;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = def.checks[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var check = _step.value;
+            switch(check.kind){
+                case "min":
+                    if (refs.target === "jsonSchema7") {
+                        if (check.inclusive) {
+                            setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+                        } else {
+                            setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
+                        }
+                    } else {
+                        if (!check.inclusive) {
+                            res.exclusiveMinimum = true;
+                        }
+                        setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+                    }
+                    break;
+                case "max":
+                    if (refs.target === "jsonSchema7") {
+                        if (check.inclusive) {
+                            setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+                        } else {
+                            setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
+                        }
+                    } else {
+                        if (!check.inclusive) {
+                            res.exclusiveMaximum = true;
+                        }
+                        setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+                    }
+                    break;
+                case "multipleOf":
+                    setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
+                    break;
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return res;
+}
+
+function parseBooleanDef() {
+    return {
+        type: "boolean"
+    };
+}
+
+function parseBrandedDef(_def, refs) {
+    return parseDef(_def.type._def, refs);
+}
+
+var parseCatchDef = function(def, refs) {
+    return parseDef(def.innerType._def, refs);
+};
+
+function parseDateDef(def, refs, overrideDateStrategy) {
+    var strategy = overrideDateStrategy !== null && overrideDateStrategy !== void 0 ? overrideDateStrategy : refs.dateStrategy;
+    if (Array.isArray(strategy)) {
+        return {
+            anyOf: strategy.map(function(item, i) {
+                return parseDateDef(def, refs, item);
+            })
+        };
+    }
+    switch(strategy){
+        case "string":
+        case "format:date-time":
+            return {
+                type: "string",
+                format: "date-time"
+            };
+        case "format:date":
+            return {
+                type: "string",
+                format: "date"
+            };
+        case "integer":
+            return integerDateParser(def, refs);
+    }
+}
+var integerDateParser = function(def, refs) {
+    var res = {
+        type: "integer",
+        format: "unix-time"
+    };
+    if (refs.target === "openApi3") {
+        return res;
+    }
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = def.checks[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var check = _step.value;
+            switch(check.kind){
+                case "min":
+                    setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+                    break;
+                case "max":
+                    setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+                    break;
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return res;
+};
+
+function _define_property$d(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread$d(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$d(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$c(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$c(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$c(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function parseDefaultDef(_def, refs) {
+    return _object_spread_props$c(_object_spread$d({}, parseDef(_def.innerType._def, refs)), {
+        default: _def.defaultValue()
+    });
+}
+
+function parseEffectsDef(_def, refs) {
+    return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : parseAnyDef(refs);
+}
+
+function parseEnumDef(def) {
+    return {
+        type: "string",
+        enum: Array.from(def.values)
+    };
+}
+
+function _array_like_to_array$b(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$b(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$b(arr);
+}
+function _define_property$c(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array$b(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread$b() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread$c(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$c(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$b(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$b(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$b(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _object_without_properties$1(source, excluded) {
+    if (source == null) return {};
+    var target = _object_without_properties_loose$1(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose$1(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function _to_consumable_array$b(arr) {
+    return _array_without_holes$b(arr) || _iterable_to_array$b(arr) || _unsupported_iterable_to_array$b(arr) || _non_iterable_spread$b();
+}
+function _unsupported_iterable_to_array$b(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$b(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$b(o, minLen);
+}
+var isJsonSchema7AllOfType = function(type) {
+    if ("type" in type && type.type === "string") return false;
+    return "allOf" in type;
+};
+function parseIntersectionDef(def, refs) {
+    var allOf = [
+        parseDef(def.left._def, _object_spread_props$b(_object_spread$c({}, refs), {
+            currentPath: _to_consumable_array$b(refs.currentPath).concat([
+                "allOf",
+                "0"
+            ])
+        })),
+        parseDef(def.right._def, _object_spread_props$b(_object_spread$c({}, refs), {
+            currentPath: _to_consumable_array$b(refs.currentPath).concat([
+                "allOf",
+                "1"
+            ])
+        }))
+    ].filter(function(x) {
+        return !!x;
+    });
+    var unevaluatedProperties = refs.target === "jsonSchema2019-09" ? {
+        unevaluatedProperties: false
+    } : undefined;
+    var mergedAllOf = [];
+    // If either of the schemas is an allOf, merge them into a single allOf
+    allOf.forEach(function(schema) {
+        if (isJsonSchema7AllOfType(schema)) {
+            var _mergedAllOf;
+            (_mergedAllOf = mergedAllOf).push.apply(_mergedAllOf, _to_consumable_array$b(schema.allOf));
+            if (schema.unevaluatedProperties === undefined) {
+                // If one of the schemas has no unevaluatedProperties set,
+                // the merged schema should also have no unevaluatedProperties set
+                unevaluatedProperties = undefined;
+            }
+        } else {
+            var nestedSchema = schema;
+            if ("additionalProperties" in schema && schema.additionalProperties === false) {
+                schema.additionalProperties; var rest = _object_without_properties$1(schema, [
+                    "additionalProperties"
+                ]);
+                nestedSchema = rest;
+            } else {
+                // As soon as one of the schemas has additionalProperties set not to false, we allow unevaluatedProperties
+                unevaluatedProperties = undefined;
+            }
+            mergedAllOf.push(nestedSchema);
+        }
+    });
+    return mergedAllOf.length ? _object_spread$c({
+        allOf: mergedAllOf
+    }, unevaluatedProperties) : undefined;
+}
+
+function _type_of$2(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function parseLiteralDef(def, refs) {
+    var parsedType = _type_of$2(def.value);
+    if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") {
+        return {
+            type: Array.isArray(def.value) ? "array" : "object"
+        };
+    }
+    if (refs.target === "openApi3") {
+        return {
+            type: parsedType === "bigint" ? "integer" : parsedType,
+            enum: [
+                def.value
+            ]
+        };
+    }
+    return {
+        type: parsedType === "bigint" ? "integer" : parsedType,
+        const: def.value
+    };
+}
+
+function _define_property$b(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread$b(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$b(target, key, source[key]);
+        });
+    }
+    return target;
+}
+var emojiRegex = undefined;
+/**
+ * Generated from the regular expressions found here as of 2024-05-22:
+ * https://github.com/colinhacks/zod/blob/master/src/types.ts.
+ *
+ * Expressions with /i flag have been changed accordingly.
+ */ var zodPatterns = {
+    /**
+     * `c` was changed to `[cC]` to replicate /i flag
+     */ cuid: /^[cC][^\s-]{8,}$/,
+    cuid2: /^[0-9a-z]+$/,
+    ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
+    /**
+     * `a-z` was added to replicate /i flag
+     */ email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+    /**
+     * Constructed a valid Unicode RegExp
+     *
+     * Lazily instantiate since this type of regex isn't supported
+     * in all envs (e.g. React Native).
+     *
+     * See:
+     * https://github.com/colinhacks/zod/issues/2433
+     * Fix in Zod:
+     * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
+     */ emoji: function() {
+        if (emojiRegex === undefined) {
+            emojiRegex = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
+        }
+        return emojiRegex;
+    },
+    /**
+     * Unused
+     */ uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
+    /**
+     * Unused
+     */ ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
+    ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
+    /**
+     * Unused
+     */ ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
+    ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
+    base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
+    base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
+    nanoid: /^[a-zA-Z0-9_-]{21}$/,
+    jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
+};
+function parseStringDef(def, refs) {
+    var res = {
+        type: "string"
+    };
+    if (def.checks) {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = def.checks[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var check = _step.value;
+                switch(check.kind){
+                    case "min":
+                        setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
+                        break;
+                    case "max":
+                        setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
+                        break;
+                    case "email":
+                        switch(refs.emailStrategy){
+                            case "format:email":
+                                addFormat(res, "email", check.message, refs);
+                                break;
+                            case "format:idn-email":
+                                addFormat(res, "idn-email", check.message, refs);
+                                break;
+                            case "pattern:zod":
+                                addPattern(res, zodPatterns.email, check.message, refs);
+                                break;
+                        }
+                        break;
+                    case "url":
+                        addFormat(res, "uri", check.message, refs);
+                        break;
+                    case "uuid":
+                        addFormat(res, "uuid", check.message, refs);
+                        break;
+                    case "regex":
+                        addPattern(res, check.regex, check.message, refs);
+                        break;
+                    case "cuid":
+                        addPattern(res, zodPatterns.cuid, check.message, refs);
+                        break;
+                    case "cuid2":
+                        addPattern(res, zodPatterns.cuid2, check.message, refs);
+                        break;
+                    case "startsWith":
+                        addPattern(res, RegExp("^".concat(escapeLiteralCheckValue(check.value, refs))), check.message, refs);
+                        break;
+                    case "endsWith":
+                        addPattern(res, RegExp("".concat(escapeLiteralCheckValue(check.value, refs), "$")), check.message, refs);
+                        break;
+                    case "datetime":
+                        addFormat(res, "date-time", check.message, refs);
+                        break;
+                    case "date":
+                        addFormat(res, "date", check.message, refs);
+                        break;
+                    case "time":
+                        addFormat(res, "time", check.message, refs);
+                        break;
+                    case "duration":
+                        addFormat(res, "duration", check.message, refs);
+                        break;
+                    case "length":
+                        setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
+                        setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
+                        break;
+                    case "includes":
+                        {
+                            addPattern(res, RegExp(escapeLiteralCheckValue(check.value, refs)), check.message, refs);
+                            break;
+                        }
+                    case "ip":
+                        {
+                            if (check.version !== "v6") {
+                                addFormat(res, "ipv4", check.message, refs);
+                            }
+                            if (check.version !== "v4") {
+                                addFormat(res, "ipv6", check.message, refs);
+                            }
+                            break;
+                        }
+                    case "base64url":
+                        addPattern(res, zodPatterns.base64url, check.message, refs);
+                        break;
+                    case "jwt":
+                        addPattern(res, zodPatterns.jwt, check.message, refs);
+                        break;
+                    case "cidr":
+                        {
+                            if (check.version !== "v6") {
+                                addPattern(res, zodPatterns.ipv4Cidr, check.message, refs);
+                            }
+                            if (check.version !== "v4") {
+                                addPattern(res, zodPatterns.ipv6Cidr, check.message, refs);
+                            }
+                            break;
+                        }
+                    case "emoji":
+                        addPattern(res, zodPatterns.emoji(), check.message, refs);
+                        break;
+                    case "ulid":
+                        {
+                            addPattern(res, zodPatterns.ulid, check.message, refs);
+                            break;
+                        }
+                    case "base64":
+                        {
+                            switch(refs.base64Strategy){
+                                case "format:binary":
+                                    {
+                                        addFormat(res, "binary", check.message, refs);
+                                        break;
+                                    }
+                                case "contentEncoding:base64":
+                                    {
+                                        setResponseValueAndErrors(res, "contentEncoding", "base64", check.message, refs);
+                                        break;
+                                    }
+                                case "pattern:zod":
+                                    {
+                                        addPattern(res, zodPatterns.base64, check.message, refs);
+                                        break;
+                                    }
+                            }
+                            break;
+                        }
+                    case "nanoid":
+                        {
+                            addPattern(res, zodPatterns.nanoid, check.message, refs);
+                        }
+                    case "toLowerCase":
+                    case "toUpperCase":
+                    case "trim":
+                        break;
+                    default:
+                        (function(_) {})(check);
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return res;
+}
+function escapeLiteralCheckValue(literal, refs) {
+    return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal;
+}
+var ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
+function escapeNonAlphaNumeric(source) {
+    var result = "";
+    for(var i = 0; i < source.length; i++){
+        if (!ALPHA_NUMERIC.has(source[i])) {
+            result += "\\";
+        }
+        result += source[i];
+    }
+    return result;
+}
+// Adds a "format" keyword to the schema. If a format exists, both formats will be joined in an allOf-node, along with subsequent ones.
+function addFormat(schema, value, message, refs) {
+    var _schema_anyOf;
+    if (schema.format || ((_schema_anyOf = schema.anyOf) === null || _schema_anyOf === void 0 ? void 0 : _schema_anyOf.some(function(x) {
+        return x.format;
+    }))) {
+        if (!schema.anyOf) {
+            schema.anyOf = [];
+        }
+        if (schema.format) {
+            schema.anyOf.push(_object_spread$b({
+                format: schema.format
+            }, schema.errorMessage && refs.errorMessages && {
+                errorMessage: {
+                    format: schema.errorMessage.format
+                }
+            }));
+            delete schema.format;
+            if (schema.errorMessage) {
+                delete schema.errorMessage.format;
+                if (Object.keys(schema.errorMessage).length === 0) {
+                    delete schema.errorMessage;
+                }
+            }
+        }
+        schema.anyOf.push(_object_spread$b({
+            format: value
+        }, message && refs.errorMessages && {
+            errorMessage: {
+                format: message
+            }
+        }));
+    } else {
+        setResponseValueAndErrors(schema, "format", value, message, refs);
+    }
+}
+// Adds a "pattern" keyword to the schema. If a pattern exists, both patterns will be joined in an allOf-node, along with subsequent ones.
+function addPattern(schema, regex, message, refs) {
+    var _schema_allOf;
+    if (schema.pattern || ((_schema_allOf = schema.allOf) === null || _schema_allOf === void 0 ? void 0 : _schema_allOf.some(function(x) {
+        return x.pattern;
+    }))) {
+        if (!schema.allOf) {
+            schema.allOf = [];
+        }
+        if (schema.pattern) {
+            schema.allOf.push(_object_spread$b({
+                pattern: schema.pattern
+            }, schema.errorMessage && refs.errorMessages && {
+                errorMessage: {
+                    pattern: schema.errorMessage.pattern
+                }
+            }));
+            delete schema.pattern;
+            if (schema.errorMessage) {
+                delete schema.errorMessage.pattern;
+                if (Object.keys(schema.errorMessage).length === 0) {
+                    delete schema.errorMessage;
+                }
+            }
+        }
+        schema.allOf.push(_object_spread$b({
+            pattern: stringifyRegExpWithFlags(regex, refs)
+        }, message && refs.errorMessages && {
+            errorMessage: {
+                pattern: message
+            }
+        }));
+    } else {
+        setResponseValueAndErrors(schema, "pattern", stringifyRegExpWithFlags(regex, refs), message, refs);
+    }
+}
+// Mutate z.string.regex() in a best attempt to accommodate for regex flags when applyRegexFlags is true
+function stringifyRegExpWithFlags(regex, refs) {
+    if (!refs.applyRegexFlags || !regex.flags) {
+        return regex.source;
+    }
+    // Currently handled flags
+    var flags = {
+        i: regex.flags.includes("i"),
+        m: regex.flags.includes("m"),
+        s: regex.flags.includes("s")
+    };
+    // The general principle here is to step through each character, one at a time, applying mutations as flags require. We keep track when the current character is escaped, and when it's inside a group /like [this]/ or (also) a range like /[a-z]/. The following is fairly brittle imperative code; edit at your peril!
+    var source = flags.i ? regex.source.toLowerCase() : regex.source;
+    var pattern = "";
+    var isEscaped = false;
+    var inCharGroup = false;
+    var inCharRange = false;
+    for(var i = 0; i < source.length; i++){
+        if (isEscaped) {
+            pattern += source[i];
+            isEscaped = false;
+            continue;
+        }
+        if (flags.i) {
+            if (inCharGroup) {
+                if (source[i].match(/[a-z]/)) {
+                    var _source_;
+                    if (inCharRange) {
+                        pattern += source[i];
+                        pattern += "".concat(source[i - 2], "-").concat(source[i]).toUpperCase();
+                        inCharRange = false;
+                    } else if (source[i + 1] === "-" && ((_source_ = source[i + 2]) === null || _source_ === void 0 ? void 0 : _source_.match(/[a-z]/))) {
+                        pattern += source[i];
+                        inCharRange = true;
+                    } else {
+                        pattern += "".concat(source[i]).concat(source[i].toUpperCase());
+                    }
+                    continue;
+                }
+            } else if (source[i].match(/[a-z]/)) {
+                pattern += "[".concat(source[i]).concat(source[i].toUpperCase(), "]");
+                continue;
+            }
+        }
+        if (flags.m) {
+            if (source[i] === "^") {
+                pattern += "(^|(?<=[\r\n]))";
+                continue;
+            } else if (source[i] === "$") {
+                pattern += "($|(?=[\r\n]))";
+                continue;
+            }
+        }
+        if (flags.s && source[i] === ".") {
+            pattern += inCharGroup ? "".concat(source[i], "\r\n") : "[".concat(source[i], "\r\n]");
+            continue;
+        }
+        pattern += source[i];
+        if (source[i] === "\\") {
+            isEscaped = true;
+        } else if (inCharGroup && source[i] === "]") {
+            inCharGroup = false;
+        } else if (!inCharGroup && source[i] === "[") {
+            inCharGroup = true;
+        }
+    }
+    try {
+        new RegExp(pattern);
+    } catch (e) {
+        console.warn("Could not convert regex pattern at ".concat(refs.currentPath.join("/"), " to a flag-independent form! Falling back to the flag-ignorant source"));
+        return regex.source;
+    }
+    return pattern;
+}
+
+function _array_like_to_array$a(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$a(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$a(arr);
+}
+function _define_property$a(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array$a(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread$a() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread$a(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$a(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$a(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$a(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$a(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function _to_consumable_array$a(arr) {
+    return _array_without_holes$a(arr) || _iterable_to_array$a(arr) || _unsupported_iterable_to_array$a(arr) || _non_iterable_spread$a();
+}
+function _unsupported_iterable_to_array$a(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$a(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$a(o, minLen);
+}
+function parseRecordDef(def, refs) {
+    var _def_keyType, _def_keyType1, _def_keyType__def_checks, _def_keyType2, _def_keyType3, _def_keyType__def_type__def_checks;
+    if (refs.target === "openAi") {
+        console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
+    }
+    if (refs.target === "openApi3" && ((_def_keyType = def.keyType) === null || _def_keyType === void 0 ? void 0 : _def_keyType._def.typeName) === v3.ZodFirstPartyTypeKind.ZodEnum) {
+        return {
+            type: "object",
+            required: def.keyType._def.values,
+            properties: def.keyType._def.values.reduce(function(acc, key) {
+                var _parseDef;
+                return _object_spread_props$a(_object_spread$a({}, acc), _define_property$a({}, key, (_parseDef = parseDef(def.valueType._def, _object_spread_props$a(_object_spread$a({}, refs), {
+                    currentPath: _to_consumable_array$a(refs.currentPath).concat([
+                        "properties",
+                        key
+                    ])
+                }))) !== null && _parseDef !== void 0 ? _parseDef : parseAnyDef(refs)));
+            }, {}),
+            additionalProperties: refs.rejectedAdditionalProperties
+        };
+    }
+    var _parseDef;
+    var schema = {
+        type: "object",
+        additionalProperties: (_parseDef = parseDef(def.valueType._def, _object_spread_props$a(_object_spread$a({}, refs), {
+            currentPath: _to_consumable_array$a(refs.currentPath).concat([
+                "additionalProperties"
+            ])
+        }))) !== null && _parseDef !== void 0 ? _parseDef : refs.allowedAdditionalProperties
+    };
+    if (refs.target === "openApi3") {
+        return schema;
+    }
+    if (((_def_keyType1 = def.keyType) === null || _def_keyType1 === void 0 ? void 0 : _def_keyType1._def.typeName) === v3.ZodFirstPartyTypeKind.ZodString && ((_def_keyType__def_checks = def.keyType._def.checks) === null || _def_keyType__def_checks === void 0 ? void 0 : _def_keyType__def_checks.length)) {
+        var _parseStringDef = parseStringDef(def.keyType._def, refs); _parseStringDef.type; var keyType = _object_without_properties(_parseStringDef, [
+            "type"
+        ]);
+        return _object_spread_props$a(_object_spread$a({}, schema), {
+            propertyNames: keyType
+        });
+    } else if (((_def_keyType2 = def.keyType) === null || _def_keyType2 === void 0 ? void 0 : _def_keyType2._def.typeName) === v3.ZodFirstPartyTypeKind.ZodEnum) {
+        return _object_spread_props$a(_object_spread$a({}, schema), {
+            propertyNames: {
+                enum: def.keyType._def.values
+            }
+        });
+    } else if (((_def_keyType3 = def.keyType) === null || _def_keyType3 === void 0 ? void 0 : _def_keyType3._def.typeName) === v3.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === v3.ZodFirstPartyTypeKind.ZodString && ((_def_keyType__def_type__def_checks = def.keyType._def.type._def.checks) === null || _def_keyType__def_type__def_checks === void 0 ? void 0 : _def_keyType__def_type__def_checks.length)) {
+        var _parseBrandedDef = parseBrandedDef(def.keyType._def, refs); _parseBrandedDef.type; var keyType1 = _object_without_properties(_parseBrandedDef, [
+            "type"
+        ]);
+        return _object_spread_props$a(_object_spread$a({}, schema), {
+            propertyNames: keyType1
+        });
+    }
+    return schema;
+}
+
+function _array_like_to_array$9(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$9(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$9(arr);
+}
+function _define_property$9(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array$9(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread$9() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread$9(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$9(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$9(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$9(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$9(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _to_consumable_array$9(arr) {
+    return _array_without_holes$9(arr) || _iterable_to_array$9(arr) || _unsupported_iterable_to_array$9(arr) || _non_iterable_spread$9();
+}
+function _unsupported_iterable_to_array$9(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$9(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$9(o, minLen);
+}
+function parseMapDef(def, refs) {
+    if (refs.mapStrategy === "record") {
+        return parseRecordDef(def, refs);
+    }
+    var keys = parseDef(def.keyType._def, _object_spread_props$9(_object_spread$9({}, refs), {
+        currentPath: _to_consumable_array$9(refs.currentPath).concat([
+            "items",
+            "items",
+            "0"
+        ])
+    })) || parseAnyDef(refs);
+    var values = parseDef(def.valueType._def, _object_spread_props$9(_object_spread$9({}, refs), {
+        currentPath: _to_consumable_array$9(refs.currentPath).concat([
+            "items",
+            "items",
+            "1"
+        ])
+    })) || parseAnyDef(refs);
+    return {
+        type: "array",
+        maxItems: 125,
+        items: {
+            type: "array",
+            items: [
+                keys,
+                values
+            ],
+            minItems: 2,
+            maxItems: 2
+        }
+    };
+}
+
+function _type_of$1(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function parseNativeEnumDef(def) {
+    var object = def.values;
+    var actualKeys = Object.keys(def.values).filter(function(key) {
+        return typeof object[object[key]] !== "number";
+    });
+    var actualValues = actualKeys.map(function(key) {
+        return object[key];
+    });
+    var parsedTypes = Array.from(new Set(actualValues.map(function(values) {
+        return typeof values === "undefined" ? "undefined" : _type_of$1(values);
+    })));
+    return {
+        type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : [
+            "string",
+            "number"
+        ],
+        enum: actualValues
+    };
+}
+
+function _array_like_to_array$8(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$8(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$8(arr);
+}
+function _define_property$8(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array$8(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread$8() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread$8(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$8(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$8(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$8(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$8(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _to_consumable_array$8(arr) {
+    return _array_without_holes$8(arr) || _iterable_to_array$8(arr) || _unsupported_iterable_to_array$8(arr) || _non_iterable_spread$8();
+}
+function _unsupported_iterable_to_array$8(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$8(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$8(o, minLen);
+}
+function parseNeverDef(refs) {
+    return refs.target === "openAi" ? undefined : {
+        not: parseAnyDef(_object_spread_props$8(_object_spread$8({}, refs), {
+            currentPath: _to_consumable_array$8(refs.currentPath).concat([
+                "not"
+            ])
+        }))
+    };
+}
+
+function parseNullDef(refs) {
+    return refs.target === "openApi3" ? {
+        enum: [
+            "null"
+        ],
+        nullable: true
+    } : {
+        type: "null"
+    };
+}
+
+function _array_like_to_array$7(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$7(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$7(arr);
+}
+function _define_property$7(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array$7(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread$7() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread$7(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$7(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$7(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$7(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$7(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _to_consumable_array$7(arr) {
+    return _array_without_holes$7(arr) || _iterable_to_array$7(arr) || _unsupported_iterable_to_array$7(arr) || _non_iterable_spread$7();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array$7(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$7(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$7(o, minLen);
+}
+var primitiveMappings = {
+    ZodString: "string",
+    ZodNumber: "number",
+    ZodBigInt: "integer",
+    ZodBoolean: "boolean",
+    ZodNull: "null"
+};
+function parseUnionDef(def, refs) {
+    if (refs.target === "openApi3") return asAnyOf(def, refs);
+    var options = _instanceof(def.options, Map) ? Array.from(def.options.values()) : def.options;
+    // This blocks tries to look ahead a bit to produce nicer looking schemas with type array instead of anyOf.
+    if (options.every(function(x) {
+        return x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length);
+    })) {
+        // all types in union are primitive and lack checks, so might as well squash into {type: [...]}
+        var types = options.reduce(function(types, x) {
+            var type = primitiveMappings[x._def.typeName]; //Can be safely casted due to row 43
+            return type && !types.includes(type) ? _to_consumable_array$7(types).concat([
+                type
+            ]) : types;
+        }, []);
+        return {
+            type: types.length > 1 ? types : types[0]
+        };
+    } else if (options.every(function(x) {
+        return x._def.typeName === "ZodLiteral" && !x.description;
+    })) {
+        // all options literals
+        var types1 = options.reduce(function(acc, x) {
+            var type = _type_of(x._def.value);
+            switch(type){
+                case "string":
+                case "number":
+                case "boolean":
+                    return _to_consumable_array$7(acc).concat([
+                        type
+                    ]);
+                case "bigint":
+                    return _to_consumable_array$7(acc).concat([
+                        "integer"
+                    ]);
+                case "object":
+                    if (x._def.value === null) return _to_consumable_array$7(acc).concat([
+                        "null"
+                    ]);
+                case "symbol":
+                case "undefined":
+                case "function":
+                default:
+                    return acc;
+            }
+        }, []);
+        if (types1.length === options.length) {
+            // all the literals are primitive, as far as null can be considered primitive
+            var uniqueTypes = types1.filter(function(x, i, a) {
+                return a.indexOf(x) === i;
+            });
+            return {
+                type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
+                enum: options.reduce(function(acc, x) {
+                    return acc.includes(x._def.value) ? acc : _to_consumable_array$7(acc).concat([
+                        x._def.value
+                    ]);
+                }, [])
+            };
+        }
+    } else if (options.every(function(x) {
+        return x._def.typeName === "ZodEnum";
+    })) {
+        return {
+            type: "string",
+            enum: options.reduce(function(acc, x) {
+                return _to_consumable_array$7(acc).concat(_to_consumable_array$7(x._def.values.filter(function(x) {
+                    return !acc.includes(x);
+                })));
+            }, [])
+        };
+    }
+    return asAnyOf(def, refs);
+}
+var asAnyOf = function(def, refs) {
+    var anyOf = (_instanceof(def.options, Map) ? Array.from(def.options.values()) : def.options).map(function(x, i) {
+        return parseDef(x._def, _object_spread_props$7(_object_spread$7({}, refs), {
+            currentPath: _to_consumable_array$7(refs.currentPath).concat([
+                "anyOf",
+                "".concat(i)
+            ])
+        }));
+    }).filter(function(x) {
+        return !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0);
+    });
+    return anyOf.length ? {
+        anyOf: anyOf
+    } : undefined;
+};
+
+function _array_like_to_array$6(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$6(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$6(arr);
+}
+function _define_property$6(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array$6(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread$6() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread$6(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$6(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$6(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$6(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$6(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _to_consumable_array$6(arr) {
+    return _array_without_holes$6(arr) || _iterable_to_array$6(arr) || _unsupported_iterable_to_array$6(arr) || _non_iterable_spread$6();
+}
+function _unsupported_iterable_to_array$6(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$6(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$6(o, minLen);
+}
+function parseNullableDef(def, refs) {
+    if ([
+        "ZodString",
+        "ZodNumber",
+        "ZodBigInt",
+        "ZodBoolean",
+        "ZodNull"
+    ].includes(def.innerType._def.typeName) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
+        if (refs.target === "openApi3") {
+            return {
+                type: primitiveMappings[def.innerType._def.typeName],
+                nullable: true
+            };
+        }
+        return {
+            type: [
+                primitiveMappings[def.innerType._def.typeName],
+                "null"
+            ]
+        };
+    }
+    if (refs.target === "openApi3") {
+        var base = parseDef(def.innerType._def, _object_spread_props$6(_object_spread$6({}, refs), {
+            currentPath: _to_consumable_array$6(refs.currentPath)
+        }));
+        if (base && "$ref" in base) return {
+            allOf: [
+                base
+            ],
+            nullable: true
+        };
+        return base && _object_spread_props$6(_object_spread$6({}, base), {
+            nullable: true
+        });
+    }
+    var base1 = parseDef(def.innerType._def, _object_spread_props$6(_object_spread$6({}, refs), {
+        currentPath: _to_consumable_array$6(refs.currentPath).concat([
+            "anyOf",
+            "0"
+        ])
+    }));
+    return base1 && {
+        anyOf: [
+            base1,
+            {
+                type: "null"
+            }
+        ]
+    };
+}
+
+function parseNumberDef(def, refs) {
+    var res = {
+        type: "number"
+    };
+    if (!def.checks) return res;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = def.checks[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var check = _step.value;
+            switch(check.kind){
+                case "int":
+                    res.type = "integer";
+                    addErrorMessage(res, "type", check.message, refs);
+                    break;
+                case "min":
+                    if (refs.target === "jsonSchema7") {
+                        if (check.inclusive) {
+                            setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+                        } else {
+                            setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
+                        }
+                    } else {
+                        if (!check.inclusive) {
+                            res.exclusiveMinimum = true;
+                        }
+                        setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+                    }
+                    break;
+                case "max":
+                    if (refs.target === "jsonSchema7") {
+                        if (check.inclusive) {
+                            setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+                        } else {
+                            setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
+                        }
+                    } else {
+                        if (!check.inclusive) {
+                            res.exclusiveMaximum = true;
+                        }
+                        setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+                    }
+                    break;
+                case "multipleOf":
+                    setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
+                    break;
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return res;
+}
+
+function _array_like_to_array$5(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$5(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$5(arr);
+}
+function _define_property$5(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array$5(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread$5() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread$5(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$5(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$5(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$5(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$5(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _to_consumable_array$5(arr) {
+    return _array_without_holes$5(arr) || _iterable_to_array$5(arr) || _unsupported_iterable_to_array$5(arr) || _non_iterable_spread$5();
+}
+function _unsupported_iterable_to_array$5(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$5(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$5(o, minLen);
+}
+function parseObjectDef(def, refs) {
+    var forceOptionalIntoNullable = refs.target === "openAi";
+    var result = {
+        type: "object",
+        properties: {}
+    };
+    var required = [];
+    var shape = def.shape();
+    for(var propName in shape){
+        var propDef = shape[propName];
+        if (propDef === undefined || propDef._def === undefined) {
+            continue;
+        }
+        var propOptional = safeIsOptional(propDef);
+        if (propOptional && forceOptionalIntoNullable) {
+            if (propDef._def.typeName === "ZodOptional") {
+                propDef = propDef._def.innerType;
+            }
+            if (!propDef.isNullable()) {
+                propDef = propDef.nullable();
+            }
+            propOptional = false;
+        }
+        var parsedDef = parseDef(propDef._def, _object_spread_props$5(_object_spread$5({}, refs), {
+            currentPath: _to_consumable_array$5(refs.currentPath).concat([
+                "properties",
+                propName
+            ]),
+            propertyPath: _to_consumable_array$5(refs.currentPath).concat([
+                "properties",
+                propName
+            ])
+        }));
+        if (parsedDef === undefined) {
+            continue;
+        }
+        result.properties[propName] = parsedDef;
+        if (!propOptional) {
+            required.push(propName);
+        }
+    }
+    if (required.length) {
+        result.required = required;
+    }
+    var additionalProperties = decideAdditionalProperties(def, refs);
+    if (additionalProperties !== undefined) {
+        result.additionalProperties = additionalProperties;
+    }
+    return result;
+}
+function decideAdditionalProperties(def, refs) {
+    if (def.catchall._def.typeName !== "ZodNever") {
+        return parseDef(def.catchall._def, _object_spread_props$5(_object_spread$5({}, refs), {
+            currentPath: _to_consumable_array$5(refs.currentPath).concat([
+                "additionalProperties"
+            ])
+        }));
+    }
+    switch(def.unknownKeys){
+        case "passthrough":
+            return refs.allowedAdditionalProperties;
+        case "strict":
+            return refs.rejectedAdditionalProperties;
+        case "strip":
+            return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
+    }
+}
+function safeIsOptional(schema) {
+    try {
+        return schema.isOptional();
+    } catch (e) {
+        return true;
+    }
+}
+
+function _array_like_to_array$4(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$4(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$4(arr);
+}
+function _define_property$4(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array$4(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread$4() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread$4(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$4(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$4(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$4(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$4(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _to_consumable_array$4(arr) {
+    return _array_without_holes$4(arr) || _iterable_to_array$4(arr) || _unsupported_iterable_to_array$4(arr) || _non_iterable_spread$4();
+}
+function _unsupported_iterable_to_array$4(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$4(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$4(o, minLen);
+}
+var parseOptionalDef = function(def, refs) {
+    var _refs_propertyPath;
+    if (refs.currentPath.toString() === ((_refs_propertyPath = refs.propertyPath) === null || _refs_propertyPath === void 0 ? void 0 : _refs_propertyPath.toString())) {
+        return parseDef(def.innerType._def, refs);
+    }
+    var innerSchema = parseDef(def.innerType._def, _object_spread_props$4(_object_spread$4({}, refs), {
+        currentPath: _to_consumable_array$4(refs.currentPath).concat([
+            "anyOf",
+            "1"
+        ])
+    }));
+    return innerSchema ? {
+        anyOf: [
+            {
+                not: parseAnyDef(refs)
+            },
+            innerSchema
+        ]
+    } : parseAnyDef(refs);
+};
+
+function _array_like_to_array$3(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$3(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$3(arr);
+}
+function _define_property$3(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array$3(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread$3() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread$3(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$3(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$3(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$3(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$3(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _to_consumable_array$3(arr) {
+    return _array_without_holes$3(arr) || _iterable_to_array$3(arr) || _unsupported_iterable_to_array$3(arr) || _non_iterable_spread$3();
+}
+function _unsupported_iterable_to_array$3(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$3(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$3(o, minLen);
+}
+var parsePipelineDef = function(def, refs) {
+    if (refs.pipeStrategy === "input") {
+        return parseDef(def.in._def, refs);
+    } else if (refs.pipeStrategy === "output") {
+        return parseDef(def.out._def, refs);
+    }
+    var a = parseDef(def.in._def, _object_spread_props$3(_object_spread$3({}, refs), {
+        currentPath: _to_consumable_array$3(refs.currentPath).concat([
+            "allOf",
+            "0"
+        ])
+    }));
+    var b = parseDef(def.out._def, _object_spread_props$3(_object_spread$3({}, refs), {
+        currentPath: _to_consumable_array$3(refs.currentPath).concat([
+            "allOf",
+            a ? "1" : "0"
+        ])
+    }));
+    return {
+        allOf: [
+            a,
+            b
+        ].filter(function(x) {
+            return x !== undefined;
+        })
+    };
+};
+
+function parsePromiseDef(def, refs) {
+    return parseDef(def.type._def, refs);
+}
+
+function _array_like_to_array$2(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$2(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$2(arr);
+}
+function _define_property$2(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array$2(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread$2() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread$2(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$2(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$2(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$2(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$2(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _to_consumable_array$2(arr) {
+    return _array_without_holes$2(arr) || _iterable_to_array$2(arr) || _unsupported_iterable_to_array$2(arr) || _non_iterable_spread$2();
+}
+function _unsupported_iterable_to_array$2(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$2(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$2(o, minLen);
+}
+function parseSetDef(def, refs) {
+    var items = parseDef(def.valueType._def, _object_spread_props$2(_object_spread$2({}, refs), {
+        currentPath: _to_consumable_array$2(refs.currentPath).concat([
+            "items"
+        ])
+    }));
+    var schema = {
+        type: "array",
+        uniqueItems: true,
+        items: items
+    };
+    if (def.minSize) {
+        setResponseValueAndErrors(schema, "minItems", def.minSize.value, def.minSize.message, refs);
+    }
+    if (def.maxSize) {
+        setResponseValueAndErrors(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs);
+    }
+    return schema;
+}
+
+function _array_like_to_array$1(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes$1(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$1(arr);
+}
+function _define_property$1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array$1(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread$1() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread$1(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$1(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$1(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$1(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$1(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _to_consumable_array$1(arr) {
+    return _array_without_holes$1(arr) || _iterable_to_array$1(arr) || _unsupported_iterable_to_array$1(arr) || _non_iterable_spread$1();
+}
+function _unsupported_iterable_to_array$1(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$1(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$1(o, minLen);
+}
+function parseTupleDef(def, refs) {
+    if (def.rest) {
+        return {
+            type: "array",
+            minItems: def.items.length,
+            items: def.items.map(function(x, i) {
+                return parseDef(x._def, _object_spread_props$1(_object_spread$1({}, refs), {
+                    currentPath: _to_consumable_array$1(refs.currentPath).concat([
+                        "items",
+                        "".concat(i)
+                    ])
+                }));
+            }).reduce(function(acc, x) {
+                return x === undefined ? acc : _to_consumable_array$1(acc).concat([
+                    x
+                ]);
+            }, []),
+            additionalItems: parseDef(def.rest._def, _object_spread_props$1(_object_spread$1({}, refs), {
+                currentPath: _to_consumable_array$1(refs.currentPath).concat([
+                    "additionalItems"
+                ])
+            }))
+        };
+    } else {
+        return {
+            type: "array",
+            minItems: def.items.length,
+            maxItems: def.items.length,
+            items: def.items.map(function(x, i) {
+                return parseDef(x._def, _object_spread_props$1(_object_spread$1({}, refs), {
+                    currentPath: _to_consumable_array$1(refs.currentPath).concat([
+                        "items",
+                        "".concat(i)
+                    ])
+                }));
+            }).reduce(function(acc, x) {
+                return x === undefined ? acc : _to_consumable_array$1(acc).concat([
+                    x
+                ]);
+            }, [])
+        };
+    }
+}
+
+function parseUndefinedDef(refs) {
+    return {
+        not: parseAnyDef(refs)
+    };
+}
+
+function parseUnknownDef(refs) {
+    return parseAnyDef(refs);
+}
+
+var parseReadonlyDef = function(def, refs) {
+    return parseDef(def.innerType._def, refs);
+};
+
+var selectParser = function(def, typeName, refs) {
+    switch(typeName){
+        case v3.ZodFirstPartyTypeKind.ZodString:
+            return parseStringDef(def, refs);
+        case v3.ZodFirstPartyTypeKind.ZodNumber:
+            return parseNumberDef(def, refs);
+        case v3.ZodFirstPartyTypeKind.ZodObject:
+            return parseObjectDef(def, refs);
+        case v3.ZodFirstPartyTypeKind.ZodBigInt:
+            return parseBigintDef(def, refs);
+        case v3.ZodFirstPartyTypeKind.ZodBoolean:
+            return parseBooleanDef();
+        case v3.ZodFirstPartyTypeKind.ZodDate:
+            return parseDateDef(def, refs);
+        case v3.ZodFirstPartyTypeKind.ZodUndefined:
+            return parseUndefinedDef(refs);
+        case v3.ZodFirstPartyTypeKind.ZodNull:
+            return parseNullDef(refs);
+        case v3.ZodFirstPartyTypeKind.ZodArray:
+            return parseArrayDef(def, refs);
+        case v3.ZodFirstPartyTypeKind.ZodUnion:
+        case v3.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+            return parseUnionDef(def, refs);
+        case v3.ZodFirstPartyTypeKind.ZodIntersection:
+            return parseIntersectionDef(def, refs);
+        case v3.ZodFirstPartyTypeKind.ZodTuple:
+            return parseTupleDef(def, refs);
+        case v3.ZodFirstPartyTypeKind.ZodRecord:
+            return parseRecordDef(def, refs);
+        case v3.ZodFirstPartyTypeKind.ZodLiteral:
+            return parseLiteralDef(def, refs);
+        case v3.ZodFirstPartyTypeKind.ZodEnum:
+            return parseEnumDef(def);
+        case v3.ZodFirstPartyTypeKind.ZodNativeEnum:
+            return parseNativeEnumDef(def);
+        case v3.ZodFirstPartyTypeKind.ZodNullable:
+            return parseNullableDef(def, refs);
+        case v3.ZodFirstPartyTypeKind.ZodOptional:
+            return parseOptionalDef(def, refs);
+        case v3.ZodFirstPartyTypeKind.ZodMap:
+            return parseMapDef(def, refs);
+        case v3.ZodFirstPartyTypeKind.ZodSet:
+            return parseSetDef(def, refs);
+        case v3.ZodFirstPartyTypeKind.ZodLazy:
+            return function() {
+                return def.getter()._def;
+            };
+        case v3.ZodFirstPartyTypeKind.ZodPromise:
+            return parsePromiseDef(def, refs);
+        case v3.ZodFirstPartyTypeKind.ZodNaN:
+        case v3.ZodFirstPartyTypeKind.ZodNever:
+            return parseNeverDef(refs);
+        case v3.ZodFirstPartyTypeKind.ZodEffects:
+            return parseEffectsDef(def, refs);
+        case v3.ZodFirstPartyTypeKind.ZodAny:
+            return parseAnyDef(refs);
+        case v3.ZodFirstPartyTypeKind.ZodUnknown:
+            return parseUnknownDef(refs);
+        case v3.ZodFirstPartyTypeKind.ZodDefault:
+            return parseDefaultDef(def, refs);
+        case v3.ZodFirstPartyTypeKind.ZodBranded:
+            return parseBrandedDef(def, refs);
+        case v3.ZodFirstPartyTypeKind.ZodReadonly:
+            return parseReadonlyDef(def, refs);
+        case v3.ZodFirstPartyTypeKind.ZodCatch:
+            return parseCatchDef(def, refs);
+        case v3.ZodFirstPartyTypeKind.ZodPipeline:
+            return parsePipelineDef(def, refs);
+        case v3.ZodFirstPartyTypeKind.ZodFunction:
+        case v3.ZodFirstPartyTypeKind.ZodVoid:
+        case v3.ZodFirstPartyTypeKind.ZodSymbol:
+            return undefined;
+        default:
+            return function(_) {
+                return undefined;
+            }();
+    }
+};
+
+function parseDef(def, refs) {
+    var forceResolution = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+    var seenItem = refs.seen.get(def);
+    if (refs.override) {
+        var _refs_override;
+        var overrideResult = (_refs_override = refs.override) === null || _refs_override === void 0 ? void 0 : _refs_override.call(refs, def, refs, seenItem, forceResolution);
+        if (overrideResult !== ignoreOverride) {
+            return overrideResult;
+        }
+    }
+    if (seenItem && !forceResolution) {
+        var seenSchema = get$ref(seenItem, refs);
+        if (seenSchema !== undefined) {
+            return seenSchema;
+        }
+    }
+    var newItem = {
+        def: def,
+        path: refs.currentPath,
+        jsonSchema: undefined
+    };
+    refs.seen.set(def, newItem);
+    var jsonSchemaOrGetter = selectParser(def, def.typeName, refs);
+    // If the return was a function, then the inner definition needs to be extracted before a call to parseDef (recursive)
+    var jsonSchema = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
+    if (jsonSchema) {
+        addMeta(def, refs, jsonSchema);
+    }
+    if (refs.postProcess) {
+        var postProcessResult = refs.postProcess(jsonSchema, def, refs);
+        newItem.jsonSchema = jsonSchema;
+        return postProcessResult;
+    }
+    newItem.jsonSchema = jsonSchema;
+    return jsonSchema;
+}
+var get$ref = function(item, refs) {
+    switch(refs.$refStrategy){
+        case "root":
+            return {
+                $ref: item.path.join("/")
+            };
+        case "relative":
+            return {
+                $ref: getRelativePath(refs.currentPath, item.path)
+            };
+        case "none":
+        case "seen":
+            {
+                if (item.path.length < refs.currentPath.length && item.path.every(function(value, index) {
+                    return refs.currentPath[index] === value;
+                })) {
+                    console.warn("Recursive reference detected at ".concat(refs.currentPath.join("/"), "! Defaulting to any"));
+                    return parseAnyDef(refs);
+                }
+                return refs.$refStrategy === "seen" ? parseAnyDef(refs) : undefined;
+            }
+    }
+};
+var addMeta = function(def, refs, jsonSchema) {
+    if (def.description) {
+        jsonSchema.description = def.description;
+        if (refs.markdownDescription) {
+            jsonSchema.markdownDescription = def.description;
+        }
+    }
+    return jsonSchema;
+};
+
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var zodToJsonSchema = function(schema, options) {
+    var refs = getRefs(options);
+    var definitions = undefined;
+    var name = void 0 ;
+    var _parseDef;
+    var main = (_parseDef = parseDef(schema._def, refs , false)) !== null && _parseDef !== void 0 ? _parseDef : parseAnyDef(refs);
+    if (refs.flags.hasReferencedOpenAiAnyType) {
+        if (!definitions) {
+            definitions = {};
+        }
+        if (!definitions[refs.openAiAnyTypeName]) {
+            definitions[refs.openAiAnyTypeName] = {
+                // Skipping "object" as no properties can be defined and additionalProperties must be "false"
+                type: [
+                    "string",
+                    "number",
+                    "integer",
+                    "boolean",
+                    "array",
+                    "null"
+                ],
+                items: {
+                    $ref: refs.$refStrategy === "relative" ? "1" : _to_consumable_array(refs.basePath).concat([
+                        refs.definitionPath,
+                        refs.openAiAnyTypeName
+                    ]).join("/")
+                }
+            };
+        }
+    }
+    var combined = name === undefined ? definitions ? _object_spread_props(_object_spread({}, main), _define_property({}, refs.definitionPath, definitions)) : main : _define_property({
+        $ref: _to_consumable_array(refs.$refStrategy === "relative" ? [] : refs.basePath).concat([
+            refs.definitionPath,
+            name
+        ]).join("/")
+    }, refs.definitionPath, _object_spread_props(_object_spread({}, definitions), _define_property({}, name, main)));
+    if (refs.target === "jsonSchema7") {
+        combined.$schema = "http://json-schema.org/draft-07/schema#";
+    } else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") {
+        combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
+    }
+    if (refs.target === "openAi" && ("anyOf" in combined || "oneOf" in combined || "allOf" in combined || "type" in combined && Array.isArray(combined.type))) {
+        console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
+    }
+    return combined;
+};
+
+function runtimeToolProviderComponent(provider) {
+    var _extensions_resources, _extensions_resourceTemplates, _extensions_prompts;
+    const descriptor = describeXpertToolProvider(provider);
+    const options = descriptor.options;
+    const extensions = resolveXpertMcpExtensions(provider, descriptor);
+    // Fingerprint declarations only; never execute resource, prompt or completion handlers.
+    const capabilities = _extends._extends({}, (extensions == null ? void 0 : (_extensions_resources = extensions.resources) == null ? void 0 : _extensions_resources.length) ? {
+        resources: extensions.resources.map((_param)=>{
+            var { read } = _param, definition = _object_without_properties_loose$2(_param, [
+                "read"
+            ]);
+            return definition;
+        })
+    } : {}, (extensions == null ? void 0 : (_extensions_resourceTemplates = extensions.resourceTemplates) == null ? void 0 : _extensions_resourceTemplates.length) ? {
+        resourceTemplates: extensions.resourceTemplates.map((_param)=>{
+            var { read, complete } = _param, definition = _object_without_properties_loose$2(_param, [
+                "read",
+                "complete"
+            ]);
+            return _extends._extends({}, definition, {
+                supportsCompletion: !!complete
+            });
+        })
+    } : {}, (extensions == null ? void 0 : (_extensions_prompts = extensions.prompts) == null ? void 0 : _extensions_prompts.length) ? {
+        prompts: extensions.prompts.map((_param)=>{
+            var { get, complete } = _param, definition = _object_without_properties_loose$2(_param, [
+                "get",
+                "complete"
+            ]);
+            return _extends._extends({}, definition, {
+                hasCompletionHandler: !!complete
+            });
+        })
+    } : {});
+    const tools = descriptor.tools.map((tool)=>{
+        var _tool_options_title, _tool_middlewareProvider, _tool_options_mcp_visibility;
+        return {
+            name: tool.options.name,
+            title: (_tool_options_title = tool.options.title) != null ? _tool_options_title : null,
+            description: tool.options.description,
+            middleware: (_tool_middlewareProvider = tool.middlewareProvider) != null ? _tool_middlewareProvider : null,
+            mcp: tool.options.mcp ? _extends._extends({}, tool.options.mcp.inputSchema ? {
+                transportInputSchema: JSON.parse(JSON.stringify(zodToJsonSchema(tool.options.mcp.inputSchema)))
+            } : {}, tool.options.mcp.task ? {
+                task: tool.options.mcp.task
+            } : {}, {
+                behavior: tool.options.mcp.behavior,
+                requiredContext: [
+                    ...tool.options.mcp.requiredContext
+                ],
+                visibility: [
+                    ...(_tool_options_mcp_visibility = tool.options.mcp.visibility) != null ? _tool_options_mcp_visibility : [
+                        'model'
+                    ]
+                ],
+                inputSchema: JSON.parse(JSON.stringify(zodToJsonSchema(tool.options.inputSchema))),
+                outputSchema: tool.options.outputSchema ? JSON.parse(JSON.stringify(zodToJsonSchema(tool.options.outputSchema))) : null
+            }) : null
+        };
+    });
+    var _options_description, _options_instructions;
+    const config = {
+        provider: options.provider,
+        name: options.name,
+        description: (_options_description = options.description) != null ? _options_description : null,
+        instructions: (_options_instructions = options.instructions) != null ? _options_instructions : null,
+        runtimeDiscovered: true,
+        nativeMcp: true,
+        toolCount: tools.filter((tool)=>!!tool.mcp).length
+    };
+    const metadata = {
+        runtimeDiscovered: true,
+        nativeMcp: true,
+        toolNames: tools.filter((tool)=>!!tool.mcp).map((tool)=>tool.name)
+    };
+    return {
+        componentType: contracts.PLUGIN_COMPONENT_TYPE.TOOLSET,
+        componentKey: options.componentKey,
+        config,
+        metadata,
+        definitionHash: node_crypto.createHash('sha256').update(stableJson(_extends._extends({
+            config,
+            metadata,
+            tools
+        }, capabilities))).digest('hex')
+    };
+}
+function stableJson(value) {
+    if (value === undefined) return 'null';
+    if (value === null || typeof value !== 'object') return JSON.stringify(value);
+    if (Array.isArray(value)) return `[${value.map((item)=>stableJson(item)).join(',')}]`;
+    const entries = Object.entries(value).sort(([left], [right])=>left.localeCompare(right));
+    return `{${entries.map(([key, item])=>`${JSON.stringify(key)}:${stableJson(item)}`).join(',')}}`;
+}
+
 Object.defineProperty(exports, "ASSISTANT_CHAT_SEND_MESSAGE_COMMAND", {
     enumerable: true,
     get: function () { return contracts.ASSISTANT_CHAT_SEND_MESSAGE_COMMAND; }
@@ -6667,12 +9737,15 @@ exports.DefaultAgentMiddlewareRuntimeCapabilityRegistry = modelProvider.DefaultR
 exports.DefaultRuntimeCapabilityRegistry = modelProvider.DefaultRuntimeCapabilityRegistry;
 exports.KnowledgeDocumentVisualAssetsRuntimeCapability = modelProvider.KnowledgeDocumentVisualAssetsRuntimeCapability;
 exports.KnowledgeDocumentVisualAssetsRuntimeFactoryCapability = modelProvider.KnowledgeDocumentVisualAssetsRuntimeFactoryCapability;
+exports.KnowledgeGraphRuntimeCapability = modelProvider.KnowledgeGraphRuntimeCapability;
 exports.KnowledgebaseDocumentsRuntimeCapability = modelProvider.KnowledgebaseDocumentsRuntimeCapability;
 exports.KnowledgebaseProvisioningRuntimeCapability = modelProvider.KnowledgebaseProvisioningRuntimeCapability;
 exports.KnowledgebaseRuntimeCapability = modelProvider.KnowledgebaseRuntimeCapability;
 exports.ModelProviderBuiltinToolset = modelProvider.ModelProviderBuiltinToolset;
 exports.ProjectAccessRuntimeCapability = modelProvider.ProjectAccessRuntimeCapability;
 exports.ProjectProvisioningRuntimeCapability = modelProvider.ProjectProvisioningRuntimeCapability;
+exports.RUNTIME_CAPABILITY_PROVIDER = modelProvider.RUNTIME_CAPABILITY_PROVIDER;
+exports.RuntimeCapabilityProvider = modelProvider.RuntimeCapabilityProvider;
 exports.SANDBOX_JOB_ERROR_CODES = modelProvider.SANDBOX_JOB_ERROR_CODES;
 exports.SANDBOX_JOB_PROGRESS_PREFIX = modelProvider.SANDBOX_JOB_PROGRESS_PREFIX;
 exports.SandboxJobRuntimeError = modelProvider.SandboxJobRuntimeError;
@@ -6682,6 +9755,11 @@ exports.WorkspaceFilesRuntimeCapability = modelProvider.WorkspaceFilesRuntimeCap
 exports.XPERT_RUNTIME_CAPABILITIES_TOKEN = modelProvider.XPERT_RUNTIME_CAPABILITIES_TOKEN;
 exports.createRuntimeCapability = modelProvider.createRuntimeCapability;
 exports.isSandboxJobRuntimeError = modelProvider.isSandboxJobRuntimeError;
+exports.DataSourceRuntimeCapability = dataWorkbench.DataSourceRuntimeCapability;
+exports.SqlDatabaseWorkbenchAdapter = dataWorkbench.SqlDatabaseWorkbenchAdapter;
+exports.quoteDatabaseIdentifier = dataWorkbench.quoteDatabaseIdentifier;
+exports.requireReadStatement = dataWorkbench.requireReadStatement;
+exports.splitWorkbenchSql = dataWorkbench.splitWorkbenchSql;
 exports.ModelProviderHttpClient = modelProviderHttpClient.ModelProviderHttpClient;
 exports.ModelProviderHttpError = modelProviderHttpClient.ModelProviderHttpError;
 exports.CONNECTOR_AUTHORIZATION_MODES = connector.CONNECTOR_AUTHORIZATION_MODES;
@@ -6851,6 +9929,9 @@ exports.XPERT_TOOL_PROVIDER = XPERT_TOOL_PROVIDER;
 exports.XPERT_TOOL_PROVIDER_METADATA = XPERT_TOOL_PROVIDER_METADATA;
 exports.XPERT_TOOL_RESULT_FORMAT_VERSION = XPERT_TOOL_RESULT_FORMAT_VERSION;
 exports.XpFileSystem = XpFileSystem;
+exports.XpertPrompt = XpertPrompt;
+exports.XpertResource = XpertResource;
+exports.XpertResourceTemplate = XpertResourceTemplate;
 exports.XpertServerPlugin = XpertServerPlugin;
 exports.XpertTool = XpertTool;
 exports.XpertToolProvider = XpertToolProvider;
@@ -6862,6 +9943,7 @@ exports.calculateLLMUsagePrice = calculateLLMUsagePrice;
 exports.calculateModelPrice = calculateModelPrice;
 exports.calculateModelUsageCharge = calculateModelUsageCharge;
 exports.chunkText = chunkText;
+exports.countTextTokens = countTextTokens;
 exports.countTokensSafe = countTokensSafe;
 exports.createI18nInstance = createI18nInstance;
 exports.createPluginLogger = createPluginLogger;
@@ -6917,7 +9999,10 @@ exports.resolveSandboxTerminalAdapter = resolveSandboxTerminalAdapter;
 exports.resolveStrategyMetadataTarget = resolveStrategyMetadataTarget;
 exports.resolveTenantGlobalScopeKey = resolveTenantGlobalScopeKey;
 exports.resolveTokenUsage = resolveTokenUsage;
+exports.resolveXpertMcpExtensions = resolveXpertMcpExtensions;
 exports.runWithRequestContext = runWithRequestContext;
+exports.runtimeToolProviderComponent = runtimeToolProviderComponent;
 exports.secondsToMilliseconds = secondsToMilliseconds;
 exports.setDefaultTenantId = setDefaultTenantId;
 exports.sumTokenUsage = sumTokenUsage;
+exports.textTokenBoundaries = textTokenBoundaries;