@discomedia/utils 1.0.61 → 1.0.63

package/dist/index.cjs

@@ -1150,6 +1150,8 @@ function isOpenRouterModel(model) {
         'openai/gpt-5-mini',
         'openai/gpt-5-nano',
         'openai/gpt-5.1',
+        'openai/gpt-5.4',
+        'openai/gpt-5.4-pro',
         'openai/gpt-5.2',
         'openai/gpt-5.2-pro',
         'openai/gpt-5.1-codex',
@@ -1579,7 +1581,7 @@ function maybeObj(x) {
     return x ?? {};
 }
 // https://stackoverflow.com/a/34491287
-function isEmptyObj(obj) {
+function isEmptyObj$1(obj) {
     if (!obj)
         return true;
     for (const _k in obj)
@@ -3318,6 +3320,20 @@ let Messages$1 = class Messages extends APIResource {
 function isChatCompletionFunctionTool(tool) {
     return tool !== undefined && 'function' in tool && tool.function !== undefined;
 }
+function makeParseableTextFormat(response_format, parser) {
+    const obj = { ...response_format };
+    Object.defineProperties(obj, {
+        $brand: {
+            value: 'auto-parseable-response-format',
+            enumerable: false,
+        },
+        $parseRaw: {
+            value: parser,
+            enumerable: false,
+        },
+    });
+    return obj;
+}
 function isAutoParsableResponseFormat(response_format) {
     return response_format?.['$brand'] === 'auto-parseable-response-format';
 }
@@ -5330,7 +5346,7 @@ const readEnv = (env) => {
     return undefined;
 };
 
-var _AssistantStream_instances, _a$1, _AssistantStream_events, _AssistantStream_runStepSnapshots, _AssistantStream_messageSnapshots, _AssistantStream_messageSnapshot, _AssistantStream_finalRun, _AssistantStream_currentContentIndex, _AssistantStream_currentContent, _AssistantStream_currentToolCallIndex, _AssistantStream_currentToolCall, _AssistantStream_currentEvent, _AssistantStream_currentRunSnapshot, _AssistantStream_currentRunStepSnapshot, _AssistantStream_addEvent, _AssistantStream_endRequest, _AssistantStream_handleMessage, _AssistantStream_handleRunStep, _AssistantStream_handleEvent, _AssistantStream_accumulateRunStep, _AssistantStream_accumulateMessage, _AssistantStream_accumulateContent, _AssistantStream_handleRun;
+var _AssistantStream_instances, _a$2, _AssistantStream_events, _AssistantStream_runStepSnapshots, _AssistantStream_messageSnapshots, _AssistantStream_messageSnapshot, _AssistantStream_finalRun, _AssistantStream_currentContentIndex, _AssistantStream_currentContent, _AssistantStream_currentToolCallIndex, _AssistantStream_currentToolCall, _AssistantStream_currentEvent, _AssistantStream_currentRunSnapshot, _AssistantStream_currentRunStepSnapshot, _AssistantStream_addEvent, _AssistantStream_endRequest, _AssistantStream_handleMessage, _AssistantStream_handleRunStep, _AssistantStream_handleEvent, _AssistantStream_accumulateRunStep, _AssistantStream_accumulateMessage, _AssistantStream_accumulateContent, _AssistantStream_handleRun;
 class AssistantStream extends EventStream {
     constructor() {
         super(...arguments);
@@ -5405,7 +5421,7 @@ class AssistantStream extends EventStream {
         };
     }
     static fromReadableStream(stream) {
-        const runner = new _a$1();
+        const runner = new _a$2();
         runner._run(() => runner._fromReadableStream(stream));
         return runner;
     }
@@ -5431,7 +5447,7 @@ class AssistantStream extends EventStream {
         return stream.toReadableStream();
     }
     static createToolAssistantStream(runId, runs, params, options) {
-        const runner = new _a$1();
+        const runner = new _a$2();
         runner._run(() => runner._runToolAssistantStream(runId, runs, params, {
             ...options,
             headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'stream' },
@@ -5460,7 +5476,7 @@ class AssistantStream extends EventStream {
         return this._addRun(__classPrivateFieldGet(this, _AssistantStream_instances, "m", _AssistantStream_endRequest).call(this));
     }
     static createThreadAssistantStream(params, thread, options) {
-        const runner = new _a$1();
+        const runner = new _a$2();
         runner._run(() => runner._threadAssistantStream(params, thread, {
             ...options,
             headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'stream' },
@@ -5468,7 +5484,7 @@ class AssistantStream extends EventStream {
         return runner;
     }
     static createAssistantStream(threadId, runs, params, options) {
-        const runner = new _a$1();
+        const runner = new _a$2();
         runner._run(() => runner._runAssistantStream(threadId, runs, params, {
             ...options,
             headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'stream' },
@@ -5610,7 +5626,7 @@ class AssistantStream extends EventStream {
         return await this._createToolAssistantStream(runs, runId, params, options);
     }
 }
-_a$1 = AssistantStream, _AssistantStream_addEvent = function _AssistantStream_addEvent(event) {
+_a$2 = AssistantStream, _AssistantStream_addEvent = function _AssistantStream_addEvent(event) {
     if (this.ended)
         return;
     __classPrivateFieldSet(this, _AssistantStream_currentEvent, event);
@@ -5788,7 +5804,7 @@ _a$1 = AssistantStream, _AssistantStream_addEvent = function _AssistantStream_ad
             }
             let data = event.data;
             if (data.delta) {
-                const accumulated = _a$1.accumulateDelta(snapshot, data.delta);
+                const accumulated = _a$2.accumulateDelta(snapshot, data.delta);
                 __classPrivateFieldGet(this, _AssistantStream_runStepSnapshots, "f")[event.data.id] = accumulated;
             }
             return __classPrivateFieldGet(this, _AssistantStream_runStepSnapshots, "f")[event.data.id];
@@ -5842,7 +5858,7 @@ _a$1 = AssistantStream, _AssistantStream_addEvent = function _AssistantStream_ad
     }
     throw Error('Tried to accumulate a non-message event');
 }, _AssistantStream_accumulateContent = function _AssistantStream_accumulateContent(contentElement, currentContent) {
-    return _a$1.accumulateDelta(currentContent, contentElement);
+    return _a$2.accumulateDelta(currentContent, contentElement);
 }, _AssistantStream_handleRun = function _AssistantStream_handleRun(event) {
     __classPrivateFieldSet(this, _AssistantStream_currentRunSnapshot, event.data);
     switch (event.event) {
@@ -8260,7 +8276,7 @@ _Webhooks_instances = new WeakSet(), _Webhooks_validateSecret = function _Webhoo
 };
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-var _OpenAI_instances, _a, _OpenAI_encoder, _OpenAI_baseURLOverridden;
+var _OpenAI_instances, _a$1, _OpenAI_encoder, _OpenAI_baseURLOverridden;
 /**
  * API Client for interfacing with the OpenAI API.
  */
@@ -8351,7 +8367,7 @@ class OpenAI {
             throw new OpenAIError("It looks like you're running in a browser-like environment.\n\nThis is disabled by default, as it risks exposing your secret API credentials to attackers.\nIf you understand the risks and have appropriate mitigations in place,\nyou can set the `dangerouslyAllowBrowser` option to `true`, e.g.,\n\nnew OpenAI({ apiKey, dangerouslyAllowBrowser: true });\n\nhttps://help.openai.com/en/articles/5112595-best-practices-for-api-key-safety\n");
         }
         this.baseURL = options.baseURL;
-        this.timeout = options.timeout ?? _a.DEFAULT_TIMEOUT /* 10 minutes */;
+        this.timeout = options.timeout ?? _a$1.DEFAULT_TIMEOUT /* 10 minutes */;
         this.logger = options.logger ?? console;
         const defaultLogLevel = 'warn';
         // Set default logLevel early so that we can log a warning in parseLogLevel.
@@ -8439,7 +8455,7 @@ class OpenAI {
             new URL(path)
             : new URL(baseURL + (baseURL.endsWith('/') && path.startsWith('/') ? path.slice(1) : path));
         const defaultQuery = this.defaultQuery();
-        if (!isEmptyObj(defaultQuery)) {
+        if (!isEmptyObj$1(defaultQuery)) {
             query = { ...defaultQuery, ...query };
         }
         if (typeof query === 'object' && query && !Array.isArray(query)) {
@@ -8781,10 +8797,10 @@ class OpenAI {
         }
     }
 }
-_a = OpenAI, _OpenAI_encoder = new WeakMap(), _OpenAI_instances = new WeakSet(), _OpenAI_baseURLOverridden = function _OpenAI_baseURLOverridden() {
+_a$1 = OpenAI, _OpenAI_encoder = new WeakMap(), _OpenAI_instances = new WeakSet(), _OpenAI_baseURLOverridden = function _OpenAI_baseURLOverridden() {
     return this.baseURL !== 'https://api.openai.com/v1';
 };
-OpenAI.OpenAI = _a;
+OpenAI.OpenAI = _a$1;
 OpenAI.DEFAULT_TIMEOUT = 600000; // 10 minutes
 OpenAI.OpenAIError = OpenAIError;
 OpenAI.APIError = APIError;
@@ -8824,238 +8840,3050 @@ OpenAI.Containers = Containers;
 OpenAI.Skills = Skills;
 OpenAI.Videos = Videos;
 
-// llm-openai-config.ts
-const DEFAULT_MODEL = 'gpt-4.1-mini';
-/** Token costs in USD per 1M tokens. Last updated Feb 2025. */
-const openAiModelCosts = {
-    'gpt-4o': {
-        inputCost: 2.5 / 1_000_000,
-        outputCost: 10 / 1_000_000,
-    },
-    'gpt-4o-mini': {
-        inputCost: 0.15 / 1_000_000,
-        outputCost: 0.6 / 1_000_000,
-    },
-    'o1-mini': {
-        inputCost: 1.1 / 1_000_000,
-        outputCost: 4.4 / 1_000_000,
-    },
-    'o1': {
-        inputCost: 15 / 1_000_000,
-        outputCost: 60 / 1_000_000,
-    },
-    'o3-mini': {
-        inputCost: 1.1 / 1_000_000,
-        outputCost: 4.4 / 1_000_000,
-    },
-    'o3': {
-        inputCost: 2 / 1_000_000,
-        outputCost: 8 / 1_000_000,
-    },
-    'gpt-4.1': {
-        inputCost: 2 / 1_000_000,
-        outputCost: 8 / 1_000_000,
-    },
-    'gpt-4.1-mini': {
-        inputCost: 0.4 / 1_000_000,
-        outputCost: 1.6 / 1_000_000,
-    },
-    'gpt-4.1-nano': {
-        inputCost: 0.1 / 1_000_000,
-        outputCost: 0.4 / 1_000_000,
-    },
-    'gpt-5': {
-        inputCost: 1.25 / 1_000_000,
-        outputCost: 10 / 1_000_000,
-    },
-    'gpt-5-mini': {
-        inputCost: 0.25 / 1_000_000,
-        outputCost: 2 / 1_000_000,
-    },
-    'gpt-5-nano': {
-        inputCost: 0.05 / 1_000_000,
-        outputCost: 0.4 / 1_000_000,
-    },
-    'gpt-5.1': {
-        inputCost: 1.25 / 1_000_000,
-        outputCost: 10 / 1_000_000,
-    },
-    'gpt-5.2': {
-        inputCost: 1.5 / 1_000_000,
-        outputCost: 12 / 1_000_000,
-    },
-    'gpt-5.2-pro': {
-        inputCost: 3 / 1_000_000,
-        outputCost: 24 / 1_000_000,
-    },
-    'gpt-5.1-codex': {
-        inputCost: 1.1 / 1_000_000,
-        outputCost: 8.8 / 1_000_000,
-    },
-    'gpt-5.1-codex-max': {
-        inputCost: 1.8 / 1_000_000,
-        outputCost: 14.4 / 1_000_000,
-    },
-    'o4-mini': {
-        inputCost: 1.1 / 1_000_000,
-        outputCost: 4.4 / 1_000_000,
-    },
-};
-const deepseekModelCosts = {
-    'deepseek-chat': {
-        inputCost: 0.27 / 1_000_000, // $0.27 per 1M tokens (Cache miss price)
-        cacheHitCost: 0.07 / 1_000_000, // $0.07 per 1M tokens (Cache hit price)
-        outputCost: 1.1 / 1_000_000, // $1.10 per 1M tokens
-    },
-    'deepseek-reasoner': {
-        inputCost: 0.55 / 1_000_000, // $0.55 per 1M tokens (Cache miss price)
-        cacheHitCost: 0.14 / 1_000_000, // $0.14 per 1M tokens (Cache hit price)
-        outputCost: 2.19 / 1_000_000, // $2.19 per 1M tokens
-    },
-};
-/** Image generation costs in USD per image. Based on OpenAI pricing as of Feb 2025. */
-const openAiImageCosts = {
-    'gpt-image-1': 0.0075, // $0.0075 per image for gpt-image-1
-    'gpt-image-1.5': 0.0075, // Assumes parity pricing with gpt-image-1 until OpenAI publishes updated rates
-};
-/**
- * Calculates the cost of generating images using OpenAI's Images API.
- *
- * @param model The image generation model name.
- * @param imageCount The number of images generated.
- * @returns The cost of generating the images in USD.
- */
-function calculateImageCost(model, imageCount) {
-    if (typeof model !== 'string' || typeof imageCount !== 'number' || imageCount <= 0) {
-        return 0;
+// functions
+function getEnumValues(entries) {
+    const numericValues = Object.values(entries).filter((v) => typeof v === "number");
+    const values = Object.entries(entries)
+        .filter(([k, _]) => numericValues.indexOf(+k) === -1)
+        .map(([_, v]) => v);
+    return values;
+}
+
+var _a;
+class $ZodRegistry {
+    constructor() {
+        this._map = new WeakMap();
+        this._idmap = new Map();
+    }
+    add(schema, ..._meta) {
+        const meta = _meta[0];
+        this._map.set(schema, meta);
+        if (meta && typeof meta === "object" && "id" in meta) {
+            this._idmap.set(meta.id, schema);
+        }
+        return this;
+    }
+    clear() {
+        this._map = new WeakMap();
+        this._idmap = new Map();
+        return this;
+    }
+    remove(schema) {
+        const meta = this._map.get(schema);
+        if (meta && typeof meta === "object" && "id" in meta) {
+            this._idmap.delete(meta.id);
+        }
+        this._map.delete(schema);
+        return this;
+    }
+    get(schema) {
+        // return this._map.get(schema) as any;
+        // inherit metadata
+        const p = schema._zod.parent;
+        if (p) {
+            const pm = { ...(this.get(p) ?? {}) };
+            delete pm.id; // do not inherit id
+            const f = { ...pm, ...this._map.get(schema) };
+            return Object.keys(f).length ? f : undefined;
+        }
+        return this._map.get(schema);
+    }
+    has(schema) {
+        return this._map.has(schema);
     }
-    const costPerImage = openAiImageCosts[model];
-    if (!costPerImage)
-        return 0;
-    return imageCount * costPerImage;
 }
-/**
- * Calculates the cost of calling a language model in USD based on the provider and model, tokens, and given costs per 1M tokens.
- *
- * @param provider The provider of the language model. Supported providers are 'openai' and 'deepseek'.
- * @param model The name of the language model. Supported models are listed in the `openAiModelCosts` and `deepseekModelCosts` objects.
- * @param inputTokens The number of input tokens passed to the language model.
- * @param outputTokens The number of output tokens generated by the language model.
- * @param reasoningTokens The number of output tokens generated by the language model for reasoning. This is only used for Deepseek models.
- * @param cacheHitTokens The number of input tokens that were cache hits for Deepseek models.
- * @returns The cost of calling the language model in USD.
- */
-function calculateCost(provider, model, inputTokens, outputTokens, reasoningTokens, cacheHitTokens) {
-    if (typeof provider !== 'string' ||
-        typeof model !== 'string' ||
-        typeof inputTokens !== 'number' ||
-        typeof outputTokens !== 'number' ||
-        (reasoningTokens !== undefined && typeof reasoningTokens !== 'number') ||
-        (cacheHitTokens !== undefined && typeof cacheHitTokens !== 'number')) {
-        return 0;
+// registries
+function registry() {
+    return new $ZodRegistry();
+}
+(_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
+const globalRegistry = globalThis.__zod_globalRegistry;
+
+// function initializeContext<T extends schemas.$ZodType>(inputs: JSONSchemaGeneratorParams<T>): ToJSONSchemaContext<T> {
+//   return {
+//     processor: inputs.processor,
+//     metadataRegistry: inputs.metadata ?? globalRegistry,
+//     target: inputs.target ?? "draft-2020-12",
+//     unrepresentable: inputs.unrepresentable ?? "throw",
+//   };
+// }
+function initializeContext(params) {
+    // Normalize target: convert old non-hyphenated versions to hyphenated versions
+    let target = params?.target ?? "draft-2020-12";
+    if (target === "draft-4")
+        target = "draft-04";
+    if (target === "draft-7")
+        target = "draft-07";
+    return {
+        processors: params.processors ?? {},
+        metadataRegistry: params?.metadata ?? globalRegistry,
+        target,
+        unrepresentable: params?.unrepresentable ?? "throw",
+        override: params?.override ?? (() => { }),
+        io: params?.io ?? "output",
+        counter: 0,
+        seen: new Map(),
+        cycles: params?.cycles ?? "ref",
+        reused: params?.reused ?? "inline",
+        external: params?.external ?? undefined,
+    };
+}
+function process$1(schema, ctx, _params = { path: [], schemaPath: [] }) {
+    var _a;
+    const def = schema._zod.def;
+    // check for schema in seens
+    const seen = ctx.seen.get(schema);
+    if (seen) {
+        seen.count++;
+        // check if cycle
+        const isCycle = _params.schemaPath.includes(schema);
+        if (isCycle) {
+            seen.cycle = _params.path;
+        }
+        return seen.schema;
+    }
+    // initialize
+    const result = { schema: {}, count: 1, cycle: undefined, path: _params.path };
+    ctx.seen.set(schema, result);
+    // custom method overrides default behavior
+    const overrideSchema = schema._zod.toJSONSchema?.();
+    if (overrideSchema) {
+        result.schema = overrideSchema;
     }
-    const modelCosts = provider === 'deepseek' ? deepseekModelCosts[model] : openAiModelCosts[model];
-    if (!modelCosts)
-        return 0;
-    // Calculate input cost based on cache hit/miss for Deepseek
-    const inputCost = provider === 'deepseek' && modelCosts.cacheHitCost
-        ? (cacheHitTokens || 0) * modelCosts.cacheHitCost + (inputTokens - (cacheHitTokens || 0)) * modelCosts.inputCost
-        : inputTokens * modelCosts.inputCost;
-    const outputCost = outputTokens * modelCosts.outputCost;
-    const reasoningCost = (reasoningTokens || 0) * modelCosts.outputCost;
-    return inputCost + outputCost + reasoningCost;
+    else {
+        const params = {
+            ..._params,
+            schemaPath: [..._params.schemaPath, schema],
+            path: _params.path,
+        };
+        if (schema._zod.processJSONSchema) {
+            schema._zod.processJSONSchema(ctx, result.schema, params);
+        }
+        else {
+            const _json = result.schema;
+            const processor = ctx.processors[def.type];
+            if (!processor) {
+                throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
+            }
+            processor(schema, ctx, _json, params);
+        }
+        const parent = schema._zod.parent;
+        if (parent) {
+            // Also set ref if processor didn't (for inheritance)
+            if (!result.ref)
+                result.ref = parent;
+            process$1(parent, ctx, params);
+            ctx.seen.get(parent).isParent = true;
+        }
+    }
+    // metadata
+    const meta = ctx.metadataRegistry.get(schema);
+    if (meta)
+        Object.assign(result.schema, meta);
+    if (ctx.io === "input" && isTransforming(schema)) {
+        // examples/defaults only apply to output type of pipe
+        delete result.schema.examples;
+        delete result.schema.default;
+    }
+    // set prefault as default
+    if (ctx.io === "input" && result.schema._prefault)
+        (_a = result.schema).default ?? (_a.default = result.schema._prefault);
+    delete result.schema._prefault;
+    // pulling fresh from ctx.seen in case it was overwritten
+    const _result = ctx.seen.get(schema);
+    return _result.schema;
 }
-
-/**
- * Fix a broken JSON string by attempting to extract and parse valid JSON content. This function is very lenient and will attempt to fix many types of JSON errors, including unbalanced brackets, missing or extra commas, improperly escaped $ signs, unquoted strings, trailing commas, missing closing brackets or braces, etc.
- * @param {string} jsonStr - The broken JSON string to fix
- * @returns {JsonValue} - The parsed JSON value
- */
-function fixBrokenJson(jsonStr) {
-    // Pre-process: Fix improperly escaped $ signs
-    jsonStr = jsonStr.replace(/\\\$/g, '$');
-    let index = 0;
-    function parse() {
-        const results = [];
-        while (index < jsonStr.length) {
-            skipWhitespace();
-            const value = parseValue();
-            if (value !== undefined) {
-                results.push(value);
+function extractDefs(ctx, schema
+// params: EmitParams
+) {
+    // iterate over seen map;
+    const root = ctx.seen.get(schema);
+    if (!root)
+        throw new Error("Unprocessed schema. This is a bug in Zod.");
+    // Track ids to detect duplicates across different schemas
+    const idToSchema = new Map();
+    for (const entry of ctx.seen.entries()) {
+        const id = ctx.metadataRegistry.get(entry[0])?.id;
+        if (id) {
+            const existing = idToSchema.get(id);
+            if (existing && existing !== entry[0]) {
+                throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
             }
-            else {
-                index++; // Skip invalid character
+            idToSchema.set(id, entry[0]);
+        }
+    }
+    // returns a ref to the schema
+    // defId will be empty if the ref points to an external schema (or #)
+    const makeURI = (entry) => {
+        // comparing the seen objects because sometimes
+        // multiple schemas map to the same seen object.
+        // e.g. lazy
+        // external is configured
+        const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
+        if (ctx.external) {
+            const externalId = ctx.external.registry.get(entry[0])?.id; // ?? "__shared";// `__schema${ctx.counter++}`;
+            // check if schema is in the external registry
+            const uriGenerator = ctx.external.uri ?? ((id) => id);
+            if (externalId) {
+                return { ref: uriGenerator(externalId) };
+            }
+            // otherwise, add to __shared
+            const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;
+            entry[1].defId = id; // set defId so it will be reused if needed
+            return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` };
+        }
+        if (entry[1] === root) {
+            return { ref: "#" };
+        }
+        // self-contained schema
+        const uriPrefix = `#`;
+        const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
+        const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
+        return { defId, ref: defUriPrefix + defId };
+    };
+    // stored cached version in `def` property
+    // remove all properties, set $ref
+    const extractToDef = (entry) => {
+        // if the schema is already a reference, do not extract it
+        if (entry[1].schema.$ref) {
+            return;
+        }
+        const seen = entry[1];
+        const { ref, defId } = makeURI(entry);
+        seen.def = { ...seen.schema };
+        // defId won't be set if the schema is a reference to an external schema
+        // or if the schema is the root schema
+        if (defId)
+            seen.defId = defId;
+        // wipe away all properties except $ref
+        const schema = seen.schema;
+        for (const key in schema) {
+            delete schema[key];
+        }
+        schema.$ref = ref;
+    };
+    // throw on cycles
+    // break cycles
+    if (ctx.cycles === "throw") {
+        for (const entry of ctx.seen.entries()) {
+            const seen = entry[1];
+            if (seen.cycle) {
+                throw new Error("Cycle detected: " +
+                    `#/${seen.cycle?.join("/")}/<root>` +
+                    '\n\nSet the `cycles` parameter to `"ref"` to resolve cyclical schemas with defs.');
             }
         }
-        return results.length === 1 ? results[0] : results;
     }
-    function parseValue() {
-        skipWhitespace();
-        const char = getChar();
-        if (!char)
-            return undefined;
-        if (char === '{')
-            return parseObject();
-        if (char === '[')
-            return parseArray();
-        if (char === '"' || char === "'")
-            return parseString();
-        if (char === 't' && jsonStr.slice(index, index + 4).toLowerCase() === 'true') {
-            index += 4;
-            return true;
+    // extract schemas into $defs
+    for (const entry of ctx.seen.entries()) {
+        const seen = entry[1];
+        // convert root schema to # $ref
+        if (schema === entry[0]) {
+            extractToDef(entry); // this has special handling for the root schema
+            continue;
         }
-        if (char === 'f' && jsonStr.slice(index, index + 5).toLowerCase() === 'false') {
-            index += 5;
-            return false;
+        // extract schemas that are in the external registry
+        if (ctx.external) {
+            const ext = ctx.external.registry.get(entry[0])?.id;
+            if (schema !== entry[0] && ext) {
+                extractToDef(entry);
+                continue;
+            }
         }
-        if (char === 'n' && jsonStr.slice(index, index + 4).toLowerCase() === 'null') {
-            index += 4;
-            return null;
+        // extract schemas with `id` meta
+        const id = ctx.metadataRegistry.get(entry[0])?.id;
+        if (id) {
+            extractToDef(entry);
+            continue;
         }
-        if (/[a-zA-Z]/.test(char))
-            return parseString(); // Unquoted string
-        if (char === '-' || char === '.' || /\d/.test(char))
-            return parseNumber();
-        return undefined; // Unknown character
-    }
-    function parseObject() {
-        const obj = {};
-        index++; // Skip opening brace
-        skipWhitespace();
-        while (index < jsonStr.length && getChar() !== '}') {
-            skipWhitespace();
-            const key = parseString();
-            if (key === undefined) {
-                console.warn(`Expected key at position ${index}`);
-                index++;
+        // break cycles
+        if (seen.cycle) {
+            // any
+            extractToDef(entry);
+            continue;
+        }
+        // extract reused schemas
+        if (seen.count > 1) {
+            if (ctx.reused === "ref") {
+                extractToDef(entry);
+                // biome-ignore lint:
                 continue;
             }
-            skipWhitespace();
-            if (getChar() === ':') {
-                index++; // Skip colon
+        }
+    }
+}
+function finalize(ctx, schema) {
+    const root = ctx.seen.get(schema);
+    if (!root)
+        throw new Error("Unprocessed schema. This is a bug in Zod.");
+    // flatten refs - inherit properties from parent schemas
+    const flattenRef = (zodSchema) => {
+        const seen = ctx.seen.get(zodSchema);
+        // already processed
+        if (seen.ref === null)
+            return;
+        const schema = seen.def ?? seen.schema;
+        const _cached = { ...schema };
+        const ref = seen.ref;
+        seen.ref = null; // prevent infinite recursion
+        if (ref) {
+            flattenRef(ref);
+            const refSeen = ctx.seen.get(ref);
+            const refSchema = refSeen.schema;
+            // merge referenced schema into current
+            if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
+                // older drafts can't combine $ref with other properties
+                schema.allOf = schema.allOf ?? [];
+                schema.allOf.push(refSchema);
             }
             else {
-                console.warn(`Missing colon after key "${key}" at position ${index}`);
+                Object.assign(schema, refSchema);
             }
-            skipWhitespace();
-            const value = parseValue();
-            if (value === undefined) {
-                console.warn(`Expected value for key "${key}" at position ${index}`);
-                index++;
-                continue;
+            // restore child's own properties (child wins)
+            Object.assign(schema, _cached);
+            const isParentRef = zodSchema._zod.parent === ref;
+            // For parent chain, child is a refinement - remove parent-only properties
+            if (isParentRef) {
+                for (const key in schema) {
+                    if (key === "$ref" || key === "allOf")
+                        continue;
+                    if (!(key in _cached)) {
+                        delete schema[key];
+                    }
+                }
             }
-            obj[key] = value;
-            skipWhitespace();
-            if (getChar() === ',') {
-                index++; // Skip comma
+            // When ref was extracted to $defs, remove properties that match the definition
+            if (refSchema.$ref && refSeen.def) {
+                for (const key in schema) {
+                    if (key === "$ref" || key === "allOf")
+                        continue;
+                    if (key in refSeen.def && JSON.stringify(schema[key]) === JSON.stringify(refSeen.def[key])) {
+                        delete schema[key];
+                    }
+                }
             }
-            else {
-                break;
+        }
+        // If parent was extracted (has $ref), propagate $ref to this schema
+        // This handles cases like: readonly().meta({id}).describe()
+        // where processor sets ref to innerType but parent should be referenced
+        const parent = zodSchema._zod.parent;
+        if (parent && parent !== ref) {
+            // Ensure parent is processed first so its def has inherited properties
+            flattenRef(parent);
+            const parentSeen = ctx.seen.get(parent);
+            if (parentSeen?.schema.$ref) {
+                schema.$ref = parentSeen.schema.$ref;
+                // De-duplicate with parent's definition
+                if (parentSeen.def) {
+                    for (const key in schema) {
+                        if (key === "$ref" || key === "allOf")
+                            continue;
+                        if (key in parentSeen.def && JSON.stringify(schema[key]) === JSON.stringify(parentSeen.def[key])) {
+                            delete schema[key];
+                        }
+                    }
+                }
             }
-            skipWhitespace();
         }
-        if (getChar() === '}') {
-            index++; // Skip closing brace
+        // execute overrides
+        ctx.override({
+            zodSchema: zodSchema,
+            jsonSchema: schema,
+            path: seen.path ?? [],
+        });
+    };
+    for (const entry of [...ctx.seen.entries()].reverse()) {
+        flattenRef(entry[0]);
+    }
+    const result = {};
+    if (ctx.target === "draft-2020-12") {
+        result.$schema = "https://json-schema.org/draft/2020-12/schema";
+    }
+    else if (ctx.target === "draft-07") {
+        result.$schema = "http://json-schema.org/draft-07/schema#";
+    }
+    else if (ctx.target === "draft-04") {
+        result.$schema = "http://json-schema.org/draft-04/schema#";
+    }
+    else if (ctx.target === "openapi-3.0") ;
+    else ;
+    if (ctx.external?.uri) {
+        const id = ctx.external.registry.get(schema)?.id;
+        if (!id)
+            throw new Error("Schema is missing an `id` property");
+        result.$id = ctx.external.uri(id);
+    }
+    Object.assign(result, root.def ?? root.schema);
+    // build defs object
+    const defs = ctx.external?.defs ?? {};
+    for (const entry of ctx.seen.entries()) {
+        const seen = entry[1];
+        if (seen.def && seen.defId) {
+            defs[seen.defId] = seen.def;
+        }
+    }
+    // set definitions in result
+    if (ctx.external) ;
+    else {
+        if (Object.keys(defs).length > 0) {
+            if (ctx.target === "draft-2020-12") {
+                result.$defs = defs;
+            }
+            else {
+                result.definitions = defs;
+            }
+        }
+    }
+    try {
+        // this "finalizes" this schema and ensures all cycles are removed
+        // each call to finalize() is functionally independent
+        // though the seen map is shared
+        const finalized = JSON.parse(JSON.stringify(result));
+        Object.defineProperty(finalized, "~standard", {
+            value: {
+                ...schema["~standard"],
+                jsonSchema: {
+                    input: createStandardJSONSchemaMethod(schema, "input", ctx.processors),
+                    output: createStandardJSONSchemaMethod(schema, "output", ctx.processors),
+                },
+            },
+            enumerable: false,
+            writable: false,
+        });
+        return finalized;
+    }
+    catch (_err) {
+        throw new Error("Error converting schema to JSON.");
+    }
+}
+function isTransforming(_schema, _ctx) {
+    const ctx = _ctx ?? { seen: new Set() };
+    if (ctx.seen.has(_schema))
+        return false;
+    ctx.seen.add(_schema);
+    const def = _schema._zod.def;
+    if (def.type === "transform")
+        return true;
+    if (def.type === "array")
+        return isTransforming(def.element, ctx);
+    if (def.type === "set")
+        return isTransforming(def.valueType, ctx);
+    if (def.type === "lazy")
+        return isTransforming(def.getter(), ctx);
+    if (def.type === "promise" ||
+        def.type === "optional" ||
+        def.type === "nonoptional" ||
+        def.type === "nullable" ||
+        def.type === "readonly" ||
+        def.type === "default" ||
+        def.type === "prefault") {
+        return isTransforming(def.innerType, ctx);
+    }
+    if (def.type === "intersection") {
+        return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
+    }
+    if (def.type === "record" || def.type === "map") {
+        return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
+    }
+    if (def.type === "pipe") {
+        return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
+    }
+    if (def.type === "object") {
+        for (const key in def.shape) {
+            if (isTransforming(def.shape[key], ctx))
+                return true;
+        }
+        return false;
+    }
+    if (def.type === "union") {
+        for (const option of def.options) {
+            if (isTransforming(option, ctx))
+                return true;
+        }
+        return false;
+    }
+    if (def.type === "tuple") {
+        for (const item of def.items) {
+            if (isTransforming(item, ctx))
+                return true;
+        }
+        if (def.rest && isTransforming(def.rest, ctx))
+            return true;
+        return false;
+    }
+    return false;
+}
+const createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
+    const { libraryOptions, target } = params ?? {};
+    const ctx = initializeContext({ ...(libraryOptions ?? {}), target, io, processors });
+    process$1(schema, ctx);
+    extractDefs(ctx, schema);
+    return finalize(ctx, schema);
+};
+
+const formatMap = {
+    guid: "uuid",
+    url: "uri",
+    datetime: "date-time",
+    json_string: "json-string",
+    regex: "", // do not set
+};
+// ==================== SIMPLE TYPE PROCESSORS ====================
+const stringProcessor = (schema, ctx, _json, _params) => {
+    const json = _json;
+    json.type = "string";
+    const { minimum, maximum, format, patterns, contentEncoding } = schema._zod
+        .bag;
+    if (typeof minimum === "number")
+        json.minLength = minimum;
+    if (typeof maximum === "number")
+        json.maxLength = maximum;
+    // custom pattern overrides format
+    if (format) {
+        json.format = formatMap[format] ?? format;
+        if (json.format === "")
+            delete json.format; // empty format is not valid
+        // JSON Schema format: "time" requires a full time with offset or Z
+        // z.iso.time() does not include timezone information, so format: "time" should never be used
+        if (format === "time") {
+            delete json.format;
+        }
+    }
+    if (contentEncoding)
+        json.contentEncoding = contentEncoding;
+    if (patterns && patterns.size > 0) {
+        const regexes = [...patterns];
+        if (regexes.length === 1)
+            json.pattern = regexes[0].source;
+        else if (regexes.length > 1) {
+            json.allOf = [
+                ...regexes.map((regex) => ({
+                    ...(ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0"
+                        ? { type: "string" }
+                        : {}),
+                    pattern: regex.source,
+                })),
+            ];
+        }
+    }
+};
+const numberProcessor = (schema, ctx, _json, _params) => {
+    const json = _json;
+    const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
+    if (typeof format === "string" && format.includes("int"))
+        json.type = "integer";
+    else
+        json.type = "number";
+    if (typeof exclusiveMinimum === "number") {
+        if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+            json.minimum = exclusiveMinimum;
+            json.exclusiveMinimum = true;
+        }
+        else {
+            json.exclusiveMinimum = exclusiveMinimum;
+        }
+    }
+    if (typeof minimum === "number") {
+        json.minimum = minimum;
+        if (typeof exclusiveMinimum === "number" && ctx.target !== "draft-04") {
+            if (exclusiveMinimum >= minimum)
+                delete json.minimum;
+            else
+                delete json.exclusiveMinimum;
+        }
+    }
+    if (typeof exclusiveMaximum === "number") {
+        if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+            json.maximum = exclusiveMaximum;
+            json.exclusiveMaximum = true;
+        }
+        else {
+            json.exclusiveMaximum = exclusiveMaximum;
+        }
+    }
+    if (typeof maximum === "number") {
+        json.maximum = maximum;
+        if (typeof exclusiveMaximum === "number" && ctx.target !== "draft-04") {
+            if (exclusiveMaximum <= maximum)
+                delete json.maximum;
+            else
+                delete json.exclusiveMaximum;
+        }
+    }
+    if (typeof multipleOf === "number")
+        json.multipleOf = multipleOf;
+};
+const booleanProcessor = (_schema, _ctx, json, _params) => {
+    json.type = "boolean";
+};
+const bigintProcessor = (_schema, ctx, _json, _params) => {
+    if (ctx.unrepresentable === "throw") {
+        throw new Error("BigInt cannot be represented in JSON Schema");
+    }
+};
+const symbolProcessor = (_schema, ctx, _json, _params) => {
+    if (ctx.unrepresentable === "throw") {
+        throw new Error("Symbols cannot be represented in JSON Schema");
+    }
+};
+const nullProcessor = (_schema, ctx, json, _params) => {
+    if (ctx.target === "openapi-3.0") {
+        json.type = "string";
+        json.nullable = true;
+        json.enum = [null];
+    }
+    else {
+        json.type = "null";
+    }
+};
+const undefinedProcessor = (_schema, ctx, _json, _params) => {
+    if (ctx.unrepresentable === "throw") {
+        throw new Error("Undefined cannot be represented in JSON Schema");
+    }
+};
+const voidProcessor = (_schema, ctx, _json, _params) => {
+    if (ctx.unrepresentable === "throw") {
+        throw new Error("Void cannot be represented in JSON Schema");
+    }
+};
+const neverProcessor = (_schema, _ctx, json, _params) => {
+    json.not = {};
+};
+const anyProcessor = (_schema, _ctx, _json, _params) => {
+    // empty schema accepts anything
+};
+const unknownProcessor = (_schema, _ctx, _json, _params) => {
+    // empty schema accepts anything
+};
+const dateProcessor = (_schema, ctx, _json, _params) => {
+    if (ctx.unrepresentable === "throw") {
+        throw new Error("Date cannot be represented in JSON Schema");
+    }
+};
+const enumProcessor = (schema, _ctx, json, _params) => {
+    const def = schema._zod.def;
+    const values = getEnumValues(def.entries);
+    // Number enums can have both string and number values
+    if (values.every((v) => typeof v === "number"))
+        json.type = "number";
+    if (values.every((v) => typeof v === "string"))
+        json.type = "string";
+    json.enum = values;
+};
+const literalProcessor = (schema, ctx, json, _params) => {
+    const def = schema._zod.def;
+    const vals = [];
+    for (const val of def.values) {
+        if (val === undefined) {
+            if (ctx.unrepresentable === "throw") {
+                throw new Error("Literal `undefined` cannot be represented in JSON Schema");
+            }
+        }
+        else if (typeof val === "bigint") {
+            if (ctx.unrepresentable === "throw") {
+                throw new Error("BigInt literals cannot be represented in JSON Schema");
+            }
+            else {
+                vals.push(Number(val));
+            }
+        }
+        else {
+            vals.push(val);
+        }
+    }
+    if (vals.length === 0) ;
+    else if (vals.length === 1) {
+        const val = vals[0];
+        json.type = val === null ? "null" : typeof val;
+        if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
+            json.enum = [val];
+        }
+        else {
+            json.const = val;
+        }
+    }
+    else {
+        if (vals.every((v) => typeof v === "number"))
+            json.type = "number";
+        if (vals.every((v) => typeof v === "string"))
+            json.type = "string";
+        if (vals.every((v) => typeof v === "boolean"))
+            json.type = "boolean";
+        if (vals.every((v) => v === null))
+            json.type = "null";
+        json.enum = vals;
+    }
+};
+const nanProcessor = (_schema, ctx, _json, _params) => {
+    if (ctx.unrepresentable === "throw") {
+        throw new Error("NaN cannot be represented in JSON Schema");
+    }
+};
+const templateLiteralProcessor = (schema, _ctx, json, _params) => {
+    const _json = json;
+    const pattern = schema._zod.pattern;
+    if (!pattern)
+        throw new Error("Pattern not found in template literal");
+    _json.type = "string";
+    _json.pattern = pattern.source;
+};
+const fileProcessor = (schema, _ctx, json, _params) => {
+    const _json = json;
+    const file = {
+        type: "string",
+        format: "binary",
+        contentEncoding: "binary",
+    };
+    const { minimum, maximum, mime } = schema._zod.bag;
+    if (minimum !== undefined)
+        file.minLength = minimum;
+    if (maximum !== undefined)
+        file.maxLength = maximum;
+    if (mime) {
+        if (mime.length === 1) {
+            file.contentMediaType = mime[0];
+            Object.assign(_json, file);
+        }
+        else {
+            Object.assign(_json, file); // shared props at root
+            _json.anyOf = mime.map((m) => ({ contentMediaType: m })); // only contentMediaType differs
+        }
+    }
+    else {
+        Object.assign(_json, file);
+    }
+};
+const successProcessor = (_schema, _ctx, json, _params) => {
+    json.type = "boolean";
+};
+const customProcessor = (_schema, ctx, _json, _params) => {
+    if (ctx.unrepresentable === "throw") {
+        throw new Error("Custom types cannot be represented in JSON Schema");
+    }
+};
+const functionProcessor = (_schema, ctx, _json, _params) => {
+    if (ctx.unrepresentable === "throw") {
+        throw new Error("Function types cannot be represented in JSON Schema");
+    }
+};
+const transformProcessor = (_schema, ctx, _json, _params) => {
+    if (ctx.unrepresentable === "throw") {
+        throw new Error("Transforms cannot be represented in JSON Schema");
+    }
+};
+const mapProcessor = (_schema, ctx, _json, _params) => {
+    if (ctx.unrepresentable === "throw") {
+        throw new Error("Map cannot be represented in JSON Schema");
+    }
+};
+const setProcessor = (_schema, ctx, _json, _params) => {
+    if (ctx.unrepresentable === "throw") {
+        throw new Error("Set cannot be represented in JSON Schema");
+    }
+};
+// ==================== COMPOSITE TYPE PROCESSORS ====================
+const arrayProcessor = (schema, ctx, _json, params) => {
+    const json = _json;
+    const def = schema._zod.def;
+    const { minimum, maximum } = schema._zod.bag;
+    if (typeof minimum === "number")
+        json.minItems = minimum;
+    if (typeof maximum === "number")
+        json.maxItems = maximum;
+    json.type = "array";
+    json.items = process$1(def.element, ctx, { ...params, path: [...params.path, "items"] });
+};
+const objectProcessor = (schema, ctx, _json, params) => {
+    const json = _json;
+    const def = schema._zod.def;
+    json.type = "object";
+    json.properties = {};
+    const shape = def.shape;
+    for (const key in shape) {
+        json.properties[key] = process$1(shape[key], ctx, {
+            ...params,
+            path: [...params.path, "properties", key],
+        });
+    }
+    // required keys
+    const allKeys = new Set(Object.keys(shape));
+    const requiredKeys = new Set([...allKeys].filter((key) => {
+        const v = def.shape[key]._zod;
+        if (ctx.io === "input") {
+            return v.optin === undefined;
+        }
+        else {
+            return v.optout === undefined;
+        }
+    }));
+    if (requiredKeys.size > 0) {
+        json.required = Array.from(requiredKeys);
+    }
+    // catchall
+    if (def.catchall?._zod.def.type === "never") {
+        // strict
+        json.additionalProperties = false;
+    }
+    else if (!def.catchall) {
+        // regular
+        if (ctx.io === "output")
+            json.additionalProperties = false;
+    }
+    else if (def.catchall) {
+        json.additionalProperties = process$1(def.catchall, ctx, {
+            ...params,
+            path: [...params.path, "additionalProperties"],
+        });
+    }
+};
+const unionProcessor = (schema, ctx, json, params) => {
+    const def = schema._zod.def;
+    // Exclusive unions (inclusive === false) use oneOf (exactly one match) instead of anyOf (one or more matches)
+    // This includes both z.xor() and discriminated unions
+    const isExclusive = def.inclusive === false;
+    const options = def.options.map((x, i) => process$1(x, ctx, {
+        ...params,
+        path: [...params.path, isExclusive ? "oneOf" : "anyOf", i],
+    }));
+    if (isExclusive) {
+        json.oneOf = options;
+    }
+    else {
+        json.anyOf = options;
+    }
+};
+const intersectionProcessor = (schema, ctx, json, params) => {
+    const def = schema._zod.def;
+    const a = process$1(def.left, ctx, {
+        ...params,
+        path: [...params.path, "allOf", 0],
+    });
+    const b = process$1(def.right, ctx, {
+        ...params,
+        path: [...params.path, "allOf", 1],
+    });
+    const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
+    const allOf = [
+        ...(isSimpleIntersection(a) ? a.allOf : [a]),
+        ...(isSimpleIntersection(b) ? b.allOf : [b]),
+    ];
+    json.allOf = allOf;
+};
+const tupleProcessor = (schema, ctx, _json, params) => {
+    const json = _json;
+    const def = schema._zod.def;
+    json.type = "array";
+    const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
+    const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
+    const prefixItems = def.items.map((x, i) => process$1(x, ctx, {
+        ...params,
+        path: [...params.path, prefixPath, i],
+    }));
+    const rest = def.rest
+        ? process$1(def.rest, ctx, {
+            ...params,
+            path: [...params.path, restPath, ...(ctx.target === "openapi-3.0" ? [def.items.length] : [])],
+        })
+        : null;
+    if (ctx.target === "draft-2020-12") {
+        json.prefixItems = prefixItems;
+        if (rest) {
+            json.items = rest;
+        }
+    }
+    else if (ctx.target === "openapi-3.0") {
+        json.items = {
+            anyOf: prefixItems,
+        };
+        if (rest) {
+            json.items.anyOf.push(rest);
+        }
+        json.minItems = prefixItems.length;
+        if (!rest) {
+            json.maxItems = prefixItems.length;
+        }
+    }
+    else {
+        json.items = prefixItems;
+        if (rest) {
+            json.additionalItems = rest;
+        }
+    }
+    // length
+    const { minimum, maximum } = schema._zod.bag;
+    if (typeof minimum === "number")
+        json.minItems = minimum;
+    if (typeof maximum === "number")
+        json.maxItems = maximum;
+};
+const recordProcessor = (schema, ctx, _json, params) => {
+    const json = _json;
+    const def = schema._zod.def;
+    json.type = "object";
+    // For looseRecord with regex patterns, use patternProperties
+    // This correctly represents "only validate keys matching the pattern" semantics
+    // and composes well with allOf (intersections)
+    const keyType = def.keyType;
+    const keyBag = keyType._zod.bag;
+    const patterns = keyBag?.patterns;
+    if (def.mode === "loose" && patterns && patterns.size > 0) {
+        // Use patternProperties for looseRecord with regex patterns
+        const valueSchema = process$1(def.valueType, ctx, {
+            ...params,
+            path: [...params.path, "patternProperties", "*"],
+        });
+        json.patternProperties = {};
+        for (const pattern of patterns) {
+            json.patternProperties[pattern.source] = valueSchema;
+        }
+    }
+    else {
+        // Default behavior: use propertyNames + additionalProperties
+        if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
+            json.propertyNames = process$1(def.keyType, ctx, {
+                ...params,
+                path: [...params.path, "propertyNames"],
+            });
+        }
+        json.additionalProperties = process$1(def.valueType, ctx, {
+            ...params,
+            path: [...params.path, "additionalProperties"],
+        });
+    }
+    // Add required for keys with discrete values (enum, literal, etc.)
+    const keyValues = keyType._zod.values;
+    if (keyValues) {
+        const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
+        if (validKeyValues.length > 0) {
+            json.required = validKeyValues;
+        }
+    }
+};
+const nullableProcessor = (schema, ctx, json, params) => {
+    const def = schema._zod.def;
+    const inner = process$1(def.innerType, ctx, params);
+    const seen = ctx.seen.get(schema);
+    if (ctx.target === "openapi-3.0") {
+        seen.ref = def.innerType;
+        json.nullable = true;
+    }
+    else {
+        json.anyOf = [inner, { type: "null" }];
+    }
+};
+const nonoptionalProcessor = (schema, ctx, _json, params) => {
+    const def = schema._zod.def;
+    process$1(def.innerType, ctx, params);
+    const seen = ctx.seen.get(schema);
+    seen.ref = def.innerType;
+};
+const defaultProcessor = (schema, ctx, json, params) => {
+    const def = schema._zod.def;
+    process$1(def.innerType, ctx, params);
+    const seen = ctx.seen.get(schema);
+    seen.ref = def.innerType;
+    json.default = JSON.parse(JSON.stringify(def.defaultValue));
+};
+const prefaultProcessor = (schema, ctx, json, params) => {
+    const def = schema._zod.def;
+    process$1(def.innerType, ctx, params);
+    const seen = ctx.seen.get(schema);
+    seen.ref = def.innerType;
+    if (ctx.io === "input")
+        json._prefault = JSON.parse(JSON.stringify(def.defaultValue));
+};
+const catchProcessor = (schema, ctx, json, params) => {
+    const def = schema._zod.def;
+    process$1(def.innerType, ctx, params);
+    const seen = ctx.seen.get(schema);
+    seen.ref = def.innerType;
+    let catchValue;
+    try {
+        catchValue = def.catchValue(undefined);
+    }
+    catch {
+        throw new Error("Dynamic catch values are not supported in JSON Schema");
+    }
+    json.default = catchValue;
+};
+const pipeProcessor = (schema, ctx, _json, params) => {
+    const def = schema._zod.def;
+    const innerType = ctx.io === "input" ? (def.in._zod.def.type === "transform" ? def.out : def.in) : def.out;
+    process$1(innerType, ctx, params);
+    const seen = ctx.seen.get(schema);
+    seen.ref = innerType;
+};
+const readonlyProcessor = (schema, ctx, json, params) => {
+    const def = schema._zod.def;
+    process$1(def.innerType, ctx, params);
+    const seen = ctx.seen.get(schema);
+    seen.ref = def.innerType;
+    json.readOnly = true;
+};
+const promiseProcessor = (schema, ctx, _json, params) => {
+    const def = schema._zod.def;
+    process$1(def.innerType, ctx, params);
+    const seen = ctx.seen.get(schema);
+    seen.ref = def.innerType;
+};
+const optionalProcessor = (schema, ctx, _json, params) => {
+    const def = schema._zod.def;
+    process$1(def.innerType, ctx, params);
+    const seen = ctx.seen.get(schema);
+    seen.ref = def.innerType;
+};
+const lazyProcessor = (schema, ctx, _json, params) => {
+    const innerType = schema._zod.innerType;
+    process$1(innerType, ctx, params);
+    const seen = ctx.seen.get(schema);
+    seen.ref = innerType;
+};
+// ==================== ALL PROCESSORS ====================
+const allProcessors = {
+    string: stringProcessor,
+    number: numberProcessor,
+    boolean: booleanProcessor,
+    bigint: bigintProcessor,
+    symbol: symbolProcessor,
+    null: nullProcessor,
+    undefined: undefinedProcessor,
+    void: voidProcessor,
+    never: neverProcessor,
+    any: anyProcessor,
+    unknown: unknownProcessor,
+    date: dateProcessor,
+    enum: enumProcessor,
+    literal: literalProcessor,
+    nan: nanProcessor,
+    template_literal: templateLiteralProcessor,
+    file: fileProcessor,
+    success: successProcessor,
+    custom: customProcessor,
+    function: functionProcessor,
+    transform: transformProcessor,
+    map: mapProcessor,
+    set: setProcessor,
+    array: arrayProcessor,
+    object: objectProcessor,
+    union: unionProcessor,
+    intersection: intersectionProcessor,
+    tuple: tupleProcessor,
+    record: recordProcessor,
+    nullable: nullableProcessor,
+    nonoptional: nonoptionalProcessor,
+    default: defaultProcessor,
+    prefault: prefaultProcessor,
+    catch: catchProcessor,
+    pipe: pipeProcessor,
+    readonly: readonlyProcessor,
+    promise: promiseProcessor,
+    optional: optionalProcessor,
+    lazy: lazyProcessor,
+};
+function toJSONSchema(input, params) {
+    if ("_idmap" in input) {
+        // Registry case
+        const registry = input;
+        const ctx = initializeContext({ ...params, processors: allProcessors });
+        const defs = {};
+        // First pass: process all schemas to build the seen map
+        for (const entry of registry._idmap.entries()) {
+            const [_, schema] = entry;
+            process$1(schema, ctx);
+        }
+        const schemas = {};
+        const external = {
+            registry,
+            uri: params?.uri,
+            defs,
+        };
+        // Update the context with external configuration
+        ctx.external = external;
+        // Second pass: emit each schema
+        for (const entry of registry._idmap.entries()) {
+            const [key, schema] = entry;
+            extractDefs(ctx, schema);
+            schemas[key] = finalize(ctx, schema);
+        }
+        if (Object.keys(defs).length > 0) {
+            const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
+            schemas.__shared = {
+                [defsSegment]: defs,
+            };
+        }
+        return { schemas };
+    }
+    // Single schema case
+    const ctx = initializeContext({ ...params, processors: allProcessors });
+    process$1(input, ctx);
+    extractDefs(ctx, input);
+    return finalize(ctx, input);
+}
+
+const ignoreOverride = Symbol('Let zodToJsonSchema decide on which parser to use');
+const defaultOptions = {
+    name: undefined,
+    $refStrategy: 'root',
+    effectStrategy: 'input',
+    pipeStrategy: 'all',
+    dateStrategy: 'format:date-time',
+    mapStrategy: 'entries',
+    nullableStrategy: 'from-target',
+    removeAdditionalStrategy: 'passthrough',
+    definitionPath: 'definitions',
+    target: 'jsonSchema7',
+    strictUnions: false,
+    errorMessages: false,
+    markdownDescription: false,
+    patternStrategy: 'escape',
+    applyRegexFlags: false,
+    emailStrategy: 'format:email',
+    base64Strategy: 'contentEncoding:base64',
+    nameStrategy: 'ref',
+};
+const getDefaultOptions = (options) => {
+    // We need to add `definitions` here as we may mutate it
+    return (typeof options === 'string' ?
+        {
+            ...defaultOptions,
+            basePath: ['#'],
+            definitions: {},
+            name: options,
+        }
+        : {
+            ...defaultOptions,
+            basePath: ['#'],
+            definitions: {},
+            ...options,
+        });
+};
+
+const zodDef = (zodSchema) => {
+    return '_def' in zodSchema ? zodSchema._def : zodSchema;
+};
+function isEmptyObj(obj) {
+    if (!obj)
+        return true;
+    for (const _k in obj)
+        return false;
+    return true;
+}
+
+const getRefs = (options) => {
+    const _options = getDefaultOptions(options);
+    const currentPath = _options.name !== undefined ?
+        [..._options.basePath, _options.definitionPath, _options.name]
+        : _options.basePath;
+    return {
+        ..._options,
+        currentPath: currentPath,
+        propertyPath: undefined,
+        seenRefs: new Set(),
+        seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [
+            zodDef(def),
+            {
+                def: zodDef(def),
+                path: [..._options.basePath, _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 addErrorMessage(res, key, errorMessage, refs) {
+    if (!refs?.errorMessages)
+        return;
+    if (errorMessage) {
+        res.errorMessage = {
+            ...res.errorMessage,
+            [key]: errorMessage,
+        };
+    }
+}
+function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
+    res[key] = value;
+    addErrorMessage(res, key, errorMessage, refs);
+}
+
+var util;
+(function (util) {
+    util.assertEqual = (_) => { };
+    function assertIs(_arg) { }
+    util.assertIs = assertIs;
+    function assertNever(_x) {
+        throw new Error();
+    }
+    util.assertNever = assertNever;
+    util.arrayToEnum = (items) => {
+        const obj = {};
+        for (const item of items) {
+            obj[item] = item;
+        }
+        return obj;
+    };
+    util.getValidEnumValues = (obj) => {
+        const validKeys = util.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
+        const filtered = {};
+        for (const k of validKeys) {
+            filtered[k] = obj[k];
+        }
+        return util.objectValues(filtered);
+    };
+    util.objectValues = (obj) => {
+        return util.objectKeys(obj).map(function (e) {
+            return obj[e];
+        });
+    };
+    util.objectKeys = typeof Object.keys === "function" // eslint-disable-line ban/ban
+        ? (obj) => Object.keys(obj) // eslint-disable-line ban/ban
+        : (object) => {
+            const keys = [];
+            for (const key in object) {
+                if (Object.prototype.hasOwnProperty.call(object, key)) {
+                    keys.push(key);
+                }
+            }
+            return keys;
+        };
+    util.find = (arr, checker) => {
+        for (const item of arr) {
+            if (checker(item))
+                return item;
+        }
+        return undefined;
+    };
+    util.isInteger = typeof Number.isInteger === "function"
+        ? (val) => Number.isInteger(val) // eslint-disable-line ban/ban
+        : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
+    function joinValues(array, separator = " | ") {
+        return array.map((val) => (typeof val === "string" ? `'${val}'` : val)).join(separator);
+    }
+    util.joinValues = joinValues;
+    util.jsonStringifyReplacer = (_, value) => {
+        if (typeof value === "bigint") {
+            return value.toString();
+        }
+        return value;
+    };
+})(util || (util = {}));
+var objectUtil;
+(function (objectUtil) {
+    objectUtil.mergeShapes = (first, second) => {
+        return {
+            ...first,
+            ...second, // second overwrites first
+        };
+    };
+})(objectUtil || (objectUtil = {}));
+util.arrayToEnum([
+    "string",
+    "nan",
+    "number",
+    "integer",
+    "float",
+    "boolean",
+    "date",
+    "bigint",
+    "symbol",
+    "function",
+    "undefined",
+    "null",
+    "array",
+    "object",
+    "unknown",
+    "promise",
+    "void",
+    "never",
+    "map",
+    "set",
+]);
+
+util.arrayToEnum([
+    "invalid_type",
+    "invalid_literal",
+    "custom",
+    "invalid_union",
+    "invalid_union_discriminator",
+    "invalid_enum_value",
+    "unrecognized_keys",
+    "invalid_arguments",
+    "invalid_return_type",
+    "invalid_date",
+    "invalid_string",
+    "too_small",
+    "too_big",
+    "invalid_intersection_types",
+    "not_multiple_of",
+    "not_finite",
+]);
+class ZodError extends Error {
+    get errors() {
+        return this.issues;
+    }
+    constructor(issues) {
+        super();
+        this.issues = [];
+        this.addIssue = (sub) => {
+            this.issues = [...this.issues, sub];
+        };
+        this.addIssues = (subs = []) => {
+            this.issues = [...this.issues, ...subs];
+        };
+        const actualProto = new.target.prototype;
+        if (Object.setPrototypeOf) {
+            // eslint-disable-next-line ban/ban
+            Object.setPrototypeOf(this, actualProto);
+        }
+        else {
+            this.__proto__ = actualProto;
+        }
+        this.name = "ZodError";
+        this.issues = issues;
+    }
+    format(_mapper) {
+        const mapper = _mapper ||
+            function (issue) {
+                return issue.message;
+            };
+        const fieldErrors = { _errors: [] };
+        const processError = (error) => {
+            for (const issue of error.issues) {
+                if (issue.code === "invalid_union") {
+                    issue.unionErrors.map(processError);
+                }
+                else if (issue.code === "invalid_return_type") {
+                    processError(issue.returnTypeError);
+                }
+                else if (issue.code === "invalid_arguments") {
+                    processError(issue.argumentsError);
+                }
+                else if (issue.path.length === 0) {
+                    fieldErrors._errors.push(mapper(issue));
+                }
+                else {
+                    let curr = fieldErrors;
+                    let i = 0;
+                    while (i < issue.path.length) {
+                        const el = issue.path[i];
+                        const terminal = i === issue.path.length - 1;
+                        if (!terminal) {
+                            curr[el] = curr[el] || { _errors: [] };
+                            // if (typeof el === "string") {
+                            //   curr[el] = curr[el] || { _errors: [] };
+                            // } else if (typeof el === "number") {
+                            //   const errorArray: any = [];
+                            //   errorArray._errors = [];
+                            //   curr[el] = curr[el] || errorArray;
+                            // }
+                        }
+                        else {
+                            curr[el] = curr[el] || { _errors: [] };
+                            curr[el]._errors.push(mapper(issue));
+                        }
+                        curr = curr[el];
+                        i++;
+                    }
+                }
+            }
+        };
+        processError(this);
+        return fieldErrors;
+    }
+    static assert(value) {
+        if (!(value instanceof ZodError)) {
+            throw new Error(`Not a ZodError: ${value}`);
+        }
+    }
+    toString() {
+        return this.message;
+    }
+    get message() {
+        return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
+    }
+    get isEmpty() {
+        return this.issues.length === 0;
+    }
+    flatten(mapper = (issue) => issue.message) {
+        const fieldErrors = Object.create(null);
+        const formErrors = [];
+        for (const sub of this.issues) {
+            if (sub.path.length > 0) {
+                const firstEl = sub.path[0];
+                fieldErrors[firstEl] = fieldErrors[firstEl] || [];
+                fieldErrors[firstEl].push(mapper(sub));
+            }
+            else {
+                formErrors.push(mapper(sub));
+            }
+        }
+        return { formErrors, fieldErrors };
+    }
+    get formErrors() {
+        return this.flatten();
+    }
+}
+ZodError.create = (issues) => {
+    const error = new ZodError(issues);
+    return error;
+};
+
+var errorUtil;
+(function (errorUtil) {
+    errorUtil.errToObj = (message) => typeof message === "string" ? { message } : message || {};
+    // biome-ignore lint:
+    errorUtil.toString = (message) => typeof message === "string" ? message : message?.message;
+})(errorUtil || (errorUtil = {}));
+
+var ZodFirstPartyTypeKind;
+(function (ZodFirstPartyTypeKind) {
+    ZodFirstPartyTypeKind["ZodString"] = "ZodString";
+    ZodFirstPartyTypeKind["ZodNumber"] = "ZodNumber";
+    ZodFirstPartyTypeKind["ZodNaN"] = "ZodNaN";
+    ZodFirstPartyTypeKind["ZodBigInt"] = "ZodBigInt";
+    ZodFirstPartyTypeKind["ZodBoolean"] = "ZodBoolean";
+    ZodFirstPartyTypeKind["ZodDate"] = "ZodDate";
+    ZodFirstPartyTypeKind["ZodSymbol"] = "ZodSymbol";
+    ZodFirstPartyTypeKind["ZodUndefined"] = "ZodUndefined";
+    ZodFirstPartyTypeKind["ZodNull"] = "ZodNull";
+    ZodFirstPartyTypeKind["ZodAny"] = "ZodAny";
+    ZodFirstPartyTypeKind["ZodUnknown"] = "ZodUnknown";
+    ZodFirstPartyTypeKind["ZodNever"] = "ZodNever";
+    ZodFirstPartyTypeKind["ZodVoid"] = "ZodVoid";
+    ZodFirstPartyTypeKind["ZodArray"] = "ZodArray";
+    ZodFirstPartyTypeKind["ZodObject"] = "ZodObject";
+    ZodFirstPartyTypeKind["ZodUnion"] = "ZodUnion";
+    ZodFirstPartyTypeKind["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
+    ZodFirstPartyTypeKind["ZodIntersection"] = "ZodIntersection";
+    ZodFirstPartyTypeKind["ZodTuple"] = "ZodTuple";
+    ZodFirstPartyTypeKind["ZodRecord"] = "ZodRecord";
+    ZodFirstPartyTypeKind["ZodMap"] = "ZodMap";
+    ZodFirstPartyTypeKind["ZodSet"] = "ZodSet";
+    ZodFirstPartyTypeKind["ZodFunction"] = "ZodFunction";
+    ZodFirstPartyTypeKind["ZodLazy"] = "ZodLazy";
+    ZodFirstPartyTypeKind["ZodLiteral"] = "ZodLiteral";
+    ZodFirstPartyTypeKind["ZodEnum"] = "ZodEnum";
+    ZodFirstPartyTypeKind["ZodEffects"] = "ZodEffects";
+    ZodFirstPartyTypeKind["ZodNativeEnum"] = "ZodNativeEnum";
+    ZodFirstPartyTypeKind["ZodOptional"] = "ZodOptional";
+    ZodFirstPartyTypeKind["ZodNullable"] = "ZodNullable";
+    ZodFirstPartyTypeKind["ZodDefault"] = "ZodDefault";
+    ZodFirstPartyTypeKind["ZodCatch"] = "ZodCatch";
+    ZodFirstPartyTypeKind["ZodPromise"] = "ZodPromise";
+    ZodFirstPartyTypeKind["ZodBranded"] = "ZodBranded";
+    ZodFirstPartyTypeKind["ZodPipeline"] = "ZodPipeline";
+    ZodFirstPartyTypeKind["ZodReadonly"] = "ZodReadonly";
+})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
+
+function parseAnyDef() {
+    return {};
+}
+
+function parseArrayDef(def, refs) {
+    const res = {
+        type: 'array',
+    };
+    if (def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) {
+        res.items = parseDef(def.type._def, {
+            ...refs,
+            currentPath: [...refs.currentPath, '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) {
+    const res = {
+        type: 'integer',
+        format: 'int64',
+    };
+    if (!def.checks)
+        return res;
+    for (const check of def.checks) {
+        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;
+        }
+    }
+    return res;
+}
+
+function parseBooleanDef() {
+    return {
+        type: 'boolean',
+    };
+}
+
+function parseBrandedDef(_def, refs) {
+    return parseDef(_def.type._def, refs);
+}
+
+const parseCatchDef = (def, refs) => {
+    return parseDef(def.innerType._def, refs);
+};
+
+function parseDateDef(def, refs, overrideDateStrategy) {
+    const strategy = overrideDateStrategy ?? refs.dateStrategy;
+    if (Array.isArray(strategy)) {
+        return {
+            anyOf: strategy.map((item, i) => 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);
+    }
+}
+const integerDateParser = (def, refs) => {
+    const res = {
+        type: 'integer',
+        format: 'unix-time',
+    };
+    if (refs.target === 'openApi3') {
+        return res;
+    }
+    for (const check of def.checks) {
+        switch (check.kind) {
+            case 'min':
+                setResponseValueAndErrors(res, 'minimum', check.value, // This is in milliseconds
+                check.message, refs);
+                break;
+            case 'max':
+                setResponseValueAndErrors(res, 'maximum', check.value, // This is in milliseconds
+                check.message, refs);
+                break;
+        }
+    }
+    return res;
+};
+
+function parseDefaultDef(_def, refs) {
+    return {
+        ...parseDef(_def.innerType._def, refs),
+        default: _def.defaultValue(),
+    };
+}
+
+function parseEffectsDef(_def, refs, forceResolution) {
+    return refs.effectStrategy === 'input' ? parseDef(_def.schema._def, refs, forceResolution) : {};
+}
+
+function parseEnumDef(def) {
+    return {
+        type: 'string',
+        enum: [...def.values],
+    };
+}
+
+const isJsonSchema7AllOfType = (type) => {
+    if ('type' in type && type.type === 'string')
+        return false;
+    return 'allOf' in type;
+};
+function parseIntersectionDef(def, refs) {
+    const allOf = [
+        parseDef(def.left._def, {
+            ...refs,
+            currentPath: [...refs.currentPath, 'allOf', '0'],
+        }),
+        parseDef(def.right._def, {
+            ...refs,
+            currentPath: [...refs.currentPath, 'allOf', '1'],
+        }),
+    ].filter((x) => !!x);
+    let unevaluatedProperties = refs.target === 'jsonSchema2019-09' ? { unevaluatedProperties: false } : undefined;
+    const mergedAllOf = [];
+    // If either of the schemas is an allOf, merge them into a single allOf
+    allOf.forEach((schema) => {
+        if (isJsonSchema7AllOfType(schema)) {
+            mergedAllOf.push(...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 {
+            let nestedSchema = schema;
+            if ('additionalProperties' in schema && schema.additionalProperties === false) {
+                const { additionalProperties, ...rest } = schema;
+                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 ?
+        {
+            allOf: mergedAllOf,
+            ...unevaluatedProperties,
+        }
+        : undefined;
+}
+
+function parseLiteralDef(def, refs) {
+    const parsedType = typeof 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,
+    };
+}
+
+let emojiRegex;
+/**
+ * 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.
+ */
+const 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: () => {
+        if (emojiRegex === undefined) {
+            emojiRegex = RegExp('^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$', 'u');
+        }
+        return emojiRegex;
+    },
+    base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
+    nanoid: /^[a-zA-Z0-9_-]{21}$/,
+};
+function parseStringDef(def, refs) {
+    const res = {
+        type: 'string',
+    };
+    function processPattern(value) {
+        return refs.patternStrategy === 'escape' ? escapeNonAlphaNumeric(value) : value;
+    }
+    if (def.checks) {
+        for (const check of def.checks) {
+            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(`^${processPattern(check.value)}`), check.message, refs);
+                    break;
+                case 'endsWith':
+                    addPattern(res, RegExp(`${processPattern(check.value)}$`), 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(processPattern(check.value)), 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 '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);
+                }
+            }
+        }
+    }
+    return res;
+}
+const escapeNonAlphaNumeric = (value) => Array.from(value)
+    .map((c) => (/[a-zA-Z0-9]/.test(c) ? c : `\\${c}`))
+    .join('');
+const addFormat = (schema, value, message, refs) => {
+    if (schema.format || schema.anyOf?.some((x) => x.format)) {
+        if (!schema.anyOf) {
+            schema.anyOf = [];
+        }
+        if (schema.format) {
+            schema.anyOf.push({
+                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({
+            format: value,
+            ...(message && refs.errorMessages && { errorMessage: { format: message } }),
+        });
+    }
+    else {
+        setResponseValueAndErrors(schema, 'format', value, message, refs);
+    }
+};
+const addPattern = (schema, regex, message, refs) => {
+    if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {
+        if (!schema.allOf) {
+            schema.allOf = [];
+        }
+        if (schema.pattern) {
+            schema.allOf.push({
+                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({
+            pattern: processRegExp(regex, refs),
+            ...(message && refs.errorMessages && { errorMessage: { pattern: message } }),
+        });
+    }
+    else {
+        setResponseValueAndErrors(schema, 'pattern', processRegExp(regex, refs), message, refs);
+    }
+};
+// Mutate z.string.regex() in a best attempt to accommodate for regex flags when applyRegexFlags is true
+const processRegExp = (regexOrFunction, refs) => {
+    const regex = typeof regexOrFunction === 'function' ? regexOrFunction() : regexOrFunction;
+    if (!refs.applyRegexFlags || !regex.flags)
+        return regex.source;
+    // Currently handled flags
+    const flags = {
+        i: regex.flags.includes('i'), // Case-insensitive
+        m: regex.flags.includes('m'), // `^` and `$` matches adjacent to newline characters
+        s: regex.flags.includes('s'), // `.` matches newlines
+    };
+    // 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!
+    const source = flags.i ? regex.source.toLowerCase() : regex.source;
+    let pattern = '';
+    let isEscaped = false;
+    let inCharGroup = false;
+    let inCharRange = false;
+    for (let 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]/)) {
+                    if (inCharRange) {
+                        pattern += source[i];
+                        pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
+                        inCharRange = false;
+                    }
+                    else if (source[i + 1] === '-' && source[i + 2]?.match(/[a-z]/)) {
+                        pattern += source[i];
+                        inCharRange = true;
+                    }
+                    else {
+                        pattern += `${source[i]}${source[i].toUpperCase()}`;
+                    }
+                    continue;
+                }
+            }
+            else if (source[i].match(/[a-z]/)) {
+                pattern += `[${source[i]}${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 ? `${source[i]}\r\n` : `[${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 {
+        const regexTest = new RegExp(pattern);
+    }
+    catch {
+        console.warn(`Could not convert regex pattern at ${refs.currentPath.join('/')} to a flag-independent form! Falling back to the flag-ignorant source`);
+        return regex.source;
+    }
+    return pattern;
+};
+
+function parseRecordDef(def, refs) {
+    if (refs.target === 'openApi3' && def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
+        return {
+            type: 'object',
+            required: def.keyType._def.values,
+            properties: def.keyType._def.values.reduce((acc, key) => ({
+                ...acc,
+                [key]: parseDef(def.valueType._def, {
+                    ...refs,
+                    currentPath: [...refs.currentPath, 'properties', key],
+                }) ?? {},
+            }), {}),
+            additionalProperties: false,
+        };
+    }
+    const schema = {
+        type: 'object',
+        additionalProperties: parseDef(def.valueType._def, {
+            ...refs,
+            currentPath: [...refs.currentPath, 'additionalProperties'],
+        }) ?? {},
+    };
+    if (refs.target === 'openApi3') {
+        return schema;
+    }
+    if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
+        const keyType = Object.entries(parseStringDef(def.keyType._def, refs)).reduce((acc, [key, value]) => (key === 'type' ? acc : { ...acc, [key]: value }), {});
+        return {
+            ...schema,
+            propertyNames: keyType,
+        };
+    }
+    else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
+        return {
+            ...schema,
+            propertyNames: {
+                enum: def.keyType._def.values,
+            },
+        };
+    }
+    return schema;
+}
+
+function parseMapDef(def, refs) {
+    if (refs.mapStrategy === 'record') {
+        return parseRecordDef(def, refs);
+    }
+    const keys = parseDef(def.keyType._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, 'items', 'items', '0'],
+    }) || {};
+    const values = parseDef(def.valueType._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, 'items', 'items', '1'],
+    }) || {};
+    return {
+        type: 'array',
+        maxItems: 125,
+        items: {
+            type: 'array',
+            items: [keys, values],
+            minItems: 2,
+            maxItems: 2,
+        },
+    };
+}
+
+function parseNativeEnumDef(def) {
+    const object = def.values;
+    const actualKeys = Object.keys(def.values).filter((key) => {
+        return typeof object[object[key]] !== 'number';
+    });
+    const actualValues = actualKeys.map((key) => object[key]);
+    const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values)));
+    return {
+        type: parsedTypes.length === 1 ?
+            parsedTypes[0] === 'string' ?
+                'string'
+                : 'number'
+            : ['string', 'number'],
+        enum: actualValues,
+    };
+}
+
+function parseNeverDef() {
+    return {
+        not: {},
+    };
+}
+
+function parseNullDef(refs) {
+    return refs.target === 'openApi3' ?
+        {
+            enum: ['null'],
+            nullable: true,
+        }
+        : {
+            type: 'null',
+        };
+}
+
+const primitiveMappings = {
+    ZodString: 'string',
+    ZodNumber: 'number',
+    ZodBigInt: 'integer',
+    ZodBoolean: 'boolean',
+    ZodNull: 'null',
+};
+function parseUnionDef(def, refs) {
+    if (refs.target === 'openApi3')
+        return asAnyOf(def, refs);
+    const options = def.options instanceof 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((x) => 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: [...]}
+        const types = options.reduce((types, x) => {
+            const type = primitiveMappings[x._def.typeName]; //Can be safely casted due to row 43
+            return type && !types.includes(type) ? [...types, type] : types;
+        }, []);
+        return {
+            type: types.length > 1 ? types : types[0],
+        };
+    }
+    else if (options.every((x) => x._def.typeName === 'ZodLiteral' && !x.description)) {
+        // all options literals
+        const types = options.reduce((acc, x) => {
+            const type = typeof x._def.value;
+            switch (type) {
+                case 'string':
+                case 'number':
+                case 'boolean':
+                    return [...acc, type];
+                case 'bigint':
+                    return [...acc, 'integer'];
+                case 'object':
+                    if (x._def.value === null)
+                        return [...acc, 'null'];
+                case 'symbol':
+                case 'undefined':
+                case 'function':
+                default:
+                    return acc;
+            }
+        }, []);
+        if (types.length === options.length) {
+            // all the literals are primitive, as far as null can be considered primitive
+            const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
+            return {
+                type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
+                enum: options.reduce((acc, x) => {
+                    return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
+                }, []),
+            };
+        }
+    }
+    else if (options.every((x) => x._def.typeName === 'ZodEnum')) {
+        return {
+            type: 'string',
+            enum: options.reduce((acc, x) => [...acc, ...x._def.values.filter((x) => !acc.includes(x))], []),
+        };
+    }
+    return asAnyOf(def, refs);
+}
+const asAnyOf = (def, refs) => {
+    const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options)
+        .map((x, i) => parseDef(x._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, 'anyOf', `${i}`],
+    }))
+        .filter((x) => !!x && (!refs.strictUnions || (typeof x === 'object' && Object.keys(x).length > 0)));
+    return anyOf.length ? { anyOf } : undefined;
+};
+
+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' || refs.nullableStrategy === 'property') {
+            return {
+                type: primitiveMappings[def.innerType._def.typeName],
+                nullable: true,
+            };
+        }
+        return {
+            type: [primitiveMappings[def.innerType._def.typeName], 'null'],
+        };
+    }
+    if (refs.target === 'openApi3') {
+        const base = parseDef(def.innerType._def, {
+            ...refs,
+            currentPath: [...refs.currentPath],
+        });
+        if (base && '$ref' in base)
+            return { allOf: [base], nullable: true };
+        return base && { ...base, nullable: true };
+    }
+    const base = parseDef(def.innerType._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, 'anyOf', '0'],
+    });
+    return base && { anyOf: [base, { type: 'null' }] };
+}
+
+function parseNumberDef(def, refs) {
+    const res = {
+        type: 'number',
+    };
+    if (!def.checks)
+        return res;
+    for (const check of def.checks) {
+        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;
+        }
+    }
+    return res;
+}
+
+function decideAdditionalProperties(def, refs) {
+    if (refs.removeAdditionalStrategy === 'strict') {
+        return def.catchall._def.typeName === 'ZodNever' ?
+            def.unknownKeys !== 'strict'
+            : parseDef(def.catchall._def, {
+                ...refs,
+                currentPath: [...refs.currentPath, 'additionalProperties'],
+            }) ?? true;
+    }
+    else {
+        return def.catchall._def.typeName === 'ZodNever' ?
+            def.unknownKeys === 'passthrough'
+            : parseDef(def.catchall._def, {
+                ...refs,
+                currentPath: [...refs.currentPath, 'additionalProperties'],
+            }) ?? true;
+    }
+}
+function parseObjectDef(def, refs) {
+    const result = {
+        type: 'object',
+        ...Object.entries(def.shape()).reduce((acc, [propName, propDef]) => {
+            if (propDef === undefined || propDef._def === undefined)
+                return acc;
+            const propertyPath = [...refs.currentPath, 'properties', propName];
+            const parsedDef = parseDef(propDef._def, {
+                ...refs,
+                currentPath: propertyPath,
+                propertyPath,
+            });
+            if (parsedDef === undefined)
+                return acc;
+            if (refs.openaiStrictMode &&
+                propDef.isOptional() &&
+                !propDef.isNullable() &&
+                typeof propDef._def?.defaultValue === 'undefined') {
+                throw new Error(`Zod field at \`${propertyPath.join('/')}\` uses \`.optional()\` without \`.nullable()\` which is not supported by the API. See: https://platform.openai.com/docs/guides/structured-outputs?api-mode=responses#all-fields-must-be-required`);
+            }
+            return {
+                properties: {
+                    ...acc.properties,
+                    [propName]: parsedDef,
+                },
+                required: propDef.isOptional() && !refs.openaiStrictMode ? acc.required : [...acc.required, propName],
+            };
+        }, { properties: {}, required: [] }),
+        additionalProperties: decideAdditionalProperties(def, refs),
+    };
+    if (!result.required.length)
+        delete result.required;
+    return result;
+}
+
+const parseOptionalDef = (def, refs) => {
+    if (refs.propertyPath &&
+        refs.currentPath.slice(0, refs.propertyPath.length).toString() === refs.propertyPath.toString()) {
+        return parseDef(def.innerType._def, { ...refs, currentPath: refs.currentPath });
+    }
+    const innerSchema = parseDef(def.innerType._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, 'anyOf', '1'],
+    });
+    return innerSchema ?
+        {
+            anyOf: [
+                {
+                    not: {},
+                },
+                innerSchema,
+            ],
+        }
+        : {};
+};
+
+const parsePipelineDef = (def, refs) => {
+    if (refs.pipeStrategy === 'input') {
+        return parseDef(def.in._def, refs);
+    }
+    else if (refs.pipeStrategy === 'output') {
+        return parseDef(def.out._def, refs);
+    }
+    const a = parseDef(def.in._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, 'allOf', '0'],
+    });
+    const b = parseDef(def.out._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, 'allOf', a ? '1' : '0'],
+    });
+    return {
+        allOf: [a, b].filter((x) => x !== undefined),
+    };
+};
+
+function parsePromiseDef(def, refs) {
+    return parseDef(def.type._def, refs);
+}
+
+function parseSetDef(def, refs) {
+    const items = parseDef(def.valueType._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, 'items'],
+    });
+    const schema = {
+        type: 'array',
+        uniqueItems: true,
+        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 parseTupleDef(def, refs) {
+    if (def.rest) {
+        return {
+            type: 'array',
+            minItems: def.items.length,
+            items: def.items
+                .map((x, i) => parseDef(x._def, {
+                ...refs,
+                currentPath: [...refs.currentPath, 'items', `${i}`],
+            }))
+                .reduce((acc, x) => (x === undefined ? acc : [...acc, x]), []),
+            additionalItems: parseDef(def.rest._def, {
+                ...refs,
+                currentPath: [...refs.currentPath, 'additionalItems'],
+            }),
+        };
+    }
+    else {
+        return {
+            type: 'array',
+            minItems: def.items.length,
+            maxItems: def.items.length,
+            items: def.items
+                .map((x, i) => parseDef(x._def, {
+                ...refs,
+                currentPath: [...refs.currentPath, 'items', `${i}`],
+            }))
+                .reduce((acc, x) => (x === undefined ? acc : [...acc, x]), []),
+        };
+    }
+}
+
+function parseUndefinedDef() {
+    return {
+        not: {},
+    };
+}
+
+function parseUnknownDef() {
+    return {};
+}
+
+const parseReadonlyDef = (def, refs) => {
+    return parseDef(def.innerType._def, refs);
+};
+
+function parseDef(def, refs, forceResolution = false) {
+    const seenItem = refs.seen.get(def);
+    if (refs.override) {
+        const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
+        if (overrideResult !== ignoreOverride) {
+            return overrideResult;
+        }
+    }
+    if (seenItem && !forceResolution) {
+        const seenSchema = get$ref(seenItem, refs);
+        if (seenSchema !== undefined) {
+            if ('$ref' in seenSchema) {
+                refs.seenRefs.add(seenSchema.$ref);
+            }
+            return seenSchema;
+        }
+    }
+    const newItem = { def, path: refs.currentPath, jsonSchema: undefined };
+    refs.seen.set(def, newItem);
+    const jsonSchema = selectParser(def, def.typeName, refs, forceResolution);
+    if (jsonSchema) {
+        addMeta(def, refs, jsonSchema);
+    }
+    newItem.jsonSchema = jsonSchema;
+    return jsonSchema;
+}
+const get$ref = (item, refs) => {
+    switch (refs.$refStrategy) {
+        case 'root':
+            return { $ref: item.path.join('/') };
+        // this case is needed as OpenAI strict mode doesn't support top-level `$ref`s, i.e.
+        // the top-level schema *must* be `{"type": "object", "properties": {...}}` but if we ever
+        // need to define a `$ref`, relative `$ref`s aren't supported, so we need to extract
+        // the schema to `#/definitions/` and reference that.
+        //
+        // e.g. if we need to reference a schema at
+        // `["#","definitions","contactPerson","properties","person1","properties","name"]`
+        // then we'll extract it out to `contactPerson_properties_person1_properties_name`
+        case 'extract-to-root':
+            const name = item.path.slice(refs.basePath.length + 1).join('_');
+            // we don't need to extract the root schema in this case, as it's already
+            // been added to the definitions
+            if (name !== refs.name && refs.nameStrategy === 'duplicate-ref') {
+                refs.definitions[name] = item.def;
+            }
+            return { $ref: [...refs.basePath, refs.definitionPath, name].join('/') };
+        case 'relative':
+            return { $ref: getRelativePath(refs.currentPath, item.path) };
+        case 'none':
+        case 'seen': {
+            if (item.path.length < refs.currentPath.length &&
+                item.path.every((value, index) => refs.currentPath[index] === value)) {
+                console.warn(`Recursive reference detected at ${refs.currentPath.join('/')}! Defaulting to any`);
+                return {};
+            }
+            return refs.$refStrategy === 'seen' ? {} : undefined;
+        }
+    }
+};
+const getRelativePath = (pathA, pathB) => {
+    let i = 0;
+    for (; i < pathA.length && i < pathB.length; i++) {
+        if (pathA[i] !== pathB[i])
+            break;
+    }
+    return [(pathA.length - i).toString(), ...pathB.slice(i)].join('/');
+};
+const selectParser = (def, typeName, refs, forceResolution) => {
+    switch (typeName) {
+        case ZodFirstPartyTypeKind.ZodString:
+            return parseStringDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodNumber:
+            return parseNumberDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodObject:
+            return parseObjectDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodBigInt:
+            return parseBigintDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodBoolean:
+            return parseBooleanDef();
+        case ZodFirstPartyTypeKind.ZodDate:
+            return parseDateDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodUndefined:
+            return parseUndefinedDef();
+        case ZodFirstPartyTypeKind.ZodNull:
+            return parseNullDef(refs);
+        case ZodFirstPartyTypeKind.ZodArray:
+            return parseArrayDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodUnion:
+        case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+            return parseUnionDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodIntersection:
+            return parseIntersectionDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodTuple:
+            return parseTupleDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodRecord:
+            return parseRecordDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodLiteral:
+            return parseLiteralDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodEnum:
+            return parseEnumDef(def);
+        case ZodFirstPartyTypeKind.ZodNativeEnum:
+            return parseNativeEnumDef(def);
+        case ZodFirstPartyTypeKind.ZodNullable:
+            return parseNullableDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodOptional:
+            return parseOptionalDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodMap:
+            return parseMapDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodSet:
+            return parseSetDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodLazy:
+            return parseDef(def.getter()._def, refs);
+        case ZodFirstPartyTypeKind.ZodPromise:
+            return parsePromiseDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodNaN:
+        case ZodFirstPartyTypeKind.ZodNever:
+            return parseNeverDef();
+        case ZodFirstPartyTypeKind.ZodEffects:
+            return parseEffectsDef(def, refs, forceResolution);
+        case ZodFirstPartyTypeKind.ZodAny:
+            return parseAnyDef();
+        case ZodFirstPartyTypeKind.ZodUnknown:
+            return parseUnknownDef();
+        case ZodFirstPartyTypeKind.ZodDefault:
+            return parseDefaultDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodBranded:
+            return parseBrandedDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodReadonly:
+            return parseReadonlyDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodCatch:
+            return parseCatchDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodPipeline:
+            return parsePipelineDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodFunction:
+        case ZodFirstPartyTypeKind.ZodVoid:
+        case ZodFirstPartyTypeKind.ZodSymbol:
+            return undefined;
+        default:
+            return ((_) => undefined)();
+    }
+};
+const addMeta = (def, refs, jsonSchema) => {
+    if (def.description) {
+        jsonSchema.description = def.description;
+        if (refs.markdownDescription) {
+            jsonSchema.markdownDescription = def.description;
+        }
+    }
+    return jsonSchema;
+};
+
+const zodToJsonSchema = (schema, options) => {
+    const refs = getRefs(options);
+    const name = typeof options === 'string' ? options
+        : options?.nameStrategy === 'title' ? undefined
+            : options?.name;
+    const main = parseDef(schema._def, name === undefined ? refs : ({
+        ...refs,
+        currentPath: [...refs.basePath, refs.definitionPath, name],
+    }), false) ?? {};
+    const title = typeof options === 'object' && options.name !== undefined && options.nameStrategy === 'title' ?
+        options.name
+        : undefined;
+    if (title !== undefined) {
+        main.title = title;
+    }
+    const definitions = (() => {
+        if (isEmptyObj(refs.definitions)) {
+            return undefined;
+        }
+        const definitions = {};
+        const processedDefinitions = new Set();
+        // the call to `parseDef()` here might itself add more entries to `.definitions`
+        // so we need to continually evaluate definitions until we've resolved all of them
+        //
+        // we have a generous iteration limit here to avoid blowing up the stack if there
+        // are any bugs that would otherwise result in us iterating indefinitely
+        for (let i = 0; i < 500; i++) {
+            const newDefinitions = Object.entries(refs.definitions).filter(([key]) => !processedDefinitions.has(key));
+            if (newDefinitions.length === 0)
+                break;
+            for (const [key, schema] of newDefinitions) {
+                definitions[key] =
+                    parseDef(zodDef(schema), { ...refs, currentPath: [...refs.basePath, refs.definitionPath, key] }, true) ?? {};
+                processedDefinitions.add(key);
+            }
+        }
+        return definitions;
+    })();
+    const combined = name === undefined ?
+        definitions ?
+            {
+                ...main,
+                [refs.definitionPath]: definitions,
+            }
+            : main
+        : refs.nameStrategy === 'duplicate-ref' ?
+            {
+                ...main,
+                ...(definitions || refs.seenRefs.size ?
+                    {
+                        [refs.definitionPath]: {
+                            ...definitions,
+                            // only actually duplicate the schema definition if it was ever referenced
+                            // otherwise the duplication is completely pointless
+                            ...(refs.seenRefs.size ? { [name]: main } : undefined),
+                        },
+                    }
+                    : undefined),
+            }
+            : {
+                $ref: [...(refs.$refStrategy === 'relative' ? [] : refs.basePath), refs.definitionPath, name].join('/'),
+                [refs.definitionPath]: {
+                    ...definitions,
+                    [name]: main,
+                },
+            };
+    if (refs.target === 'jsonSchema7') {
+        combined.$schema = 'http://json-schema.org/draft-07/schema#';
+    }
+    else if (refs.target === 'jsonSchema2019-09') {
+        combined.$schema = 'https://json-schema.org/draft/2019-09/schema#';
+    }
+    return combined;
+};
+
+function toStrictJsonSchema(schema) {
+    if (schema.type !== 'object') {
+        throw new Error(`Root schema must have type: 'object' but got type: ${schema.type ? `'${schema.type}'` : 'undefined'}`);
+    }
+    const schemaCopy = structuredClone(schema);
+    return ensureStrictJsonSchema(schemaCopy, [], schemaCopy);
+}
+function isNullable(schema) {
+    if (typeof schema === 'boolean') {
+        return false;
+    }
+    if (schema.type === 'null') {
+        return true;
+    }
+    for (const oneOfVariant of schema.oneOf ?? []) {
+        if (isNullable(oneOfVariant)) {
+            return true;
+        }
+    }
+    for (const allOfVariant of schema.anyOf ?? []) {
+        if (isNullable(allOfVariant)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Mutates the given JSON schema to ensure it conforms to the `strict` standard
+ * that the API expects.
+ */
+function ensureStrictJsonSchema(jsonSchema, path, root) {
+    if (typeof jsonSchema === 'boolean') {
+        throw new TypeError(`Expected object schema but got boolean; path=${path.join('/')}`);
+    }
+    if (!isObject(jsonSchema)) {
+        throw new TypeError(`Expected ${JSON.stringify(jsonSchema)} to be an object; path=${path.join('/')}`);
+    }
+    // Handle $defs (non-standard but sometimes used)
+    const defs = jsonSchema.$defs;
+    if (isObject(defs)) {
+        for (const [defName, defSchema] of Object.entries(defs)) {
+            ensureStrictJsonSchema(defSchema, [...path, '$defs', defName], root);
+        }
+    }
+    // Handle definitions (draft-04 style, deprecated in draft-07 but still used)
+    const definitions = jsonSchema.definitions;
+    if (isObject(definitions)) {
+        for (const [definitionName, definitionSchema] of Object.entries(definitions)) {
+            ensureStrictJsonSchema(definitionSchema, [...path, 'definitions', definitionName], root);
+        }
+    }
+    // Add additionalProperties: false to object types
+    const typ = jsonSchema.type;
+    if (typ === 'object' && !('additionalProperties' in jsonSchema)) {
+        jsonSchema.additionalProperties = false;
+    }
+    const required = jsonSchema.required ?? [];
+    // Handle object properties
+    const properties = jsonSchema.properties;
+    if (isObject(properties)) {
+        for (const [key, value] of Object.entries(properties)) {
+            if (!isNullable(value) && !required.includes(key)) {
+                throw new Error(`Zod field at \`${[...path, 'properties', key].join('/')}\` uses \`.optional()\` without \`.nullable()\` which is not supported by the API. See: https://platform.openai.com/docs/guides/structured-outputs?api-mode=responses#all-fields-must-be-required`);
+            }
+        }
+        jsonSchema.required = Object.keys(properties);
+        jsonSchema.properties = Object.fromEntries(Object.entries(properties).map(([key, propSchema]) => [
+            key,
+            ensureStrictJsonSchema(propSchema, [...path, 'properties', key], root),
+        ]));
+    }
+    // Handle arrays
+    const items = jsonSchema.items;
+    if (isObject(items)) {
+        jsonSchema.items = ensureStrictJsonSchema(items, [...path, 'items'], root);
+    }
+    // Handle unions (anyOf)
+    const anyOf = jsonSchema.anyOf;
+    if (Array.isArray(anyOf)) {
+        jsonSchema.anyOf = anyOf.map((variant, i) => ensureStrictJsonSchema(variant, [...path, 'anyOf', String(i)], root));
+    }
+    // Handle intersections (allOf)
+    const allOf = jsonSchema.allOf;
+    if (Array.isArray(allOf)) {
+        if (allOf.length === 1) {
+            const resolved = ensureStrictJsonSchema(allOf[0], [...path, 'allOf', '0'], root);
+            Object.assign(jsonSchema, resolved);
+            delete jsonSchema.allOf;
+        }
+        else {
+            jsonSchema.allOf = allOf.map((entry, i) => ensureStrictJsonSchema(entry, [...path, 'allOf', String(i)], root));
+        }
+    }
+    // Strip `null` defaults as there's no meaningful distinction
+    if (jsonSchema.default === null) {
+        delete jsonSchema.default;
+    }
+    // Handle $ref with additional properties
+    const ref = jsonSchema.$ref;
+    if (ref && hasMoreThanNKeys(jsonSchema, 1)) {
+        if (typeof ref !== 'string') {
+            throw new TypeError(`Received non-string $ref - ${ref}; path=${path.join('/')}`);
+        }
+        const resolved = resolveRef(root, ref);
+        if (typeof resolved === 'boolean') {
+            throw new Error(`Expected \`$ref: ${ref}\` to resolve to an object schema but got boolean`);
+        }
+        if (!isObject(resolved)) {
+            throw new Error(`Expected \`$ref: ${ref}\` to resolve to an object but got ${JSON.stringify(resolved)}`);
+        }
+        // Properties from the json schema take priority over the ones on the `$ref`
+        Object.assign(jsonSchema, { ...resolved, ...jsonSchema });
+        delete jsonSchema.$ref;
+        // Since the schema expanded from `$ref` might not have `additionalProperties: false` applied,
+        // we call `ensureStrictJsonSchema` again to fix the inlined schema and ensure it's valid.
+        return ensureStrictJsonSchema(jsonSchema, path, root);
+    }
+    return jsonSchema;
+}
+function resolveRef(root, ref) {
+    if (!ref.startsWith('#/')) {
+        throw new Error(`Unexpected $ref format ${JSON.stringify(ref)}; Does not start with #/`);
+    }
+    const pathParts = ref.slice(2).split('/');
+    let resolved = root;
+    for (const key of pathParts) {
+        if (!isObject(resolved)) {
+            throw new Error(`encountered non-object entry while resolving ${ref} - ${JSON.stringify(resolved)}`);
+        }
+        const value = resolved[key];
+        if (value === undefined) {
+            throw new Error(`Key ${key} not found while resolving ${ref}`);
+        }
+        resolved = value;
+    }
+    return resolved;
+}
+function isObject(obj) {
+    return typeof obj === 'object' && obj !== null && !Array.isArray(obj);
+}
+function hasMoreThanNKeys(obj, n) {
+    let i = 0;
+    for (const _ in obj) {
+        i++;
+        if (i > n) {
+            return true;
+        }
+    }
+    return false;
+}
+
+function zodV3ToJsonSchema(schema, options) {
+    return zodToJsonSchema(schema, {
+        openaiStrictMode: true,
+        name: options.name,
+        nameStrategy: 'duplicate-ref',
+        $refStrategy: 'extract-to-root',
+        nullableStrategy: 'property',
+    });
+}
+function zodV4ToJsonSchema(schema) {
+    return toStrictJsonSchema(toJSONSchema(schema, {
+        target: 'draft-7',
+    }));
+}
+function isZodV4(zodObject) {
+    return '_zod' in zodObject;
+}
+function zodTextFormat(zodObject, name, props) {
+    return makeParseableTextFormat({
+        type: 'json_schema',
+        ...props,
+        name,
+        strict: true,
+        schema: isZodV4(zodObject) ? zodV4ToJsonSchema(zodObject) : zodV3ToJsonSchema(zodObject, { name }),
+    }, (content) => zodObject.parse(JSON.parse(content)));
+}
+
+// llm-openai-config.ts
+const DEFAULT_MODEL = 'gpt-4.1-mini';
+const GPT_5_4_HIGH_CONTEXT_THRESHOLD_TOKENS = 272_000;
+const GPT_5_4_HIGH_CONTEXT_INPUT_MULTIPLIER = 2;
+const GPT_5_4_HIGH_CONTEXT_OUTPUT_MULTIPLIER = 1.5;
+/** Token costs in USD per 1M tokens. Last updated Mar 2026. */
+const openAiModelCosts = {
+    'gpt-4o': {
+        inputCost: 2.5 / 1_000_000,
+        cacheHitCost: 1.25 / 1_000_000,
+        outputCost: 10 / 1_000_000,
+    },
+    'gpt-4o-mini': {
+        inputCost: 0.15 / 1_000_000,
+        cacheHitCost: 0.075 / 1_000_000,
+        outputCost: 0.6 / 1_000_000,
+    },
+    'o1-mini': {
+        inputCost: 1.1 / 1_000_000,
+        cacheHitCost: 0.55 / 1_000_000,
+        outputCost: 4.4 / 1_000_000,
+    },
+    'o1': {
+        inputCost: 15 / 1_000_000,
+        cacheHitCost: 7.5 / 1_000_000,
+        outputCost: 60 / 1_000_000,
+    },
+    'o3-mini': {
+        inputCost: 1.1 / 1_000_000,
+        cacheHitCost: 0.55 / 1_000_000,
+        outputCost: 4.4 / 1_000_000,
+    },
+    'o3': {
+        inputCost: 2 / 1_000_000,
+        cacheHitCost: 0.5 / 1_000_000,
+        outputCost: 8 / 1_000_000,
+    },
+    'gpt-4.1': {
+        inputCost: 2 / 1_000_000,
+        cacheHitCost: 0.5 / 1_000_000,
+        outputCost: 8 / 1_000_000,
+    },
+    'gpt-4.1-mini': {
+        inputCost: 0.4 / 1_000_000,
+        cacheHitCost: 0.1 / 1_000_000,
+        outputCost: 1.6 / 1_000_000,
+    },
+    'gpt-4.1-nano': {
+        inputCost: 0.1 / 1_000_000,
+        cacheHitCost: 0.025 / 1_000_000,
+        outputCost: 0.4 / 1_000_000,
+    },
+    'gpt-5': {
+        inputCost: 1.25 / 1_000_000,
+        cacheHitCost: 0.125 / 1_000_000,
+        outputCost: 10 / 1_000_000,
+    },
+    'gpt-5-mini': {
+        inputCost: 0.25 / 1_000_000,
+        cacheHitCost: 0.025 / 1_000_000,
+        outputCost: 2 / 1_000_000,
+    },
+    'gpt-5-nano': {
+        inputCost: 0.05 / 1_000_000,
+        cacheHitCost: 0.005 / 1_000_000,
+        outputCost: 0.4 / 1_000_000,
+    },
+    'gpt-5.1': {
+        inputCost: 1.25 / 1_000_000,
+        cacheHitCost: 0.125 / 1_000_000,
+        outputCost: 10 / 1_000_000,
+    },
+    'gpt-5.4': {
+        inputCost: 2.5 / 1_000_000,
+        cacheHitCost: 0.25 / 1_000_000,
+        outputCost: 15 / 1_000_000,
+    },
+    'gpt-5.4-pro': {
+        inputCost: 30 / 1_000_000,
+        outputCost: 180 / 1_000_000,
+    },
+    'gpt-5.2': {
+        inputCost: 1.75 / 1_000_000,
+        cacheHitCost: 0.175 / 1_000_000,
+        outputCost: 14 / 1_000_000,
+    },
+    'gpt-5.2-pro': {
+        inputCost: 21 / 1_000_000,
+        outputCost: 168 / 1_000_000,
+    },
+    'gpt-5.1-codex': {
+        inputCost: 1.25 / 1_000_000,
+        cacheHitCost: 0.125 / 1_000_000,
+        outputCost: 10 / 1_000_000,
+    },
+    'gpt-5.1-codex-max': {
+        inputCost: 1.25 / 1_000_000,
+        cacheHitCost: 0.125 / 1_000_000,
+        outputCost: 10 / 1_000_000,
+    },
+    'o4-mini': {
+        inputCost: 1.1 / 1_000_000,
+        cacheHitCost: 0.275 / 1_000_000,
+        outputCost: 4.4 / 1_000_000,
+    },
+};
+const deepseekModelCosts = {
+    'deepseek-chat': {
+        inputCost: 0.27 / 1_000_000, // $0.27 per 1M tokens (Cache miss price)
+        cacheHitCost: 0.07 / 1_000_000, // $0.07 per 1M tokens (Cache hit price)
+        outputCost: 1.1 / 1_000_000, // $1.10 per 1M tokens
+    },
+    'deepseek-reasoner': {
+        inputCost: 0.55 / 1_000_000, // $0.55 per 1M tokens (Cache miss price)
+        cacheHitCost: 0.14 / 1_000_000, // $0.14 per 1M tokens (Cache hit price)
+        outputCost: 2.19 / 1_000_000, // $2.19 per 1M tokens
+    },
+};
+function shouldUseGPT54HighContextPricing(model, inputTokens) {
+    return (model === 'gpt-5.4' || model === 'gpt-5.4-pro') && inputTokens > GPT_5_4_HIGH_CONTEXT_THRESHOLD_TOKENS;
+}
+/** Image generation costs in USD per image. Based on OpenAI pricing as of Feb 2025. */
+const openAiImageCosts = {
+    'gpt-image-1': 0.0075, // $0.0075 per image for gpt-image-1
+    'gpt-image-1.5': 0.0075, // Assumes parity pricing with gpt-image-1 until OpenAI publishes updated rates
+};
+/**
+ * Calculates the cost of generating images using OpenAI's Images API.
+ *
+ * @param model The image generation model name.
+ * @param imageCount The number of images generated.
+ * @returns The cost of generating the images in USD.
+ */
+function calculateImageCost(model, imageCount) {
+    if (typeof model !== 'string' || typeof imageCount !== 'number' || imageCount <= 0) {
+        return 0;
+    }
+    const costPerImage = openAiImageCosts[model];
+    if (!costPerImage)
+        return 0;
+    return imageCount * costPerImage;
+}
+/**
+ * Calculates the cost of calling a language model in USD based on the provider and model, tokens, and given costs per 1M tokens.
+ *
+ * @param provider The provider of the language model. Supported providers are 'openai' and 'deepseek'.
+ * @param model The name of the language model. Supported models are listed in the `openAiModelCosts` and `deepseekModelCosts` objects.
+ * @param inputTokens The number of input tokens passed to the language model.
+ * @param outputTokens The number of output tokens generated by the language model.
+ * @param reasoningTokens The number of output tokens generated by the language model for reasoning.
+ * @param cacheHitTokens The number of input tokens billed at cached-input rates.
+ * @returns The cost of calling the language model in USD.
+ */
+function calculateCost(provider, model, inputTokens, outputTokens, reasoningTokens, cacheHitTokens) {
+    if (typeof provider !== 'string' ||
+        typeof model !== 'string' ||
+        typeof inputTokens !== 'number' ||
+        typeof outputTokens !== 'number' ||
+        (reasoningTokens !== undefined && typeof reasoningTokens !== 'number') ||
+        (cacheHitTokens !== undefined && typeof cacheHitTokens !== 'number')) {
+        return 0;
+    }
+    const modelCosts = provider === 'deepseek' ? deepseekModelCosts[model] : openAiModelCosts[model];
+    if (!modelCosts)
+        return 0;
+    const boundedCacheHitTokens = Math.min(Math.max(cacheHitTokens || 0, 0), inputTokens);
+    let inputCost = inputTokens * modelCosts.inputCost;
+    if (typeof modelCosts.cacheHitCost === 'number' && boundedCacheHitTokens > 0) {
+        inputCost = boundedCacheHitTokens * modelCosts.cacheHitCost + (inputTokens - boundedCacheHitTokens) * modelCosts.inputCost;
+    }
+    let outputCost = outputTokens * modelCosts.outputCost;
+    let reasoningCost = (reasoningTokens || 0) * modelCosts.outputCost;
+    if (provider === 'openai' && shouldUseGPT54HighContextPricing(model, inputTokens)) {
+        inputCost *= GPT_5_4_HIGH_CONTEXT_INPUT_MULTIPLIER;
+        outputCost *= GPT_5_4_HIGH_CONTEXT_OUTPUT_MULTIPLIER;
+        reasoningCost *= GPT_5_4_HIGH_CONTEXT_OUTPUT_MULTIPLIER;
+    }
+    return inputCost + outputCost + reasoningCost;
+}
+
+/**
+ * Fix a broken JSON string by attempting to extract and parse valid JSON content. This function is very lenient and will attempt to fix many types of JSON errors, including unbalanced brackets, missing or extra commas, improperly escaped $ signs, unquoted strings, trailing commas, missing closing brackets or braces, etc.
+ * @param {string} jsonStr - The broken JSON string to fix
+ * @returns {JsonValue} - The parsed JSON value
+ */
+function fixBrokenJson(jsonStr) {
+    // Pre-process: Fix improperly escaped $ signs
+    jsonStr = jsonStr.replace(/\\\$/g, '$');
+    let index = 0;
+    function parse() {
+        const results = [];
+        while (index < jsonStr.length) {
+            skipWhitespace();
+            const value = parseValue();
+            if (value !== undefined) {
+                results.push(value);
+            }
+            else {
+                index++; // Skip invalid character
+            }
+        }
+        return results.length === 1 ? results[0] : results;
+    }
+    function parseValue() {
+        skipWhitespace();
+        const char = getChar();
+        if (!char)
+            return undefined;
+        if (char === '{')
+            return parseObject();
+        if (char === '[')
+            return parseArray();
+        if (char === '"' || char === "'")
+            return parseString();
+        if (char === 't' && jsonStr.slice(index, index + 4).toLowerCase() === 'true') {
+            index += 4;
+            return true;
+        }
+        if (char === 'f' && jsonStr.slice(index, index + 5).toLowerCase() === 'false') {
+            index += 5;
+            return false;
+        }
+        if (char === 'n' && jsonStr.slice(index, index + 4).toLowerCase() === 'null') {
+            index += 4;
+            return null;
+        }
+        if (/[a-zA-Z]/.test(char))
+            return parseString(); // Unquoted string
+        if (char === '-' || char === '.' || /\d/.test(char))
+            return parseNumber();
+        return undefined; // Unknown character
+    }
+    function parseObject() {
+        const obj = {};
+        index++; // Skip opening brace
+        skipWhitespace();
+        while (index < jsonStr.length && getChar() !== '}') {
+            skipWhitespace();
+            const key = parseString();
+            if (key === undefined) {
+                console.warn(`Expected key at position ${index}`);
+                index++;
+                continue;
+            }
+            skipWhitespace();
+            if (getChar() === ':') {
+                index++; // Skip colon
+            }
+            else {
+                console.warn(`Missing colon after key "${key}" at position ${index}`);
+            }
+            skipWhitespace();
+            const value = parseValue();
+            if (value === undefined) {
+                console.warn(`Expected value for key "${key}" at position ${index}`);
+                index++;
+                continue;
+            }
+            obj[key] = value;
+            skipWhitespace();
+            if (getChar() === ',') {
+                index++; // Skip comma
+            }
+            else {
+                break;
+            }
+            skipWhitespace();
+        }
+        if (getChar() === '}') {
+            index++; // Skip closing brace
         }
         else {
             // Add a closing brace if it's missing
@@ -9360,6 +12188,8 @@ const isSupportedModel = (model) => {
         'gpt-5-mini',
         'gpt-5-nano',
         'gpt-5.1',
+        'gpt-5.4',
+        'gpt-5.4-pro',
         'gpt-5.2',
         'gpt-5.2-pro',
         'gpt-5.1-codex',
@@ -9386,6 +12216,8 @@ function supportsTemperature(model) {
         'gpt-5-mini',
         'gpt-5-nano',
         'gpt-5.1',
+        'gpt-5.4',
+        'gpt-5.4-pro',
         'gpt-5.2',
         'gpt-5.2-pro',
         'gpt-5.1-codex',
@@ -9413,6 +12245,8 @@ function isGPT5Model(model) {
         'gpt-5-mini',
         'gpt-5-nano',
         'gpt-5.1',
+        'gpt-5.4',
+        'gpt-5.4-pro',
         'gpt-5.2',
         'gpt-5.2-pro',
         'gpt-5.1-codex',
@@ -9420,6 +12254,38 @@ function isGPT5Model(model) {
     ];
     return gpt5Models.includes(model);
 }
+function supportsStructuredOutputs(model) {
+    return normalizeModelName(model) !== 'gpt-5.4-pro';
+}
+function supportsDistillation(model) {
+    return normalizeModelName(model) !== 'gpt-5.4-pro';
+}
+function isZodSchema(schema) {
+    return typeof schema === 'object' && schema !== null && 'safeParse' in schema;
+}
+function buildJsonSchemaFormat(schema, schemaName, schemaDescription, schemaStrict) {
+    if (isZodSchema(schema)) {
+        const zodFormat = zodTextFormat(schema, schemaName, schemaDescription
+            ? {
+                description: schemaDescription,
+            }
+            : undefined);
+        return {
+            type: 'json_schema',
+            name: zodFormat.name,
+            schema: zodFormat.schema,
+            ...(zodFormat.description ? { description: zodFormat.description } : {}),
+            ...(schemaStrict !== undefined ? { strict: schemaStrict } : { strict: zodFormat.strict }),
+        };
+    }
+    return {
+        type: 'json_schema',
+        name: schemaName,
+        schema,
+        ...(schemaDescription ? { description: schemaDescription } : {}),
+        ...(schemaStrict !== undefined ? { strict: schemaStrict } : {}),
+    };
+}
 /**
  * Makes a call to OpenAI's Responses API for more advanced use cases with built-in tools.
  *
@@ -9462,8 +12328,15 @@ const makeResponsesAPICall = async (input, options = {}) => {
         input,
         ...cleanOptions,
     };
+    if (requestBody.text?.format?.type === 'json_schema' && !supportsStructuredOutputs(normalizedModel)) {
+        throw new Error(`Model ${normalizedModel} does not support structured outputs`);
+    }
+    if (requestBody.store && !supportsDistillation(normalizedModel)) {
+        throw new Error(`Model ${normalizedModel} does not support distillation`);
+    }
     // Make the API call to the Responses endpoint
     const response = await openai.responses.create(requestBody);
+    const cacheHitTokens = response.usage?.input_tokens_details?.cached_tokens || 0;
     // Extract tool calls from the output
     const toolCalls = response.output
         ?.filter((item) => item.type === 'function_call')
@@ -9503,7 +12376,8 @@ const makeResponsesAPICall = async (input, options = {}) => {
                 reasoning_tokens: response.usage?.output_tokens_details?.reasoning_tokens || 0,
                 provider: 'openai',
                 model: normalizedModel,
-                cost: calculateCost('openai', normalizedModel, response.usage?.input_tokens || 0, response.usage?.output_tokens || 0, response.usage?.output_tokens_details?.reasoning_tokens || 0),
+                cache_hit_tokens: cacheHitTokens,
+                cost: calculateCost('openai', normalizedModel, response.usage?.input_tokens || 0, response.usage?.output_tokens || 0, response.usage?.output_tokens_details?.reasoning_tokens || 0, cacheHitTokens),
             },
             tool_calls: toolCalls,
             ...(codeInterpreterOutputs ? { code_interpreter_outputs: codeInterpreterOutputs } : {}),
@@ -9519,9 +12393,13 @@ const makeResponsesAPICall = async (input, options = {}) => {
         .join('') || '';
     // Determine the format for parsing the response
     let parsingFormat = 'text';
-    if (requestBody.text?.format?.type === 'json_object') {
+    const requestedFormat = requestBody.text?.format;
+    if (requestedFormat?.type === 'json_object') {
         parsingFormat = 'json';
     }
+    else if (requestedFormat?.type === 'json_schema') {
+        parsingFormat = requestedFormat;
+    }
     // Handle regular responses
     const parsedResponse = await parseResponse(textContent, parsingFormat);
     if (parsedResponse === null) {
@@ -9535,7 +12413,8 @@ const makeResponsesAPICall = async (input, options = {}) => {
             reasoning_tokens: response.usage?.output_tokens_details?.reasoning_tokens || 0,
             provider: 'openai',
             model: normalizedModel,
-            cost: calculateCost('openai', normalizedModel, response.usage?.input_tokens || 0, response.usage?.output_tokens || 0, response.usage?.output_tokens_details?.reasoning_tokens || 0),
+            cache_hit_tokens: cacheHitTokens,
+            cost: calculateCost('openai', normalizedModel, response.usage?.input_tokens || 0, response.usage?.output_tokens || 0, response.usage?.output_tokens_details?.reasoning_tokens || 0, cacheHitTokens),
         },
         tool_calls: toolCalls,
         ...(codeInterpreterOutputs ? { code_interpreter_outputs: codeInterpreterOutputs } : {}),
@@ -9558,7 +12437,7 @@ const makeResponsesAPICall = async (input, options = {}) => {
  * });
  */
 async function makeLLMCall(input, options = {}) {
-    const { apiKey, model = DEFAULT_MODEL, responseFormat = 'text', tools, useCodeInterpreter = false, useWebSearch = false, imageBase64, imageDetail = 'high', context, } = options;
+    const { apiKey, model = DEFAULT_MODEL, responseFormat = 'text', schema, schemaName = 'response', schemaDescription, schemaStrict, tools, useCodeInterpreter = false, useWebSearch = false, imageBase64, imageDetail = 'high', context, } = options;
     // Validate model
     const normalizedModel = normalizeModelName(model);
     if (!isSupportedModel(normalizedModel)) {
@@ -9636,9 +12515,17 @@ async function makeLLMCall(input, options = {}) {
         responsesOptions.temperature = 0.2;
     }
     // Configure response format
-    if (responseFormat === 'json') {
+    if (schema) {
+        responsesOptions.text = {
+            format: buildJsonSchemaFormat(schema, schemaName, schemaDescription, schemaStrict),
+        };
+    }
+    else if (responseFormat === 'json') {
         responsesOptions.text = { format: { type: 'json_object' } };
     }
+    else if (typeof responseFormat === 'object' && responseFormat.type === 'json_schema') {
+        responsesOptions.text = { format: responseFormat };
+    }
     // Configure built-in tools
     if (useCodeInterpreter) {
         responsesOptions.tools = [{ type: 'code_interpreter', container: { type: 'auto' } }];
@@ -9667,6 +12554,8 @@ const MULTIMODAL_VISION_MODELS = new Set([
     'gpt-5-mini',
     'gpt-5-nano',
     'gpt-5.1',
+    'gpt-5.4',
+    'gpt-5.4-pro',
     'gpt-5.2',
     'gpt-5.2-pro',
     'gpt-5.1-codex',