freestyle-sandboxes 0.0.97 → 0.1.0

package/dist/index-DuOpIaWc.cjs

@@ -1,3068 +0,0 @@
-'use strict';
-
-var index = require('./index.cjs');
-var zod = require('zod');
-
-var marker = "vercel.ai.error";
-var symbol = Symbol.for(marker);
-var _a;
-var _AISDKError = class _AISDKError2 extends Error {
-  /**
-   * Creates an AI SDK Error.
-   *
-   * @param {Object} params - The parameters for creating the error.
-   * @param {string} params.name - The name of the error.
-   * @param {string} params.message - The error message.
-   * @param {unknown} [params.cause] - The underlying cause of the error.
-   */
-  constructor({
-    name: name14,
-    message,
-    cause
-  }) {
-    super(message);
-    this[_a] = true;
-    this.name = name14;
-    this.cause = cause;
-  }
-  /**
-   * Checks if the given error is an AI SDK Error.
-   * @param {unknown} error - The error to check.
-   * @returns {boolean} True if the error is an AI SDK Error, false otherwise.
-   */
-  static isInstance(error) {
-    return _AISDKError2.hasMarker(error, marker);
-  }
-  static hasMarker(error, marker15) {
-    const markerSymbol = Symbol.for(marker15);
-    return error != null && typeof error === "object" && markerSymbol in error && typeof error[markerSymbol] === "boolean" && error[markerSymbol] === true;
-  }
-};
-_a = symbol;
-var AISDKError = _AISDKError;
-function getErrorMessage(error) {
-  if (error == null) {
-    return "unknown error";
-  }
-  if (typeof error === "string") {
-    return error;
-  }
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return JSON.stringify(error);
-}
-var name3 = "AI_InvalidArgumentError";
-var marker4$1 = `vercel.ai.error.${name3}`;
-var symbol4$1 = Symbol.for(marker4$1);
-var _a4$1;
-var InvalidArgumentError = class extends AISDKError {
-  constructor({
-    message,
-    cause,
-    argument
-  }) {
-    super({ name: name3, message, cause });
-    this[_a4$1] = true;
-    this.argument = argument;
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker4$1);
-  }
-};
-_a4$1 = symbol4$1;
-var name6 = "AI_JSONParseError";
-var marker7 = `vercel.ai.error.${name6}`;
-var symbol7 = Symbol.for(marker7);
-var _a7;
-var JSONParseError = class extends AISDKError {
-  constructor({ text, cause }) {
-    super({
-      name: name6,
-      message: `JSON parsing failed: Text: ${text}.
-Error message: ${getErrorMessage(cause)}`,
-      cause
-    });
-    this[_a7] = true;
-    this.text = text;
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker7);
-  }
-};
-_a7 = symbol7;
-var name12 = "AI_TypeValidationError";
-var marker13 = `vercel.ai.error.${name12}`;
-var symbol13 = Symbol.for(marker13);
-var _a13;
-var _TypeValidationError = class _TypeValidationError2 extends AISDKError {
-  constructor({ value, cause }) {
-    super({
-      name: name12,
-      message: `Type validation failed: Value: ${JSON.stringify(value)}.
-Error message: ${getErrorMessage(cause)}`,
-      cause
-    });
-    this[_a13] = true;
-    this.value = value;
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker13);
-  }
-  /**
-   * Wraps an error into a TypeValidationError.
-   * If the cause is already a TypeValidationError with the same value, it returns the cause.
-   * Otherwise, it creates a new TypeValidationError.
-   *
-   * @param {Object} params - The parameters for wrapping the error.
-   * @param {unknown} params.value - The value that failed validation.
-   * @param {unknown} params.cause - The original error or cause of the validation failure.
-   * @returns {TypeValidationError} A TypeValidationError instance.
-   */
-  static wrap({
-    value,
-    cause
-  }) {
-    return _TypeValidationError2.isInstance(cause) && cause.value === value ? cause : new _TypeValidationError2({ value, cause });
-  }
-};
-_a13 = symbol13;
-var TypeValidationError = _TypeValidationError;
-
-let customAlphabet = (alphabet, defaultSize = 21) => {
-  return (size = defaultSize) => {
-    let id = "";
-    let i = size | 0;
-    while (i--) {
-      id += alphabet[Math.random() * alphabet.length | 0];
-    }
-    return id;
-  };
-};
-
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-var secureJsonParse = {exports: {}};
-
-var hasRequiredSecureJsonParse;
-
-function requireSecureJsonParse () {
-	if (hasRequiredSecureJsonParse) return secureJsonParse.exports;
-	hasRequiredSecureJsonParse = 1;
-	const hasBuffer = typeof Buffer !== "undefined";
-	const suspectProtoRx = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
-	const suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
-	function _parse(text, reviver, options) {
-	  if (options == null) {
-	    if (reviver !== null && typeof reviver === "object") {
-	      options = reviver;
-	      reviver = void 0;
-	    }
-	  }
-	  if (hasBuffer && Buffer.isBuffer(text)) {
-	    text = text.toString();
-	  }
-	  if (text && text.charCodeAt(0) === 65279) {
-	    text = text.slice(1);
-	  }
-	  const obj = JSON.parse(text, reviver);
-	  if (obj === null || typeof obj !== "object") {
-	    return obj;
-	  }
-	  const protoAction = options && options.protoAction || "error";
-	  const constructorAction = options && options.constructorAction || "error";
-	  if (protoAction === "ignore" && constructorAction === "ignore") {
-	    return obj;
-	  }
-	  if (protoAction !== "ignore" && constructorAction !== "ignore") {
-	    if (suspectProtoRx.test(text) === false && suspectConstructorRx.test(text) === false) {
-	      return obj;
-	    }
-	  } else if (protoAction !== "ignore" && constructorAction === "ignore") {
-	    if (suspectProtoRx.test(text) === false) {
-	      return obj;
-	    }
-	  } else {
-	    if (suspectConstructorRx.test(text) === false) {
-	      return obj;
-	    }
-	  }
-	  return filter(obj, { protoAction, constructorAction, safe: options && options.safe });
-	}
-	function filter(obj, { protoAction = "error", constructorAction = "error", safe } = {}) {
-	  let next = [obj];
-	  while (next.length) {
-	    const nodes = next;
-	    next = [];
-	    for (const node of nodes) {
-	      if (protoAction !== "ignore" && Object.prototype.hasOwnProperty.call(node, "__proto__")) {
-	        if (safe === true) {
-	          return null;
-	        } else if (protoAction === "error") {
-	          throw new SyntaxError("Object contains forbidden prototype property");
-	        }
-	        delete node.__proto__;
-	      }
-	      if (constructorAction !== "ignore" && Object.prototype.hasOwnProperty.call(node, "constructor") && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
-	        if (safe === true) {
-	          return null;
-	        } else if (constructorAction === "error") {
-	          throw new SyntaxError("Object contains forbidden prototype property");
-	        }
-	        delete node.constructor;
-	      }
-	      for (const key in node) {
-	        const value = node[key];
-	        if (value && typeof value === "object") {
-	          next.push(value);
-	        }
-	      }
-	    }
-	  }
-	  return obj;
-	}
-	function parse(text, reviver, options) {
-	  const stackTraceLimit = Error.stackTraceLimit;
-	  Error.stackTraceLimit = 0;
-	  try {
-	    return _parse(text, reviver, options);
-	  } finally {
-	    Error.stackTraceLimit = stackTraceLimit;
-	  }
-	}
-	function safeParse(text, reviver) {
-	  const stackTraceLimit = Error.stackTraceLimit;
-	  Error.stackTraceLimit = 0;
-	  try {
-	    return _parse(text, reviver, { safe: true });
-	  } catch (_e) {
-	    return null;
-	  } finally {
-	    Error.stackTraceLimit = stackTraceLimit;
-	  }
-	}
-	secureJsonParse.exports = parse;
-	secureJsonParse.exports.default = parse;
-	secureJsonParse.exports.parse = parse;
-	secureJsonParse.exports.safeParse = safeParse;
-	secureJsonParse.exports.scan = filter;
-	return secureJsonParse.exports;
-}
-
-var secureJsonParseExports = requireSecureJsonParse();
-var SecureJSON = /*@__PURE__*/getDefaultExportFromCjs(secureJsonParseExports);
-
-function convertAsyncIteratorToReadableStream(iterator) {
-  return new ReadableStream({
-    /**
-     * Called when the consumer wants to pull more data from the stream.
-     *
-     * @param {ReadableStreamDefaultController<T>} controller - The controller to enqueue data into the stream.
-     * @returns {Promise<void>}
-     */
-    async pull(controller) {
-      try {
-        const { value, done } = await iterator.next();
-        if (done) {
-          controller.close();
-        } else {
-          controller.enqueue(value);
-        }
-      } catch (error) {
-        controller.error(error);
-      }
-    },
-    /**
-     * Called when the consumer cancels the stream.
-     */
-    cancel() {
-    }
-  });
-}
-var createIdGenerator = ({
-  prefix,
-  size: defaultSize = 16,
-  alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
-  separator = "-"
-} = {}) => {
-  const generator = customAlphabet(alphabet, defaultSize);
-  if (prefix == null) {
-    return generator;
-  }
-  if (alphabet.includes(separator)) {
-    throw new InvalidArgumentError({
-      argument: "separator",
-      message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
-    });
-  }
-  return (size) => `${prefix}${separator}${generator(size)}`;
-};
-createIdGenerator();
-var validatorSymbol = Symbol.for("vercel.ai.validator");
-function validator(validate) {
-  return { [validatorSymbol]: true, validate };
-}
-function isValidator(value) {
-  return typeof value === "object" && value !== null && validatorSymbol in value && value[validatorSymbol] === true && "validate" in value;
-}
-function asValidator(value) {
-  return isValidator(value) ? value : zodValidator(value);
-}
-function zodValidator(zodSchema) {
-  return validator((value) => {
-    const result = zodSchema.safeParse(value);
-    return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
-  });
-}
-function safeValidateTypes({
-  value,
-  schema
-}) {
-  const validator2 = asValidator(schema);
-  try {
-    if (validator2.validate == null) {
-      return { success: true, value };
-    }
-    const result = validator2.validate(value);
-    if (result.success) {
-      return result;
-    }
-    return {
-      success: false,
-      error: TypeValidationError.wrap({ value, cause: result.error })
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: TypeValidationError.wrap({ value, cause: error })
-    };
-  }
-}
-function safeParseJSON({
-  text,
-  schema
-}) {
-  try {
-    const value = SecureJSON.parse(text);
-    if (schema == null) {
-      return { success: true, value, rawValue: value };
-    }
-    const validationResult = safeValidateTypes({ value, schema });
-    return validationResult.success ? { ...validationResult, rawValue: value } : validationResult;
-  } catch (error) {
-    return {
-      success: false,
-      error: JSONParseError.isInstance(error) ? error : new JSONParseError({ text, cause: error })
-    };
-  }
-}
-
-const ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
-const defaultOptions = {
-  name: void 0,
-  $refStrategy: "root",
-  basePath: ["#"],
-  effectStrategy: "input",
-  pipeStrategy: "all",
-  dateStrategy: "format:date-time",
-  mapStrategy: "entries",
-  removeAdditionalStrategy: "passthrough",
-  allowedAdditionalProperties: true,
-  rejectedAdditionalProperties: false,
-  definitionPath: "definitions",
-  target: "jsonSchema7",
-  strictUnions: false,
-  definitions: {},
-  errorMessages: false,
-  markdownDescription: false,
-  patternStrategy: "escape",
-  applyRegexFlags: false,
-  emailStrategy: "format:email",
-  base64Strategy: "contentEncoding:base64",
-  nameStrategy: "ref"
-};
-const getDefaultOptions = (options) => typeof options === "string" ? {
-  ...defaultOptions,
-  name: options
-} : {
-  ...defaultOptions,
-  ...options
-};
-
-const getRefs = (options) => {
-  const _options = getDefaultOptions(options);
-  const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
-  return {
-    ..._options,
-    currentPath,
-    propertyPath: void 0,
-    seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [
-      def._def,
-      {
-        def: def._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: void 0
-      }
-    ]))
-  };
-};
-
-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);
-}
-
-function parseAnyDef() {
-  return {};
-}
-
-function parseArrayDef(def, refs) {
-  const res = {
-    type: "array"
-  };
-  if (def.type?._def && def.type?._def?.typeName !== zod.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) {
-  return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : {};
-}
-
-function parseEnumDef(def) {
-  return {
-    type: "string",
-    enum: Array.from(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 } : void 0;
-  const mergedAllOf = [];
-  allOf.forEach((schema) => {
-    if (isJsonSchema7AllOfType(schema)) {
-      mergedAllOf.push(...schema.allOf);
-      if (schema.unevaluatedProperties === void 0) {
-        unevaluatedProperties = void 0;
-      }
-    } else {
-      let nestedSchema = schema;
-      if ("additionalProperties" in schema && schema.additionalProperties === false) {
-        const { additionalProperties, ...rest } = schema;
-        nestedSchema = rest;
-      } else {
-        unevaluatedProperties = void 0;
-      }
-      mergedAllOf.push(nestedSchema);
-    }
-  });
-  return mergedAllOf.length ? {
-    allOf: mergedAllOf,
-    ...unevaluatedProperties
-  } : void 0;
-}
-
-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 = void 0;
-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 === void 0) {
-      emojiRegex = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
-    }
-    return emojiRegex;
-  },
-  /**
-   * Unused
-   */
-  uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
-  /**
-   * Unused
-   */
-  ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
-  ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
-  /**
-   * Unused
-   */
-  ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
-  ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
-  base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
-  base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
-  nanoid: /^[a-zA-Z0-9_-]{21}$/,
-  jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
-};
-function parseStringDef(def, refs) {
-  const res = {
-    type: "string"
-  };
-  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(`^${escapeLiteralCheckValue(check.value, refs)}`), check.message, refs);
-          break;
-        case "endsWith":
-          addPattern(res, RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`), check.message, refs);
-          break;
-        case "datetime":
-          addFormat(res, "date-time", check.message, refs);
-          break;
-        case "date":
-          addFormat(res, "date", check.message, refs);
-          break;
-        case "time":
-          addFormat(res, "time", check.message, refs);
-          break;
-        case "duration":
-          addFormat(res, "duration", check.message, refs);
-          break;
-        case "length":
-          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
-          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
-          break;
-        case "includes": {
-          addPattern(res, RegExp(escapeLiteralCheckValue(check.value, refs)), check.message, refs);
-          break;
-        }
-        case "ip": {
-          if (check.version !== "v6") {
-            addFormat(res, "ipv4", check.message, refs);
-          }
-          if (check.version !== "v4") {
-            addFormat(res, "ipv6", check.message, refs);
-          }
-          break;
-        }
-        case "base64url":
-          addPattern(res, zodPatterns.base64url, check.message, refs);
-          break;
-        case "jwt":
-          addPattern(res, zodPatterns.jwt, check.message, refs);
-          break;
-        case "cidr": {
-          if (check.version !== "v6") {
-            addPattern(res, zodPatterns.ipv4Cidr, check.message, refs);
-          }
-          if (check.version !== "v4") {
-            addPattern(res, zodPatterns.ipv6Cidr, check.message, refs);
-          }
-          break;
-        }
-        case "emoji":
-          addPattern(res, zodPatterns.emoji(), check.message, refs);
-          break;
-        case "ulid": {
-          addPattern(res, zodPatterns.ulid, check.message, refs);
-          break;
-        }
-        case "base64": {
-          switch (refs.base64Strategy) {
-            case "format:binary": {
-              addFormat(res, "binary", check.message, refs);
-              break;
-            }
-            case "contentEncoding:base64": {
-              setResponseValueAndErrors(res, "contentEncoding", "base64", check.message, refs);
-              break;
-            }
-            case "pattern:zod": {
-              addPattern(res, zodPatterns.base64, check.message, refs);
-              break;
-            }
-          }
-          break;
-        }
-        case "nanoid": {
-          addPattern(res, zodPatterns.nanoid, check.message, refs);
-        }
-      }
-    }
-  }
-  return res;
-}
-function escapeLiteralCheckValue(literal, refs) {
-  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal;
-}
-const ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
-function escapeNonAlphaNumeric(source) {
-  let result = "";
-  for (let i = 0; i < source.length; i++) {
-    if (!ALPHA_NUMERIC.has(source[i])) {
-      result += "\\";
-    }
-    result += source[i];
-  }
-  return result;
-}
-function 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);
-  }
-}
-function 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: stringifyRegExpWithFlags(regex, refs),
-      ...message && refs.errorMessages && { errorMessage: { pattern: message } }
-    });
-  } else {
-    setResponseValueAndErrors(schema, "pattern", stringifyRegExpWithFlags(regex, refs), message, refs);
-  }
-}
-function stringifyRegExpWithFlags(regex, refs) {
-  if (!refs.applyRegexFlags || !regex.flags) {
-    return regex.source;
-  }
-  const flags = {
-    i: regex.flags.includes("i"),
-    m: regex.flags.includes("m"),
-    s: regex.flags.includes("s")
-    // `.` matches newlines
-  };
-  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
-]))`;
-        continue;
-      } else if (source[i] === "$") {
-        pattern += `($|(?=[\r
-]))`;
-        continue;
-      }
-    }
-    if (flags.s && source[i] === ".") {
-      pattern += inCharGroup ? `${source[i]}\r
-` : `[${source[i]}\r
-]`;
-      continue;
-    }
-    pattern += source[i];
-    if (source[i] === "\\") {
-      isEscaped = true;
-    } else if (inCharGroup && source[i] === "]") {
-      inCharGroup = false;
-    } else if (!inCharGroup && source[i] === "[") {
-      inCharGroup = true;
-    }
-  }
-  try {
-    new RegExp(pattern);
-  } catch {
-    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 === "openAi") {
-    console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
-  }
-  if (refs.target === "openApi3" && def.keyType?._def.typeName === zod.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: refs.rejectedAdditionalProperties
-    };
-  }
-  const schema = {
-    type: "object",
-    additionalProperties: parseDef(def.valueType._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "additionalProperties"]
-    }) ?? refs.allowedAdditionalProperties
-  };
-  if (refs.target === "openApi3") {
-    return schema;
-  }
-  if (def.keyType?._def.typeName === zod.ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
-    const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
-    return {
-      ...schema,
-      propertyNames: keyType
-    };
-  } else if (def.keyType?._def.typeName === zod.ZodFirstPartyTypeKind.ZodEnum) {
-    return {
-      ...schema,
-      propertyNames: {
-        enum: def.keyType._def.values
-      }
-    };
-  } else if (def.keyType?._def.typeName === zod.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === zod.ZodFirstPartyTypeKind.ZodString && def.keyType._def.type._def.checks?.length) {
-    const { type, ...keyType } = parseBrandedDef(def.keyType._def, refs);
-    return {
-      ...schema,
-      propertyNames: keyType
-    };
-  }
-  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;
-  if (options.every((x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length))) {
-    const types = options.reduce((types2, x) => {
-      const type = primitiveMappings[x._def.typeName];
-      return type && !types2.includes(type) ? [...types2, type] : types2;
-    }, []);
-    return {
-      type: types.length > 1 ? types : types[0]
-    };
-  } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
-    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) {
-      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((x2) => !acc.includes(x2))
-      ], [])
-    };
-  }
-  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 } : void 0;
-};
-
-function parseNullableDef(def, refs) {
-  if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(def.innerType._def.typeName) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
-    if (refs.target === "openApi3") {
-      return {
-        type: primitiveMappings[def.innerType._def.typeName],
-        nullable: true
-      };
-    }
-    return {
-      type: [
-        primitiveMappings[def.innerType._def.typeName],
-        "null"
-      ]
-    };
-  }
-  if (refs.target === "openApi3") {
-    const base2 = parseDef(def.innerType._def, {
-      ...refs,
-      currentPath: [...refs.currentPath]
-    });
-    if (base2 && "$ref" in base2)
-      return { allOf: [base2], nullable: true };
-    return base2 && { ...base2, 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 parseObjectDef(def, refs) {
-  const forceOptionalIntoNullable = refs.target === "openAi";
-  const result = {
-    type: "object",
-    properties: {}
-  };
-  const required = [];
-  const shape = def.shape();
-  for (const propName in shape) {
-    let propDef = shape[propName];
-    if (propDef === void 0 || propDef._def === void 0) {
-      continue;
-    }
-    let propOptional = safeIsOptional(propDef);
-    if (propOptional && forceOptionalIntoNullable) {
-      if (propDef instanceof zod.ZodOptional) {
-        propDef = propDef._def.innerType;
-      }
-      if (!propDef.isNullable()) {
-        propDef = propDef.nullable();
-      }
-      propOptional = false;
-    }
-    const parsedDef = parseDef(propDef._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "properties", propName],
-      propertyPath: [...refs.currentPath, "properties", propName]
-    });
-    if (parsedDef === void 0) {
-      continue;
-    }
-    result.properties[propName] = parsedDef;
-    if (!propOptional) {
-      required.push(propName);
-    }
-  }
-  if (required.length) {
-    result.required = required;
-  }
-  const additionalProperties = decideAdditionalProperties(def, refs);
-  if (additionalProperties !== void 0) {
-    result.additionalProperties = additionalProperties;
-  }
-  return result;
-}
-function decideAdditionalProperties(def, refs) {
-  if (def.catchall._def.typeName !== "ZodNever") {
-    return parseDef(def.catchall._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "additionalProperties"]
-    });
-  }
-  switch (def.unknownKeys) {
-    case "passthrough":
-      return refs.allowedAdditionalProperties;
-    case "strict":
-      return refs.rejectedAdditionalProperties;
-    case "strip":
-      return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
-  }
-}
-function safeIsOptional(schema) {
-  try {
-    return schema.isOptional();
-  } catch {
-    return true;
-  }
-}
-
-const parseOptionalDef = (def, refs) => {
-  if (refs.currentPath.toString() === refs.propertyPath?.toString()) {
-    return parseDef(def.innerType._def, refs);
-  }
-  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 !== void 0)
-  };
-};
-
-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 === void 0 ? 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 === void 0 ? acc : [...acc, x], [])
-    };
-  }
-}
-
-function parseUndefinedDef() {
-  return {
-    not: {}
-  };
-}
-
-function parseUnknownDef() {
-  return {};
-}
-
-const parseReadonlyDef = (def, refs) => {
-  return parseDef(def.innerType._def, refs);
-};
-
-const selectParser = (def, typeName, refs) => {
-  switch (typeName) {
-    case zod.ZodFirstPartyTypeKind.ZodString:
-      return parseStringDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodNumber:
-      return parseNumberDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodObject:
-      return parseObjectDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodBigInt:
-      return parseBigintDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodBoolean:
-      return parseBooleanDef();
-    case zod.ZodFirstPartyTypeKind.ZodDate:
-      return parseDateDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodUndefined:
-      return parseUndefinedDef();
-    case zod.ZodFirstPartyTypeKind.ZodNull:
-      return parseNullDef(refs);
-    case zod.ZodFirstPartyTypeKind.ZodArray:
-      return parseArrayDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodUnion:
-    case zod.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
-      return parseUnionDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodIntersection:
-      return parseIntersectionDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodTuple:
-      return parseTupleDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodRecord:
-      return parseRecordDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodLiteral:
-      return parseLiteralDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodEnum:
-      return parseEnumDef(def);
-    case zod.ZodFirstPartyTypeKind.ZodNativeEnum:
-      return parseNativeEnumDef(def);
-    case zod.ZodFirstPartyTypeKind.ZodNullable:
-      return parseNullableDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodOptional:
-      return parseOptionalDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodMap:
-      return parseMapDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodSet:
-      return parseSetDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodLazy:
-      return () => def.getter()._def;
-    case zod.ZodFirstPartyTypeKind.ZodPromise:
-      return parsePromiseDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodNaN:
-    case zod.ZodFirstPartyTypeKind.ZodNever:
-      return parseNeverDef();
-    case zod.ZodFirstPartyTypeKind.ZodEffects:
-      return parseEffectsDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodAny:
-      return parseAnyDef();
-    case zod.ZodFirstPartyTypeKind.ZodUnknown:
-      return parseUnknownDef();
-    case zod.ZodFirstPartyTypeKind.ZodDefault:
-      return parseDefaultDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodBranded:
-      return parseBrandedDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodReadonly:
-      return parseReadonlyDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodCatch:
-      return parseCatchDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodPipeline:
-      return parsePipelineDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodFunction:
-    case zod.ZodFirstPartyTypeKind.ZodVoid:
-    case zod.ZodFirstPartyTypeKind.ZodSymbol:
-      return void 0;
-    default:
-      return /* @__PURE__ */ ((_) => void 0)();
-  }
-};
-
-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 !== void 0) {
-      return seenSchema;
-    }
-  }
-  const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
-  refs.seen.set(def, newItem);
-  const jsonSchemaOrGetter = selectParser(def, def.typeName, refs);
-  const jsonSchema = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
-  if (jsonSchema) {
-    addMeta(def, refs, jsonSchema);
-  }
-  if (refs.postProcess) {
-    const postProcessResult = refs.postProcess(jsonSchema, def, refs);
-    newItem.jsonSchema = jsonSchema;
-    return postProcessResult;
-  }
-  newItem.jsonSchema = jsonSchema;
-  return jsonSchema;
-}
-const get$ref = (item, refs) => {
-  switch (refs.$refStrategy) {
-    case "root":
-      return { $ref: item.path.join("/") };
-    case "relative":
-      return { $ref: getRelativePath(refs.currentPath, item.path) };
-    case "none":
-    case "seen": {
-      if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
-        console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`);
-        return {};
-      }
-      return refs.$refStrategy === "seen" ? {} : void 0;
-    }
-  }
-};
-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 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 definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name2, schema2]) => ({
-    ...acc,
-    [name2]: parseDef(schema2._def, {
-      ...refs,
-      currentPath: [...refs.basePath, refs.definitionPath, name2]
-    }, true) ?? {}
-  }), {}) : void 0;
-  const name = typeof options === "string" ? options : options?.nameStrategy === "title" ? void 0 : options?.name;
-  const main = parseDef(schema._def, name === void 0 ? refs : {
-    ...refs,
-    currentPath: [...refs.basePath, refs.definitionPath, name]
-  }, false) ?? {};
-  const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
-  if (title !== void 0) {
-    main.title = title;
-  }
-  const combined = name === void 0 ? definitions ? {
-    ...main,
-    [refs.definitionPath]: definitions
-  } : main : {
-    $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" || refs.target === "openAi") {
-    combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
-  }
-  if (refs.target === "openAi" && ("anyOf" in combined || "oneOf" in combined || "allOf" in combined || "type" in combined && Array.isArray(combined.type))) {
-    console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
-  }
-  return combined;
-};
-
-var textStreamPart = {
-  code: "0",
-  name: "text",
-  parse: (value) => {
-    if (typeof value !== "string") {
-      throw new Error('"text" parts expect a string value.');
-    }
-    return { type: "text", value };
-  }
-};
-var errorStreamPart = {
-  code: "3",
-  name: "error",
-  parse: (value) => {
-    if (typeof value !== "string") {
-      throw new Error('"error" parts expect a string value.');
-    }
-    return { type: "error", value };
-  }
-};
-var assistantMessageStreamPart = {
-  code: "4",
-  name: "assistant_message",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("id" in value) || !("role" in value) || !("content" in value) || typeof value.id !== "string" || typeof value.role !== "string" || value.role !== "assistant" || !Array.isArray(value.content) || !value.content.every(
-      (item) => item != null && typeof item === "object" && "type" in item && item.type === "text" && "text" in item && item.text != null && typeof item.text === "object" && "value" in item.text && typeof item.text.value === "string"
-    )) {
-      throw new Error(
-        '"assistant_message" parts expect an object with an "id", "role", and "content" property.'
-      );
-    }
-    return {
-      type: "assistant_message",
-      value
-    };
-  }
-};
-var assistantControlDataStreamPart = {
-  code: "5",
-  name: "assistant_control_data",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("threadId" in value) || !("messageId" in value) || typeof value.threadId !== "string" || typeof value.messageId !== "string") {
-      throw new Error(
-        '"assistant_control_data" parts expect an object with a "threadId" and "messageId" property.'
-      );
-    }
-    return {
-      type: "assistant_control_data",
-      value: {
-        threadId: value.threadId,
-        messageId: value.messageId
-      }
-    };
-  }
-};
-var dataMessageStreamPart = {
-  code: "6",
-  name: "data_message",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("role" in value) || !("data" in value) || typeof value.role !== "string" || value.role !== "data") {
-      throw new Error(
-        '"data_message" parts expect an object with a "role" and "data" property.'
-      );
-    }
-    return {
-      type: "data_message",
-      value
-    };
-  }
-};
-var assistantStreamParts = [
-  textStreamPart,
-  errorStreamPart,
-  assistantMessageStreamPart,
-  assistantControlDataStreamPart,
-  dataMessageStreamPart
-];
-({
-  [textStreamPart.code]: textStreamPart,
-  [errorStreamPart.code]: errorStreamPart,
-  [assistantMessageStreamPart.code]: assistantMessageStreamPart,
-  [assistantControlDataStreamPart.code]: assistantControlDataStreamPart,
-  [dataMessageStreamPart.code]: dataMessageStreamPart
-});
-({
-  [textStreamPart.name]: textStreamPart.code,
-  [errorStreamPart.name]: errorStreamPart.code,
-  [assistantMessageStreamPart.name]: assistantMessageStreamPart.code,
-  [assistantControlDataStreamPart.name]: assistantControlDataStreamPart.code,
-  [dataMessageStreamPart.name]: dataMessageStreamPart.code
-});
-assistantStreamParts.map((part) => part.code);
-function fixJson(input) {
-  const stack = ["ROOT"];
-  let lastValidIndex = -1;
-  let literalStart = null;
-  function processValueStart(char, i, swapState) {
-    {
-      switch (char) {
-        case '"': {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_STRING");
-          break;
-        }
-        case "f":
-        case "t":
-        case "n": {
-          lastValidIndex = i;
-          literalStart = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_LITERAL");
-          break;
-        }
-        case "-": {
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_NUMBER");
-          break;
-        }
-        case "0":
-        case "1":
-        case "2":
-        case "3":
-        case "4":
-        case "5":
-        case "6":
-        case "7":
-        case "8":
-        case "9": {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_NUMBER");
-          break;
-        }
-        case "{": {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_OBJECT_START");
-          break;
-        }
-        case "[": {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_ARRAY_START");
-          break;
-        }
-      }
-    }
-  }
-  function processAfterObjectValue(char, i) {
-    switch (char) {
-      case ",": {
-        stack.pop();
-        stack.push("INSIDE_OBJECT_AFTER_COMMA");
-        break;
-      }
-      case "}": {
-        lastValidIndex = i;
-        stack.pop();
-        break;
-      }
-    }
-  }
-  function processAfterArrayValue(char, i) {
-    switch (char) {
-      case ",": {
-        stack.pop();
-        stack.push("INSIDE_ARRAY_AFTER_COMMA");
-        break;
-      }
-      case "]": {
-        lastValidIndex = i;
-        stack.pop();
-        break;
-      }
-    }
-  }
-  for (let i = 0; i < input.length; i++) {
-    const char = input[i];
-    const currentState = stack[stack.length - 1];
-    switch (currentState) {
-      case "ROOT":
-        processValueStart(char, i, "FINISH");
-        break;
-      case "INSIDE_OBJECT_START": {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            stack.push("INSIDE_OBJECT_KEY");
-            break;
-          }
-          case "}": {
-            lastValidIndex = i;
-            stack.pop();
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_OBJECT_AFTER_COMMA": {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            stack.push("INSIDE_OBJECT_KEY");
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_OBJECT_KEY": {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            stack.push("INSIDE_OBJECT_AFTER_KEY");
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_OBJECT_AFTER_KEY": {
-        switch (char) {
-          case ":": {
-            stack.pop();
-            stack.push("INSIDE_OBJECT_BEFORE_VALUE");
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_OBJECT_BEFORE_VALUE": {
-        processValueStart(char, i, "INSIDE_OBJECT_AFTER_VALUE");
-        break;
-      }
-      case "INSIDE_OBJECT_AFTER_VALUE": {
-        processAfterObjectValue(char, i);
-        break;
-      }
-      case "INSIDE_STRING": {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            lastValidIndex = i;
-            break;
-          }
-          case "\\": {
-            stack.push("INSIDE_STRING_ESCAPE");
-            break;
-          }
-          default: {
-            lastValidIndex = i;
-          }
-        }
-        break;
-      }
-      case "INSIDE_ARRAY_START": {
-        switch (char) {
-          case "]": {
-            lastValidIndex = i;
-            stack.pop();
-            break;
-          }
-          default: {
-            lastValidIndex = i;
-            processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_ARRAY_AFTER_VALUE": {
-        switch (char) {
-          case ",": {
-            stack.pop();
-            stack.push("INSIDE_ARRAY_AFTER_COMMA");
-            break;
-          }
-          case "]": {
-            lastValidIndex = i;
-            stack.pop();
-            break;
-          }
-          default: {
-            lastValidIndex = i;
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_ARRAY_AFTER_COMMA": {
-        processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
-        break;
-      }
-      case "INSIDE_STRING_ESCAPE": {
-        stack.pop();
-        lastValidIndex = i;
-        break;
-      }
-      case "INSIDE_NUMBER": {
-        switch (char) {
-          case "0":
-          case "1":
-          case "2":
-          case "3":
-          case "4":
-          case "5":
-          case "6":
-          case "7":
-          case "8":
-          case "9": {
-            lastValidIndex = i;
-            break;
-          }
-          case "e":
-          case "E":
-          case "-":
-          case ".": {
-            break;
-          }
-          case ",": {
-            stack.pop();
-            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
-              processAfterArrayValue(char, i);
-            }
-            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
-              processAfterObjectValue(char, i);
-            }
-            break;
-          }
-          case "}": {
-            stack.pop();
-            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
-              processAfterObjectValue(char, i);
-            }
-            break;
-          }
-          case "]": {
-            stack.pop();
-            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
-              processAfterArrayValue(char, i);
-            }
-            break;
-          }
-          default: {
-            stack.pop();
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_LITERAL": {
-        const partialLiteral = input.substring(literalStart, i + 1);
-        if (!"false".startsWith(partialLiteral) && !"true".startsWith(partialLiteral) && !"null".startsWith(partialLiteral)) {
-          stack.pop();
-          if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
-            processAfterObjectValue(char, i);
-          } else if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
-            processAfterArrayValue(char, i);
-          }
-        } else {
-          lastValidIndex = i;
-        }
-        break;
-      }
-    }
-  }
-  let result = input.slice(0, lastValidIndex + 1);
-  for (let i = stack.length - 1; i >= 0; i--) {
-    const state = stack[i];
-    switch (state) {
-      case "INSIDE_STRING": {
-        result += '"';
-        break;
-      }
-      case "INSIDE_OBJECT_KEY":
-      case "INSIDE_OBJECT_AFTER_KEY":
-      case "INSIDE_OBJECT_AFTER_COMMA":
-      case "INSIDE_OBJECT_START":
-      case "INSIDE_OBJECT_BEFORE_VALUE":
-      case "INSIDE_OBJECT_AFTER_VALUE": {
-        result += "}";
-        break;
-      }
-      case "INSIDE_ARRAY_START":
-      case "INSIDE_ARRAY_AFTER_COMMA":
-      case "INSIDE_ARRAY_AFTER_VALUE": {
-        result += "]";
-        break;
-      }
-      case "INSIDE_LITERAL": {
-        const partialLiteral = input.substring(literalStart, input.length);
-        if ("true".startsWith(partialLiteral)) {
-          result += "true".slice(partialLiteral.length);
-        } else if ("false".startsWith(partialLiteral)) {
-          result += "false".slice(partialLiteral.length);
-        } else if ("null".startsWith(partialLiteral)) {
-          result += "null".slice(partialLiteral.length);
-        }
-      }
-    }
-  }
-  return result;
-}
-function parsePartialJson(jsonText) {
-  if (jsonText === void 0) {
-    return { value: void 0, state: "undefined-input" };
-  }
-  let result = safeParseJSON({ text: jsonText });
-  if (result.success) {
-    return { value: result.value, state: "successful-parse" };
-  }
-  result = safeParseJSON({ text: fixJson(jsonText) });
-  if (result.success) {
-    return { value: result.value, state: "repaired-parse" };
-  }
-  return { value: void 0, state: "failed-parse" };
-}
-var textStreamPart2 = {
-  code: "0",
-  name: "text",
-  parse: (value) => {
-    if (typeof value !== "string") {
-      throw new Error('"text" parts expect a string value.');
-    }
-    return { type: "text", value };
-  }
-};
-var dataStreamPart = {
-  code: "2",
-  name: "data",
-  parse: (value) => {
-    if (!Array.isArray(value)) {
-      throw new Error('"data" parts expect an array value.');
-    }
-    return { type: "data", value };
-  }
-};
-var errorStreamPart2 = {
-  code: "3",
-  name: "error",
-  parse: (value) => {
-    if (typeof value !== "string") {
-      throw new Error('"error" parts expect a string value.');
-    }
-    return { type: "error", value };
-  }
-};
-var messageAnnotationsStreamPart = {
-  code: "8",
-  name: "message_annotations",
-  parse: (value) => {
-    if (!Array.isArray(value)) {
-      throw new Error('"message_annotations" parts expect an array value.');
-    }
-    return { type: "message_annotations", value };
-  }
-};
-var toolCallStreamPart = {
-  code: "9",
-  name: "tool_call",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("toolName" in value) || typeof value.toolName !== "string" || !("args" in value) || typeof value.args !== "object") {
-      throw new Error(
-        '"tool_call" parts expect an object with a "toolCallId", "toolName", and "args" property.'
-      );
-    }
-    return {
-      type: "tool_call",
-      value
-    };
-  }
-};
-var toolResultStreamPart = {
-  code: "a",
-  name: "tool_result",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("result" in value)) {
-      throw new Error(
-        '"tool_result" parts expect an object with a "toolCallId" and a "result" property.'
-      );
-    }
-    return {
-      type: "tool_result",
-      value
-    };
-  }
-};
-var toolCallStreamingStartStreamPart = {
-  code: "b",
-  name: "tool_call_streaming_start",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("toolName" in value) || typeof value.toolName !== "string") {
-      throw new Error(
-        '"tool_call_streaming_start" parts expect an object with a "toolCallId" and "toolName" property.'
-      );
-    }
-    return {
-      type: "tool_call_streaming_start",
-      value
-    };
-  }
-};
-var toolCallDeltaStreamPart = {
-  code: "c",
-  name: "tool_call_delta",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("argsTextDelta" in value) || typeof value.argsTextDelta !== "string") {
-      throw new Error(
-        '"tool_call_delta" parts expect an object with a "toolCallId" and "argsTextDelta" property.'
-      );
-    }
-    return {
-      type: "tool_call_delta",
-      value
-    };
-  }
-};
-var finishMessageStreamPart = {
-  code: "d",
-  name: "finish_message",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("finishReason" in value) || typeof value.finishReason !== "string") {
-      throw new Error(
-        '"finish_message" parts expect an object with a "finishReason" property.'
-      );
-    }
-    const result = {
-      finishReason: value.finishReason
-    };
-    if ("usage" in value && value.usage != null && typeof value.usage === "object" && "promptTokens" in value.usage && "completionTokens" in value.usage) {
-      result.usage = {
-        promptTokens: typeof value.usage.promptTokens === "number" ? value.usage.promptTokens : Number.NaN,
-        completionTokens: typeof value.usage.completionTokens === "number" ? value.usage.completionTokens : Number.NaN
-      };
-    }
-    return {
-      type: "finish_message",
-      value: result
-    };
-  }
-};
-var finishStepStreamPart = {
-  code: "e",
-  name: "finish_step",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("finishReason" in value) || typeof value.finishReason !== "string") {
-      throw new Error(
-        '"finish_step" parts expect an object with a "finishReason" property.'
-      );
-    }
-    const result = {
-      finishReason: value.finishReason,
-      isContinued: false
-    };
-    if ("usage" in value && value.usage != null && typeof value.usage === "object" && "promptTokens" in value.usage && "completionTokens" in value.usage) {
-      result.usage = {
-        promptTokens: typeof value.usage.promptTokens === "number" ? value.usage.promptTokens : Number.NaN,
-        completionTokens: typeof value.usage.completionTokens === "number" ? value.usage.completionTokens : Number.NaN
-      };
-    }
-    if ("isContinued" in value && typeof value.isContinued === "boolean") {
-      result.isContinued = value.isContinued;
-    }
-    return {
-      type: "finish_step",
-      value: result
-    };
-  }
-};
-var startStepStreamPart = {
-  code: "f",
-  name: "start_step",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("messageId" in value) || typeof value.messageId !== "string") {
-      throw new Error(
-        '"start_step" parts expect an object with an "id" property.'
-      );
-    }
-    return {
-      type: "start_step",
-      value: {
-        messageId: value.messageId
-      }
-    };
-  }
-};
-var reasoningStreamPart = {
-  code: "g",
-  name: "reasoning",
-  parse: (value) => {
-    if (typeof value !== "string") {
-      throw new Error('"reasoning" parts expect a string value.');
-    }
-    return { type: "reasoning", value };
-  }
-};
-var sourcePart = {
-  code: "h",
-  name: "source",
-  parse: (value) => {
-    if (value == null || typeof value !== "object") {
-      throw new Error('"source" parts expect a Source object.');
-    }
-    return {
-      type: "source",
-      value
-    };
-  }
-};
-var redactedReasoningStreamPart = {
-  code: "i",
-  name: "redacted_reasoning",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("data" in value) || typeof value.data !== "string") {
-      throw new Error(
-        '"redacted_reasoning" parts expect an object with a "data" property.'
-      );
-    }
-    return { type: "redacted_reasoning", value: { data: value.data } };
-  }
-};
-var reasoningSignatureStreamPart = {
-  code: "j",
-  name: "reasoning_signature",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("signature" in value) || typeof value.signature !== "string") {
-      throw new Error(
-        '"reasoning_signature" parts expect an object with a "signature" property.'
-      );
-    }
-    return {
-      type: "reasoning_signature",
-      value: { signature: value.signature }
-    };
-  }
-};
-var fileStreamPart = {
-  code: "k",
-  name: "file",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("data" in value) || typeof value.data !== "string" || !("mimeType" in value) || typeof value.mimeType !== "string") {
-      throw new Error(
-        '"file" parts expect an object with a "data" and "mimeType" property.'
-      );
-    }
-    return { type: "file", value };
-  }
-};
-var dataStreamParts = [
-  textStreamPart2,
-  dataStreamPart,
-  errorStreamPart2,
-  messageAnnotationsStreamPart,
-  toolCallStreamPart,
-  toolResultStreamPart,
-  toolCallStreamingStartStreamPart,
-  toolCallDeltaStreamPart,
-  finishMessageStreamPart,
-  finishStepStreamPart,
-  startStepStreamPart,
-  reasoningStreamPart,
-  sourcePart,
-  redactedReasoningStreamPart,
-  reasoningSignatureStreamPart,
-  fileStreamPart
-];
-Object.fromEntries(
-  dataStreamParts.map((part) => [part.code, part])
-);
-Object.fromEntries(
-  dataStreamParts.map((part) => [part.name, part.code])
-);
-dataStreamParts.map((part) => part.code);
-function formatDataStreamPart(type, value) {
-  const streamPart = dataStreamParts.find((part) => part.name === type);
-  if (!streamPart) {
-    throw new Error(`Invalid stream part type: ${type}`);
-  }
-  return `${streamPart.code}:${JSON.stringify(value)}
-`;
-}
-function zodSchema(zodSchema2, options) {
-  var _a;
-  const useReferences = (_a = void 0 ) != null ? _a : false;
-  return jsonSchema(
-    zodToJsonSchema(zodSchema2, {
-      $refStrategy: useReferences ? "root" : "none",
-      target: "jsonSchema7"
-      // note: openai mode breaks various gemini conversions
-    }),
-    {
-      validate: (value) => {
-        const result = zodSchema2.safeParse(value);
-        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
-      }
-    }
-  );
-}
-var schemaSymbol = Symbol.for("vercel.ai.schema");
-function jsonSchema(jsonSchema2, {
-  validate
-} = {}) {
-  return {
-    [schemaSymbol]: true,
-    _type: void 0,
-    // should never be used directly
-    [validatorSymbol]: true,
-    jsonSchema: jsonSchema2,
-    validate
-  };
-}
-function isSchema(value) {
-  return typeof value === "object" && value !== null && schemaSymbol in value && value[schemaSymbol] === true && "jsonSchema" in value && "validate" in value;
-}
-function asSchema(schema) {
-  return isSchema(schema) ? schema : zodSchema(schema);
-}
-
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name17 in all)
-    __defProp(target, name17, { get: all[name17], enumerable: true });
-};
-function prepareResponseHeaders(headers, {
-  contentType,
-  dataStreamVersion
-}) {
-  const responseHeaders = new Headers(headers != null ? headers : {});
-  if (!responseHeaders.has("Content-Type")) {
-    responseHeaders.set("Content-Type", contentType);
-  }
-  {
-    responseHeaders.set("X-Vercel-AI-Data-Stream", dataStreamVersion);
-  }
-  return responseHeaders;
-}
-var name4 = "AI_NoObjectGeneratedError";
-var marker4 = `vercel.ai.error.${name4}`;
-var symbol4 = Symbol.for(marker4);
-var _a4;
-var NoObjectGeneratedError = class extends AISDKError {
-  constructor({
-    message = "No object generated.",
-    cause,
-    text: text2,
-    response,
-    usage,
-    finishReason
-  }) {
-    super({ name: name4, message, cause });
-    this[_a4] = true;
-    this.text = text2;
-    this.response = response;
-    this.usage = usage;
-    this.finishReason = finishReason;
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker4);
-  }
-};
-_a4 = symbol4;
-var dataContentSchema = zod.z.union([
-  zod.z.string(),
-  zod.z.instanceof(Uint8Array),
-  zod.z.instanceof(ArrayBuffer),
-  zod.z.custom(
-    // Buffer might not be available in some environments such as CloudFlare:
-    (value) => {
-      var _a17, _b;
-      return (_b = (_a17 = globalThis.Buffer) == null ? void 0 : _a17.isBuffer(value)) != null ? _b : false;
-    },
-    { message: "Must be a Buffer" }
-  )
-]);
-var jsonValueSchema = zod.z.lazy(
-  () => zod.z.union([
-    zod.z.null(),
-    zod.z.string(),
-    zod.z.number(),
-    zod.z.boolean(),
-    zod.z.record(zod.z.string(), jsonValueSchema),
-    zod.z.array(jsonValueSchema)
-  ])
-);
-var providerMetadataSchema = zod.z.record(
-  zod.z.string(),
-  zod.z.record(zod.z.string(), jsonValueSchema)
-);
-var toolResultContentSchema = zod.z.array(
-  zod.z.union([
-    zod.z.object({ type: zod.z.literal("text"), text: zod.z.string() }),
-    zod.z.object({
-      type: zod.z.literal("image"),
-      data: zod.z.string(),
-      mimeType: zod.z.string().optional()
-    })
-  ])
-);
-var textPartSchema = zod.z.object({
-  type: zod.z.literal("text"),
-  text: zod.z.string(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var imagePartSchema = zod.z.object({
-  type: zod.z.literal("image"),
-  image: zod.z.union([dataContentSchema, zod.z.instanceof(URL)]),
-  mimeType: zod.z.string().optional(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var filePartSchema = zod.z.object({
-  type: zod.z.literal("file"),
-  data: zod.z.union([dataContentSchema, zod.z.instanceof(URL)]),
-  filename: zod.z.string().optional(),
-  mimeType: zod.z.string(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var reasoningPartSchema = zod.z.object({
-  type: zod.z.literal("reasoning"),
-  text: zod.z.string(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var redactedReasoningPartSchema = zod.z.object({
-  type: zod.z.literal("redacted-reasoning"),
-  data: zod.z.string(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var toolCallPartSchema = zod.z.object({
-  type: zod.z.literal("tool-call"),
-  toolCallId: zod.z.string(),
-  toolName: zod.z.string(),
-  args: zod.z.unknown(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var toolResultPartSchema = zod.z.object({
-  type: zod.z.literal("tool-result"),
-  toolCallId: zod.z.string(),
-  toolName: zod.z.string(),
-  result: zod.z.unknown(),
-  content: toolResultContentSchema.optional(),
-  isError: zod.z.boolean().optional(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var coreSystemMessageSchema = zod.z.object({
-  role: zod.z.literal("system"),
-  content: zod.z.string(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var coreUserMessageSchema = zod.z.object({
-  role: zod.z.literal("user"),
-  content: zod.z.union([
-    zod.z.string(),
-    zod.z.array(zod.z.union([textPartSchema, imagePartSchema, filePartSchema]))
-  ]),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var coreAssistantMessageSchema = zod.z.object({
-  role: zod.z.literal("assistant"),
-  content: zod.z.union([
-    zod.z.string(),
-    zod.z.array(
-      zod.z.union([
-        textPartSchema,
-        filePartSchema,
-        reasoningPartSchema,
-        redactedReasoningPartSchema,
-        toolCallPartSchema
-      ])
-    )
-  ]),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var coreToolMessageSchema = zod.z.object({
-  role: zod.z.literal("tool"),
-  content: zod.z.array(toolResultPartSchema),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-zod.z.union([
-  coreSystemMessageSchema,
-  coreUserMessageSchema,
-  coreAssistantMessageSchema,
-  coreToolMessageSchema
-]);
-var DEFAULT_SCHEMA_PREFIX = "JSON schema:";
-var DEFAULT_SCHEMA_SUFFIX = "You MUST answer with a JSON object that matches the JSON schema above.";
-var DEFAULT_GENERIC_SUFFIX = "You MUST answer with JSON.";
-function injectJsonInstruction({
-  prompt,
-  schema,
-  schemaPrefix = schema != null ? DEFAULT_SCHEMA_PREFIX : void 0,
-  schemaSuffix = schema != null ? DEFAULT_SCHEMA_SUFFIX : DEFAULT_GENERIC_SUFFIX
-}) {
-  return [
-    prompt != null && prompt.length > 0 ? prompt : void 0,
-    prompt != null && prompt.length > 0 ? "" : void 0,
-    // add a newline if prompt is not null
-    schemaPrefix,
-    schema != null ? JSON.stringify(schema) : void 0,
-    schemaSuffix
-  ].filter((line) => line != null).join("\n");
-}
-createIdGenerator({ prefix: "aiobj", size: 24 });
-createIdGenerator({ prefix: "aiobj", size: 24 });
-createIdGenerator({
-  prefix: "aitxt",
-  size: 24
-});
-createIdGenerator({
-  prefix: "msg",
-  size: 24
-});
-var output_exports = {};
-__export(output_exports, {
-  object: () => object,
-  text: () => text
-});
-var text = () => ({
-  type: "text",
-  responseFormat: () => ({ type: "text" }),
-  injectIntoSystemPrompt({ system }) {
-    return system;
-  },
-  parsePartial({ text: text2 }) {
-    return { partial: text2 };
-  },
-  parseOutput({ text: text2 }) {
-    return text2;
-  }
-});
-var object = ({
-  schema: inputSchema
-}) => {
-  const schema = asSchema(inputSchema);
-  return {
-    type: "object",
-    responseFormat: ({ model }) => ({
-      type: "json",
-      schema: model.supportsStructuredOutputs ? schema.jsonSchema : void 0
-    }),
-    injectIntoSystemPrompt({ system, model }) {
-      return model.supportsStructuredOutputs ? system : injectJsonInstruction({
-        prompt: system,
-        schema: schema.jsonSchema
-      });
-    },
-    parsePartial({ text: text2 }) {
-      const result = parsePartialJson(text2);
-      switch (result.state) {
-        case "failed-parse":
-        case "undefined-input":
-          return void 0;
-        case "repaired-parse":
-        case "successful-parse":
-          return {
-            // Note: currently no validation of partial results:
-            partial: result.value
-          };
-        default: {
-          const _exhaustiveCheck = result.state;
-          throw new Error(`Unsupported parse state: ${_exhaustiveCheck}`);
-        }
-      }
-    },
-    parseOutput({ text: text2 }, context) {
-      const parseResult = safeParseJSON({ text: text2 });
-      if (!parseResult.success) {
-        throw new NoObjectGeneratedError({
-          message: "No object generated: could not parse the response.",
-          cause: parseResult.error,
-          text: text2,
-          response: context.response,
-          usage: context.usage,
-          finishReason: context.finishReason
-        });
-      }
-      const validationResult = safeValidateTypes({
-        value: parseResult.value,
-        schema
-      });
-      if (!validationResult.success) {
-        throw new NoObjectGeneratedError({
-          message: "No object generated: response did not match schema.",
-          cause: validationResult.error,
-          text: text2,
-          response: context.response,
-          usage: context.usage,
-          finishReason: context.finishReason
-        });
-      }
-      return validationResult.value;
-    }
-  };
-};
-function mergeStreams(stream1, stream2) {
-  const reader1 = stream1.getReader();
-  const reader2 = stream2.getReader();
-  let lastRead1 = void 0;
-  let lastRead2 = void 0;
-  let stream1Done = false;
-  let stream2Done = false;
-  async function readStream1(controller) {
-    try {
-      if (lastRead1 == null) {
-        lastRead1 = reader1.read();
-      }
-      const result = await lastRead1;
-      lastRead1 = void 0;
-      if (!result.done) {
-        controller.enqueue(result.value);
-      } else {
-        controller.close();
-      }
-    } catch (error) {
-      controller.error(error);
-    }
-  }
-  async function readStream2(controller) {
-    try {
-      if (lastRead2 == null) {
-        lastRead2 = reader2.read();
-      }
-      const result = await lastRead2;
-      lastRead2 = void 0;
-      if (!result.done) {
-        controller.enqueue(result.value);
-      } else {
-        controller.close();
-      }
-    } catch (error) {
-      controller.error(error);
-    }
-  }
-  return new ReadableStream({
-    async pull(controller) {
-      try {
-        if (stream1Done) {
-          await readStream2(controller);
-          return;
-        }
-        if (stream2Done) {
-          await readStream1(controller);
-          return;
-        }
-        if (lastRead1 == null) {
-          lastRead1 = reader1.read();
-        }
-        if (lastRead2 == null) {
-          lastRead2 = reader2.read();
-        }
-        const { result, reader } = await Promise.race([
-          lastRead1.then((result2) => ({ result: result2, reader: reader1 })),
-          lastRead2.then((result2) => ({ result: result2, reader: reader2 }))
-        ]);
-        if (!result.done) {
-          controller.enqueue(result.value);
-        }
-        if (reader === reader1) {
-          lastRead1 = void 0;
-          if (result.done) {
-            await readStream2(controller);
-            stream1Done = true;
-          }
-        } else {
-          lastRead2 = void 0;
-          if (result.done) {
-            stream2Done = true;
-            await readStream1(controller);
-          }
-        }
-      } catch (error) {
-        controller.error(error);
-      }
-    },
-    cancel() {
-      reader1.cancel();
-      reader2.cancel();
-    }
-  });
-}
-createIdGenerator({
-  prefix: "aitxt",
-  size: 24
-});
-createIdGenerator({
-  prefix: "msg",
-  size: 24
-});
-function tool(tool2) {
-  return tool2;
-}
-var ClientOrServerImplementationSchema = zod.z.object({
-  name: zod.z.string(),
-  version: zod.z.string()
-}).passthrough();
-var BaseParamsSchema = zod.z.object({
-  _meta: zod.z.optional(zod.z.object({}).passthrough())
-}).passthrough();
-var ResultSchema = BaseParamsSchema;
-var RequestSchema = zod.z.object({
-  method: zod.z.string(),
-  params: zod.z.optional(BaseParamsSchema)
-});
-var ServerCapabilitiesSchema = zod.z.object({
-  experimental: zod.z.optional(zod.z.object({}).passthrough()),
-  logging: zod.z.optional(zod.z.object({}).passthrough()),
-  prompts: zod.z.optional(
-    zod.z.object({
-      listChanged: zod.z.optional(zod.z.boolean())
-    }).passthrough()
-  ),
-  resources: zod.z.optional(
-    zod.z.object({
-      subscribe: zod.z.optional(zod.z.boolean()),
-      listChanged: zod.z.optional(zod.z.boolean())
-    }).passthrough()
-  ),
-  tools: zod.z.optional(
-    zod.z.object({
-      listChanged: zod.z.optional(zod.z.boolean())
-    }).passthrough()
-  )
-}).passthrough();
-ResultSchema.extend({
-  protocolVersion: zod.z.string(),
-  capabilities: ServerCapabilitiesSchema,
-  serverInfo: ClientOrServerImplementationSchema,
-  instructions: zod.z.optional(zod.z.string())
-});
-var PaginatedResultSchema = ResultSchema.extend({
-  nextCursor: zod.z.optional(zod.z.string())
-});
-var ToolSchema = zod.z.object({
-  name: zod.z.string(),
-  description: zod.z.optional(zod.z.string()),
-  inputSchema: zod.z.object({
-    type: zod.z.literal("object"),
-    properties: zod.z.optional(zod.z.object({}).passthrough())
-  }).passthrough()
-}).passthrough();
-PaginatedResultSchema.extend({
-  tools: zod.z.array(ToolSchema)
-});
-var TextContentSchema = zod.z.object({
-  type: zod.z.literal("text"),
-  text: zod.z.string()
-}).passthrough();
-var ImageContentSchema = zod.z.object({
-  type: zod.z.literal("image"),
-  data: zod.z.string().base64(),
-  mimeType: zod.z.string()
-}).passthrough();
-var ResourceContentsSchema = zod.z.object({
-  /**
-   * The URI of this resource.
-   */
-  uri: zod.z.string(),
-  /**
-   * The MIME type of this resource, if known.
-   */
-  mimeType: zod.z.optional(zod.z.string())
-}).passthrough();
-var TextResourceContentsSchema = ResourceContentsSchema.extend({
-  text: zod.z.string()
-});
-var BlobResourceContentsSchema = ResourceContentsSchema.extend({
-  blob: zod.z.string().base64()
-});
-var EmbeddedResourceSchema = zod.z.object({
-  type: zod.z.literal("resource"),
-  resource: zod.z.union([TextResourceContentsSchema, BlobResourceContentsSchema])
-}).passthrough();
-ResultSchema.extend({
-  content: zod.z.array(
-    zod.z.union([TextContentSchema, ImageContentSchema, EmbeddedResourceSchema])
-  ),
-  isError: zod.z.boolean().default(false).optional()
-}).or(
-  ResultSchema.extend({
-    toolResult: zod.z.unknown()
-  })
-);
-var JSONRPC_VERSION = "2.0";
-var JSONRPCRequestSchema = zod.z.object({
-  jsonrpc: zod.z.literal(JSONRPC_VERSION),
-  id: zod.z.union([zod.z.string(), zod.z.number().int()])
-}).merge(RequestSchema).strict();
-var JSONRPCResponseSchema = zod.z.object({
-  jsonrpc: zod.z.literal(JSONRPC_VERSION),
-  id: zod.z.union([zod.z.string(), zod.z.number().int()]),
-  result: ResultSchema
-}).strict();
-var JSONRPCErrorSchema = zod.z.object({
-  jsonrpc: zod.z.literal(JSONRPC_VERSION),
-  id: zod.z.union([zod.z.string(), zod.z.number().int()]),
-  error: zod.z.object({
-    code: zod.z.number().int(),
-    message: zod.z.string(),
-    data: zod.z.optional(zod.z.unknown())
-  })
-}).strict();
-var JSONRPCNotificationSchema = zod.z.object({
-  jsonrpc: zod.z.literal(JSONRPC_VERSION)
-}).merge(
-  zod.z.object({
-    method: zod.z.string(),
-    params: zod.z.optional(BaseParamsSchema)
-  })
-).strict();
-zod.z.union([
-  JSONRPCRequestSchema,
-  JSONRPCNotificationSchema,
-  JSONRPCResponseSchema,
-  JSONRPCErrorSchema
-]);
-var langchain_adapter_exports = {};
-__export(langchain_adapter_exports, {
-  mergeIntoDataStream: () => mergeIntoDataStream,
-  toDataStream: () => toDataStream,
-  toDataStreamResponse: () => toDataStreamResponse
-});
-function createCallbacksTransformer(callbacks = {}) {
-  const textEncoder = new TextEncoder();
-  let aggregatedResponse = "";
-  return new TransformStream({
-    async start() {
-      if (callbacks.onStart)
-        await callbacks.onStart();
-    },
-    async transform(message, controller) {
-      controller.enqueue(textEncoder.encode(message));
-      aggregatedResponse += message;
-      if (callbacks.onToken)
-        await callbacks.onToken(message);
-      if (callbacks.onText && typeof message === "string") {
-        await callbacks.onText(message);
-      }
-    },
-    async flush() {
-      if (callbacks.onCompletion) {
-        await callbacks.onCompletion(aggregatedResponse);
-      }
-      if (callbacks.onFinal) {
-        await callbacks.onFinal(aggregatedResponse);
-      }
-    }
-  });
-}
-function toDataStreamInternal(stream, callbacks) {
-  return stream.pipeThrough(
-    new TransformStream({
-      transform: async (value, controller) => {
-        var _a17;
-        if (typeof value === "string") {
-          controller.enqueue(value);
-          return;
-        }
-        if ("event" in value) {
-          if (value.event === "on_chat_model_stream") {
-            forwardAIMessageChunk(
-              (_a17 = value.data) == null ? void 0 : _a17.chunk,
-              controller
-            );
-          }
-          return;
-        }
-        forwardAIMessageChunk(value, controller);
-      }
-    })
-  ).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(new TextDecoderStream()).pipeThrough(
-    new TransformStream({
-      transform: async (chunk, controller) => {
-        controller.enqueue(formatDataStreamPart("text", chunk));
-      }
-    })
-  );
-}
-function toDataStream(stream, callbacks) {
-  return toDataStreamInternal(stream, callbacks).pipeThrough(
-    new TextEncoderStream()
-  );
-}
-function toDataStreamResponse(stream, options) {
-  var _a17;
-  const dataStream = toDataStreamInternal(
-    stream,
-    options == null ? void 0 : options.callbacks
-  ).pipeThrough(new TextEncoderStream());
-  const data = options == null ? void 0 : options.data;
-  const init = options == null ? void 0 : options.init;
-  const responseStream = data ? mergeStreams(data.stream, dataStream) : dataStream;
-  return new Response(responseStream, {
-    status: (_a17 = init == null ? void 0 : init.status) != null ? _a17 : 200,
-    statusText: init == null ? void 0 : init.statusText,
-    headers: prepareResponseHeaders(init == null ? void 0 : init.headers, {
-      contentType: "text/plain; charset=utf-8",
-      dataStreamVersion: "v1"
-    })
-  });
-}
-function mergeIntoDataStream(stream, options) {
-  options.dataStream.merge(toDataStreamInternal(stream, options.callbacks));
-}
-function forwardAIMessageChunk(chunk, controller) {
-  if (typeof chunk.content === "string") {
-    controller.enqueue(chunk.content);
-  } else {
-    const content = chunk.content;
-    for (const item of content) {
-      if (item.type === "text") {
-        controller.enqueue(item.text);
-      }
-    }
-  }
-}
-var llamaindex_adapter_exports = {};
-__export(llamaindex_adapter_exports, {
-  mergeIntoDataStream: () => mergeIntoDataStream2,
-  toDataStream: () => toDataStream2,
-  toDataStreamResponse: () => toDataStreamResponse2
-});
-function toDataStreamInternal2(stream, callbacks) {
-  const trimStart = trimStartOfStream();
-  return convertAsyncIteratorToReadableStream(stream[Symbol.asyncIterator]()).pipeThrough(
-    new TransformStream({
-      async transform(message, controller) {
-        controller.enqueue(trimStart(message.delta));
-      }
-    })
-  ).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(new TextDecoderStream()).pipeThrough(
-    new TransformStream({
-      transform: async (chunk, controller) => {
-        controller.enqueue(formatDataStreamPart("text", chunk));
-      }
-    })
-  );
-}
-function toDataStream2(stream, callbacks) {
-  return toDataStreamInternal2(stream, callbacks).pipeThrough(
-    new TextEncoderStream()
-  );
-}
-function toDataStreamResponse2(stream, options = {}) {
-  var _a17;
-  const { init, data, callbacks } = options;
-  const dataStream = toDataStreamInternal2(stream, callbacks).pipeThrough(
-    new TextEncoderStream()
-  );
-  const responseStream = data ? mergeStreams(data.stream, dataStream) : dataStream;
-  return new Response(responseStream, {
-    status: (_a17 = init == null ? void 0 : init.status) != null ? _a17 : 200,
-    statusText: init == null ? void 0 : init.statusText,
-    headers: prepareResponseHeaders(init == null ? void 0 : init.headers, {
-      contentType: "text/plain; charset=utf-8",
-      dataStreamVersion: "v1"
-    })
-  });
-}
-function mergeIntoDataStream2(stream, options) {
-  options.dataStream.merge(toDataStreamInternal2(stream, options.callbacks));
-}
-function trimStartOfStream() {
-  let isStreamStart = true;
-  return (text2) => {
-    if (isStreamStart) {
-      text2 = text2.trimStart();
-      if (text2)
-        isStreamStart = false;
-    }
-    return text2;
-  };
-}
-
-const executeCodeSchema = zod.z.object({
-  script: zod.z.string().describe(`
-        The JavaScript or TypeScript script to execute, must be in the format of:
-
-        import { someModule } from "someModule";
-        export default () => {
-           ... your code here ...
-           return output;
-        }
-
-        or for async functions:
-
-        import { someModule } from "someModule";
-
-        export default async () => {
-            ... your code here ...
-            return output;
-        }
-        `)
-});
-const executeCodeDescription = (envVars, nodeModules) => `Execute a JavaScript or TypeScript script.
-${envVars.length > 0 ? `You can use the following environment variables: ${envVars}` : ""}
-${nodeModules.length > 0 ? `You can use the following node modules: ${nodeModules}` : "You cannot use any node modules."}`;
-const executeTool = (config) => {
-  const api = new index.FreestyleSandboxes({
-    ...config
-  });
-  const envVars = Object.keys(config.envVars ?? {}).join(", ");
-  const nodeModules = Object.keys(config.nodeModules ?? {}).join(", ");
-  return tool({
-    description: executeCodeDescription(envVars, nodeModules),
-    parameters: executeCodeSchema,
-    execute: async ({ script, ...otherParams }, { toolCallId }) => {
-      try {
-        const res = await api.executeScript(script, config);
-        if (config.onResult) {
-          await config.onResult({
-            toolCallId,
-            result: res,
-            input: {
-              script,
-              ...otherParams
-            }
-          });
-        }
-        if (config.truncateOutput) {
-          if ("output" in res) {
-            res.result = JSON.stringify(res.result).slice(0, 1e3);
-            res.logs = res.logs.slice(0, 1e3);
-          }
-        }
-        return res;
-      } catch (e) {
-        console.log("ERROR: ", e.message);
-        return {
-          message: e.message,
-          error: e.error
-        };
-      }
-    }
-  });
-};
-const deployWebTool = (config) => {
-  const api = new index.FreestyleSandboxes({
-    ...config
-  });
-  const envVars = Object.keys(config.envVars ?? {}).join(", ");
-  const nodeModules = Object.keys(config.nodeModules ?? {}).join(", ");
-  return tool({
-    description: `Deploy a Web project. ${envVars.length > 0 ? `You can use the following environment variables: ${envVars}` : ""}
-${nodeModules.length > 0 ? `You can use the following node modules: ${nodeModules}` : "You cannot use any node modules."}`,
-    parameters: zod.z.object({
-      files: zod.z.record(zod.z.string()).describe(`
-            A record of file names and their contents to deploy. For example:
-            {
-              "index.js": "import http from 'node:http';\\nnconsole.log('starting server');\\n\\nconst server = http.createServer(async(req, res) => {\\n  res.writeHead(200, { 'Content-Type': 'text/plain' });\\n  res.end('Welcome to New York its been waiting for you');\\n});\\n\\nserver.listen(3000, () => {\\n  console.log('Server is running at http://localhost:3000');\\n});",
-            }
-            `)
-    }),
-    execute: async ({ files }) => {
-      const new_files = Object.keys(files).reduce((acc, key) => {
-        acc[key] = { content: files[key] };
-        return acc;
-      }, {});
-      try {
-        const res = await api.deployWeb(
-          {
-            kind: "files",
-            files: new_files
-          },
-          config
-        );
-        return res;
-      } catch (e) {
-        console.log("ERROR: ", e.message);
-        return `Error deploying web project:
-
-${JSON.stringify(
-          files,
-          null,
-          2
-        )}
-
-Error: ${e.message}`;
-      }
-    }
-  });
-};
-
-exports.deployWebTool = deployWebTool;
-exports.executeCodeDescription = executeCodeDescription;
-exports.executeCodeSchema = executeCodeSchema;
-exports.executeTool = executeTool;
-exports.getDefaultExportFromCjs = getDefaultExportFromCjs;
-exports.zodToJsonSchema = zodToJsonSchema;