@fre4x/gemini 1.0.58 → 1.0.61

package/dist/index.js

@@ -65754,10 +65754,1312 @@ function isTerminal(status) {
   return status === "completed" || status === "failed" || status === "cancelled";
 }
 
+// ../node_modules/zod-to-json-schema/dist/esm/Options.js
+var ignoreOverride = /* @__PURE__ */ Symbol("Let zodToJsonSchema decide on which parser to use");
+var 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",
+  openAiAnyTypeName: "OpenAiAnyType"
+};
+var getDefaultOptions = (options) => typeof options === "string" ? {
+  ...defaultOptions,
+  name: options
+} : {
+  ...defaultOptions,
+  ...options
+};
+
+// ../node_modules/zod-to-json-schema/dist/esm/Refs.js
+var getRefs = (options) => {
+  const _options = getDefaultOptions(options);
+  const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
+  return {
+    ..._options,
+    flags: { hasReferencedOpenAiAnyType: false },
+    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
+      }
+    ]))
+  };
+};
+
+// ../node_modules/zod-to-json-schema/dist/esm/errorMessages.js
+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);
+}
+
+// ../node_modules/zod-to-json-schema/dist/esm/getRelativePath.js
+var getRelativePath = (pathA, pathB) => {
+  let i2 = 0;
+  for (; i2 < pathA.length && i2 < pathB.length; i2++) {
+    if (pathA[i2] !== pathB[i2])
+      break;
+  }
+  return [(pathA.length - i2).toString(), ...pathB.slice(i2)].join("/");
+};
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/any.js
+function parseAnyDef(refs) {
+  if (refs.target !== "openAi") {
+    return {};
+  }
+  const anyDefinitionPath = [
+    ...refs.basePath,
+    refs.definitionPath,
+    refs.openAiAnyTypeName
+  ];
+  refs.flags.hasReferencedOpenAiAnyType = true;
+  return {
+    $ref: refs.$refStrategy === "relative" ? getRelativePath(anyDefinitionPath, refs.currentPath) : anyDefinitionPath.join("/")
+  };
+}
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/array.js
+function parseArrayDef(def, refs) {
+  const res = {
+    type: "array"
+  };
+  if (def.type?._def && def.type?._def?.typeName !== ZodFirstPartyTypeKind2.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;
+}
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js
+function parseBigintDef(def, refs) {
+  const res = {
+    type: "integer",
+    format: "int64"
+  };
+  if (!def.checks)
+    return res;
+  for (const check2 of def.checks) {
+    switch (check2.kind) {
+      case "min":
+        if (refs.target === "jsonSchema7") {
+          if (check2.inclusive) {
+            setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMinimum", check2.value, check2.message, refs);
+          }
+        } else {
+          if (!check2.inclusive) {
+            res.exclusiveMinimum = true;
+          }
+          setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
+        }
+        break;
+      case "max":
+        if (refs.target === "jsonSchema7") {
+          if (check2.inclusive) {
+            setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMaximum", check2.value, check2.message, refs);
+          }
+        } else {
+          if (!check2.inclusive) {
+            res.exclusiveMaximum = true;
+          }
+          setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
+        }
+        break;
+      case "multipleOf":
+        setResponseValueAndErrors(res, "multipleOf", check2.value, check2.message, refs);
+        break;
+    }
+  }
+  return res;
+}
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js
+function parseBooleanDef() {
+  return {
+    type: "boolean"
+  };
+}
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/branded.js
+function parseBrandedDef(_def, refs) {
+  return parseDef(_def.type._def, refs);
+}
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/catch.js
+var parseCatchDef = (def, refs) => {
+  return parseDef(def.innerType._def, refs);
+};
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/date.js
+function parseDateDef(def, refs, overrideDateStrategy) {
+  const strategy = overrideDateStrategy ?? refs.dateStrategy;
+  if (Array.isArray(strategy)) {
+    return {
+      anyOf: strategy.map((item, i2) => parseDateDef(def, refs, item))
+    };
+  }
+  switch (strategy) {
+    case "string":
+    case "format:date-time":
+      return {
+        type: "string",
+        format: "date-time"
+      };
+    case "format:date":
+      return {
+        type: "string",
+        format: "date"
+      };
+    case "integer":
+      return integerDateParser(def, refs);
+  }
+}
+var integerDateParser = (def, refs) => {
+  const res = {
+    type: "integer",
+    format: "unix-time"
+  };
+  if (refs.target === "openApi3") {
+    return res;
+  }
+  for (const check2 of def.checks) {
+    switch (check2.kind) {
+      case "min":
+        setResponseValueAndErrors(
+          res,
+          "minimum",
+          check2.value,
+          // This is in milliseconds
+          check2.message,
+          refs
+        );
+        break;
+      case "max":
+        setResponseValueAndErrors(
+          res,
+          "maximum",
+          check2.value,
+          // This is in milliseconds
+          check2.message,
+          refs
+        );
+        break;
+    }
+  }
+  return res;
+};
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/default.js
+function parseDefaultDef(_def, refs) {
+  return {
+    ...parseDef(_def.innerType._def, refs),
+    default: _def.defaultValue()
+  };
+}
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/effects.js
+function parseEffectsDef(_def, refs) {
+  return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : parseAnyDef(refs);
+}
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/enum.js
+function parseEnumDef(def) {
+  return {
+    type: "string",
+    enum: Array.from(def.values)
+  };
+}
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js
+var 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((x2) => !!x2);
+  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;
+}
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/literal.js
+function parseLiteralDef(def, refs) {
+  const parsedType2 = typeof def.value;
+  if (parsedType2 !== "bigint" && parsedType2 !== "number" && parsedType2 !== "boolean" && parsedType2 !== "string") {
+    return {
+      type: Array.isArray(def.value) ? "array" : "object"
+    };
+  }
+  if (refs.target === "openApi3") {
+    return {
+      type: parsedType2 === "bigint" ? "integer" : parsedType2,
+      enum: [def.value]
+    };
+  }
+  return {
+    type: parsedType2 === "bigint" ? "integer" : parsedType2,
+    const: def.value
+  };
+}
+
 // ../node_modules/zod-to-json-schema/dist/esm/parsers/string.js
+var emojiRegex2 = void 0;
+var zodPatterns = {
+  /**
+   * `c` was changed to `[cC]` to replicate /i flag
+   */
+  cuid: /^[cC][^\s-]{8,}$/,
+  cuid2: /^[0-9a-z]+$/,
+  ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
+  /**
+   * `a-z` was added to replicate /i flag
+   */
+  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+  /**
+   * Constructed a valid Unicode RegExp
+   *
+   * Lazily instantiate since this type of regex isn't supported
+   * in all envs (e.g. React Native).
+   *
+   * See:
+   * https://github.com/colinhacks/zod/issues/2433
+   * Fix in Zod:
+   * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
+   */
+  emoji: () => {
+    if (emojiRegex2 === void 0) {
+      emojiRegex2 = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
+    }
+    return emojiRegex2;
+  },
+  /**
+   * 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 check2 of def.checks) {
+      switch (check2.kind) {
+        case "min":
+          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check2.value) : check2.value, check2.message, refs);
+          break;
+        case "max":
+          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check2.value) : check2.value, check2.message, refs);
+          break;
+        case "email":
+          switch (refs.emailStrategy) {
+            case "format:email":
+              addFormat(res, "email", check2.message, refs);
+              break;
+            case "format:idn-email":
+              addFormat(res, "idn-email", check2.message, refs);
+              break;
+            case "pattern:zod":
+              addPattern(res, zodPatterns.email, check2.message, refs);
+              break;
+          }
+          break;
+        case "url":
+          addFormat(res, "uri", check2.message, refs);
+          break;
+        case "uuid":
+          addFormat(res, "uuid", check2.message, refs);
+          break;
+        case "regex":
+          addPattern(res, check2.regex, check2.message, refs);
+          break;
+        case "cuid":
+          addPattern(res, zodPatterns.cuid, check2.message, refs);
+          break;
+        case "cuid2":
+          addPattern(res, zodPatterns.cuid2, check2.message, refs);
+          break;
+        case "startsWith":
+          addPattern(res, RegExp(`^${escapeLiteralCheckValue(check2.value, refs)}`), check2.message, refs);
+          break;
+        case "endsWith":
+          addPattern(res, RegExp(`${escapeLiteralCheckValue(check2.value, refs)}$`), check2.message, refs);
+          break;
+        case "datetime":
+          addFormat(res, "date-time", check2.message, refs);
+          break;
+        case "date":
+          addFormat(res, "date", check2.message, refs);
+          break;
+        case "time":
+          addFormat(res, "time", check2.message, refs);
+          break;
+        case "duration":
+          addFormat(res, "duration", check2.message, refs);
+          break;
+        case "length":
+          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check2.value) : check2.value, check2.message, refs);
+          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check2.value) : check2.value, check2.message, refs);
+          break;
+        case "includes": {
+          addPattern(res, RegExp(escapeLiteralCheckValue(check2.value, refs)), check2.message, refs);
+          break;
+        }
+        case "ip": {
+          if (check2.version !== "v6") {
+            addFormat(res, "ipv4", check2.message, refs);
+          }
+          if (check2.version !== "v4") {
+            addFormat(res, "ipv6", check2.message, refs);
+          }
+          break;
+        }
+        case "base64url":
+          addPattern(res, zodPatterns.base64url, check2.message, refs);
+          break;
+        case "jwt":
+          addPattern(res, zodPatterns.jwt, check2.message, refs);
+          break;
+        case "cidr": {
+          if (check2.version !== "v6") {
+            addPattern(res, zodPatterns.ipv4Cidr, check2.message, refs);
+          }
+          if (check2.version !== "v4") {
+            addPattern(res, zodPatterns.ipv6Cidr, check2.message, refs);
+          }
+          break;
+        }
+        case "emoji":
+          addPattern(res, zodPatterns.emoji(), check2.message, refs);
+          break;
+        case "ulid": {
+          addPattern(res, zodPatterns.ulid, check2.message, refs);
+          break;
+        }
+        case "base64": {
+          switch (refs.base64Strategy) {
+            case "format:binary": {
+              addFormat(res, "binary", check2.message, refs);
+              break;
+            }
+            case "contentEncoding:base64": {
+              setResponseValueAndErrors(res, "contentEncoding", "base64", check2.message, refs);
+              break;
+            }
+            case "pattern:zod": {
+              addPattern(res, zodPatterns.base64, check2.message, refs);
+              break;
+            }
+          }
+          break;
+        }
+        case "nanoid": {
+          addPattern(res, zodPatterns.nanoid, check2.message, refs);
+        }
+        case "toLowerCase":
+        case "toUpperCase":
+        case "trim":
+          break;
+        default:
+          /* @__PURE__ */ ((_) => {
+          })(check2);
+      }
+    }
+  }
+  return res;
+}
+function escapeLiteralCheckValue(literal2, refs) {
+  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal2) : literal2;
+}
 var ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
+function escapeNonAlphaNumeric(source) {
+  let result = "";
+  for (let i2 = 0; i2 < source.length; i2++) {
+    if (!ALPHA_NUMERIC.has(source[i2])) {
+      result += "\\";
+    }
+    result += source[i2];
+  }
+  return result;
+}
+function addFormat(schema, value, message, refs) {
+  if (schema.format || schema.anyOf?.some((x2) => x2.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((x2) => x2.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 i2 = 0; i2 < source.length; i2++) {
+    if (isEscaped) {
+      pattern += source[i2];
+      isEscaped = false;
+      continue;
+    }
+    if (flags.i) {
+      if (inCharGroup) {
+        if (source[i2].match(/[a-z]/)) {
+          if (inCharRange) {
+            pattern += source[i2];
+            pattern += `${source[i2 - 2]}-${source[i2]}`.toUpperCase();
+            inCharRange = false;
+          } else if (source[i2 + 1] === "-" && source[i2 + 2]?.match(/[a-z]/)) {
+            pattern += source[i2];
+            inCharRange = true;
+          } else {
+            pattern += `${source[i2]}${source[i2].toUpperCase()}`;
+          }
+          continue;
+        }
+      } else if (source[i2].match(/[a-z]/)) {
+        pattern += `[${source[i2]}${source[i2].toUpperCase()}]`;
+        continue;
+      }
+    }
+    if (flags.m) {
+      if (source[i2] === "^") {
+        pattern += `(^|(?<=[\r
+]))`;
+        continue;
+      } else if (source[i2] === "$") {
+        pattern += `($|(?=[\r
+]))`;
+        continue;
+      }
+    }
+    if (flags.s && source[i2] === ".") {
+      pattern += inCharGroup ? `${source[i2]}\r
+` : `[${source[i2]}\r
+]`;
+      continue;
+    }
+    pattern += source[i2];
+    if (source[i2] === "\\") {
+      isEscaped = true;
+    } else if (inCharGroup && source[i2] === "]") {
+      inCharGroup = false;
+    } else if (!inCharGroup && source[i2] === "[") {
+      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;
+}
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/record.js
+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 === ZodFirstPartyTypeKind2.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]
+        }) ?? parseAnyDef(refs)
+      }), {}),
+      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 === ZodFirstPartyTypeKind2.ZodString && def.keyType._def.checks?.length) {
+    const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind2.ZodEnum) {
+    return {
+      ...schema,
+      propertyNames: {
+        enum: def.keyType._def.values
+      }
+    };
+  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind2.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind2.ZodString && def.keyType._def.type._def.checks?.length) {
+    const { type, ...keyType } = parseBrandedDef(def.keyType._def, refs);
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  }
+  return schema;
+}
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/map.js
+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"]
+  }) || parseAnyDef(refs);
+  const values = parseDef(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items", "items", "1"]
+  }) || parseAnyDef(refs);
+  return {
+    type: "array",
+    maxItems: 125,
+    items: {
+      type: "array",
+      items: [keys, values],
+      minItems: 2,
+      maxItems: 2
+    }
+  };
+}
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js
+function parseNativeEnumDef(def) {
+  const object3 = def.values;
+  const actualKeys = Object.keys(def.values).filter((key) => {
+    return typeof object3[object3[key]] !== "number";
+  });
+  const actualValues = actualKeys.map((key) => object3[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
+  };
+}
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/never.js
+function parseNeverDef(refs) {
+  return refs.target === "openAi" ? void 0 : {
+    not: parseAnyDef({
+      ...refs,
+      currentPath: [...refs.currentPath, "not"]
+    })
+  };
+}
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/null.js
+function parseNullDef(refs) {
+  return refs.target === "openApi3" ? {
+    enum: ["null"],
+    nullable: true
+  } : {
+    type: "null"
+  };
+}
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/union.js
+var 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((x2) => x2._def.typeName in primitiveMappings && (!x2._def.checks || !x2._def.checks.length))) {
+    const types3 = options.reduce((types4, x2) => {
+      const type = primitiveMappings[x2._def.typeName];
+      return type && !types4.includes(type) ? [...types4, type] : types4;
+    }, []);
+    return {
+      type: types3.length > 1 ? types3 : types3[0]
+    };
+  } else if (options.every((x2) => x2._def.typeName === "ZodLiteral" && !x2.description)) {
+    const types3 = options.reduce((acc, x2) => {
+      const type = typeof x2._def.value;
+      switch (type) {
+        case "string":
+        case "number":
+        case "boolean":
+          return [...acc, type];
+        case "bigint":
+          return [...acc, "integer"];
+        case "object":
+          if (x2._def.value === null)
+            return [...acc, "null"];
+        case "symbol":
+        case "undefined":
+        case "function":
+        default:
+          return acc;
+      }
+    }, []);
+    if (types3.length === options.length) {
+      const uniqueTypes = types3.filter((x2, i2, a) => a.indexOf(x2) === i2);
+      return {
+        type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
+        enum: options.reduce((acc, x2) => {
+          return acc.includes(x2._def.value) ? acc : [...acc, x2._def.value];
+        }, [])
+      };
+    }
+  } else if (options.every((x2) => x2._def.typeName === "ZodEnum")) {
+    return {
+      type: "string",
+      enum: options.reduce((acc, x2) => [
+        ...acc,
+        ...x2._def.values.filter((x3) => !acc.includes(x3))
+      ], [])
+    };
+  }
+  return asAnyOf(def, refs);
+}
+var asAnyOf = (def, refs) => {
+  const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x2, i2) => parseDef(x2._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", `${i2}`]
+  })).filter((x2) => !!x2 && (!refs.strictUnions || typeof x2 === "object" && Object.keys(x2).length > 0));
+  return anyOf.length ? { anyOf } : void 0;
+};
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js
+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" }] };
+}
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/number.js
+function parseNumberDef(def, refs) {
+  const res = {
+    type: "number"
+  };
+  if (!def.checks)
+    return res;
+  for (const check2 of def.checks) {
+    switch (check2.kind) {
+      case "int":
+        res.type = "integer";
+        addErrorMessage(res, "type", check2.message, refs);
+        break;
+      case "min":
+        if (refs.target === "jsonSchema7") {
+          if (check2.inclusive) {
+            setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMinimum", check2.value, check2.message, refs);
+          }
+        } else {
+          if (!check2.inclusive) {
+            res.exclusiveMinimum = true;
+          }
+          setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
+        }
+        break;
+      case "max":
+        if (refs.target === "jsonSchema7") {
+          if (check2.inclusive) {
+            setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMaximum", check2.value, check2.message, refs);
+          }
+        } else {
+          if (!check2.inclusive) {
+            res.exclusiveMaximum = true;
+          }
+          setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
+        }
+        break;
+      case "multipleOf":
+        setResponseValueAndErrors(res, "multipleOf", check2.value, check2.message, refs);
+        break;
+    }
+  }
+  return res;
+}
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/object.js
+function parseObjectDef(def, refs) {
+  const forceOptionalIntoNullable = refs.target === "openAi";
+  const result = {
+    type: "object",
+    properties: {}
+  };
+  const required2 = [];
+  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._def.typeName === "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) {
+      required2.push(propName);
+    }
+  }
+  if (required2.length) {
+    result.required = required2;
+  }
+  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;
+  }
+}
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/optional.js
+var 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: parseAnyDef(refs)
+      },
+      innerSchema
+    ]
+  } : parseAnyDef(refs);
+};
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/pipeline.js
+var 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((x2) => x2 !== void 0)
+  };
+};
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/promise.js
+function parsePromiseDef(def, refs) {
+  return parseDef(def.type._def, refs);
+}
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/set.js
+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;
+}
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js
+function parseTupleDef(def, refs) {
+  if (def.rest) {
+    return {
+      type: "array",
+      minItems: def.items.length,
+      items: def.items.map((x2, i2) => parseDef(x2._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "items", `${i2}`]
+      })).reduce((acc, x2) => x2 === void 0 ? acc : [...acc, x2], []),
+      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((x2, i2) => parseDef(x2._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "items", `${i2}`]
+      })).reduce((acc, x2) => x2 === void 0 ? acc : [...acc, x2], [])
+    };
+  }
+}
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js
+function parseUndefinedDef(refs) {
+  return {
+    not: parseAnyDef(refs)
+  };
+}
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js
+function parseUnknownDef(refs) {
+  return parseAnyDef(refs);
+}
+
+// ../node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js
+var parseReadonlyDef = (def, refs) => {
+  return parseDef(def.innerType._def, refs);
+};
+
+// ../node_modules/zod-to-json-schema/dist/esm/selectParser.js
+var selectParser = (def, typeName, refs) => {
+  switch (typeName) {
+    case ZodFirstPartyTypeKind2.ZodString:
+      return parseStringDef(def, refs);
+    case ZodFirstPartyTypeKind2.ZodNumber:
+      return parseNumberDef(def, refs);
+    case ZodFirstPartyTypeKind2.ZodObject:
+      return parseObjectDef(def, refs);
+    case ZodFirstPartyTypeKind2.ZodBigInt:
+      return parseBigintDef(def, refs);
+    case ZodFirstPartyTypeKind2.ZodBoolean:
+      return parseBooleanDef();
+    case ZodFirstPartyTypeKind2.ZodDate:
+      return parseDateDef(def, refs);
+    case ZodFirstPartyTypeKind2.ZodUndefined:
+      return parseUndefinedDef(refs);
+    case ZodFirstPartyTypeKind2.ZodNull:
+      return parseNullDef(refs);
+    case ZodFirstPartyTypeKind2.ZodArray:
+      return parseArrayDef(def, refs);
+    case ZodFirstPartyTypeKind2.ZodUnion:
+    case ZodFirstPartyTypeKind2.ZodDiscriminatedUnion:
+      return parseUnionDef(def, refs);
+    case ZodFirstPartyTypeKind2.ZodIntersection:
+      return parseIntersectionDef(def, refs);
+    case ZodFirstPartyTypeKind2.ZodTuple:
+      return parseTupleDef(def, refs);
+    case ZodFirstPartyTypeKind2.ZodRecord:
+      return parseRecordDef(def, refs);
+    case ZodFirstPartyTypeKind2.ZodLiteral:
+      return parseLiteralDef(def, refs);
+    case ZodFirstPartyTypeKind2.ZodEnum:
+      return parseEnumDef(def);
+    case ZodFirstPartyTypeKind2.ZodNativeEnum:
+      return parseNativeEnumDef(def);
+    case ZodFirstPartyTypeKind2.ZodNullable:
+      return parseNullableDef(def, refs);
+    case ZodFirstPartyTypeKind2.ZodOptional:
+      return parseOptionalDef(def, refs);
+    case ZodFirstPartyTypeKind2.ZodMap:
+      return parseMapDef(def, refs);
+    case ZodFirstPartyTypeKind2.ZodSet:
+      return parseSetDef(def, refs);
+    case ZodFirstPartyTypeKind2.ZodLazy:
+      return () => def.getter()._def;
+    case ZodFirstPartyTypeKind2.ZodPromise:
+      return parsePromiseDef(def, refs);
+    case ZodFirstPartyTypeKind2.ZodNaN:
+    case ZodFirstPartyTypeKind2.ZodNever:
+      return parseNeverDef(refs);
+    case ZodFirstPartyTypeKind2.ZodEffects:
+      return parseEffectsDef(def, refs);
+    case ZodFirstPartyTypeKind2.ZodAny:
+      return parseAnyDef(refs);
+    case ZodFirstPartyTypeKind2.ZodUnknown:
+      return parseUnknownDef(refs);
+    case ZodFirstPartyTypeKind2.ZodDefault:
+      return parseDefaultDef(def, refs);
+    case ZodFirstPartyTypeKind2.ZodBranded:
+      return parseBrandedDef(def, refs);
+    case ZodFirstPartyTypeKind2.ZodReadonly:
+      return parseReadonlyDef(def, refs);
+    case ZodFirstPartyTypeKind2.ZodCatch:
+      return parseCatchDef(def, refs);
+    case ZodFirstPartyTypeKind2.ZodPipeline:
+      return parsePipelineDef(def, refs);
+    case ZodFirstPartyTypeKind2.ZodFunction:
+    case ZodFirstPartyTypeKind2.ZodVoid:
+    case ZodFirstPartyTypeKind2.ZodSymbol:
+      return void 0;
+    default:
+      return /* @__PURE__ */ ((_) => void 0)(typeName);
+  }
+};
+
+// ../node_modules/zod-to-json-schema/dist/esm/parseDef.js
+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;
+}
+var 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 parseAnyDef(refs);
+      }
+      return refs.$refStrategy === "seen" ? parseAnyDef(refs) : void 0;
+    }
+  }
+};
+var addMeta = (def, refs, jsonSchema) => {
+  if (def.description) {
+    jsonSchema.description = def.description;
+    if (refs.markdownDescription) {
+      jsonSchema.markdownDescription = def.description;
+    }
+  }
+  return jsonSchema;
+};
+
+// ../node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js
+var zodToJsonSchema = (schema, options) => {
+  const refs = getRefs(options);
+  let 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) ?? parseAnyDef(refs)
+  }), {}) : 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) ?? parseAnyDef(refs);
+  const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
+  if (title !== void 0) {
+    main.title = title;
+  }
+  if (refs.flags.hasReferencedOpenAiAnyType) {
+    if (!definitions) {
+      definitions = {};
+    }
+    if (!definitions[refs.openAiAnyTypeName]) {
+      definitions[refs.openAiAnyTypeName] = {
+        // Skipping "object" as no properties can be defined and additionalProperties must be "false"
+        type: ["string", "number", "integer", "boolean", "array", "null"],
+        items: {
+          $ref: refs.$refStrategy === "relative" ? "1" : [
+            ...refs.basePath,
+            refs.definitionPath,
+            refs.openAiAnyTypeName
+          ].join("/")
+        }
+      };
+    }
+  }
+  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;
+};
 
 // ../node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-json-schema-compat.js
+function mapMiniTarget(t2) {
+  if (!t2)
+    return "draft-7";
+  if (t2 === "jsonSchema7" || t2 === "draft-7")
+    return "draft-7";
+  if (t2 === "jsonSchema2019-09" || t2 === "draft-2020-12")
+    return "draft-2020-12";
+  return "draft-7";
+}
+function toJsonSchemaCompat(schema, opts) {
+  if (isZ4Schema(schema)) {
+    return toJSONSchema(schema, {
+      target: mapMiniTarget(opts?.target),
+      io: opts?.pipeStrategy ?? "input"
+    });
+  }
+  return zodToJsonSchema(schema, {
+    strictUnions: opts?.strictUnions ?? true,
+    pipeStrategy: opts?.pipeStrategy ?? "input"
+  });
+}
 function getMethodLiteral(schema) {
   const shape = getObjectShape(schema);
   const methodSchema = shape?.method;
@@ -67519,9 +68821,24 @@ var zodCompat2 = zod_exports;
 var z3 = zodCompat2.z ?? zodCompat2.default?.z ?? zodCompat2.default ?? zodCompat2;
 var IS_MOCK = process.env.GEMINI_MOCK === "true" || process.env.MOCK === "true";
 var PACKAGE_VERSION = getPackageVersion(import.meta.url);
-var DEFAULT_TEXT_MODEL = "gemini-2.0-flash";
-var DEFAULT_IMAGE_MODEL = "imagen-3.0-generate-001";
-var DEFAULT_VIDEO_MODEL = "veo-2.0-generate-001";
+var DEFAULT_TEXT_MODEL = "gemini-2.5-flash";
+var DEFAULT_IMAGE_MODEL = "imagen-4.0-generate-001";
+var DEFAULT_VIDEO_MODEL = "veo-3.1-generate-preview";
+var FALLBACK_ANALYZE_MEDIA_MODELS = [
+  DEFAULT_TEXT_MODEL,
+  "gemini-2.5-pro",
+  "gemini-2.5-flash-lite"
+];
+var FALLBACK_IMAGE_MODELS = [
+  DEFAULT_IMAGE_MODEL,
+  "imagen-4.0-ultra-generate-001",
+  "imagen-4.0-fast-generate-001"
+];
+var FALLBACK_VIDEO_MODELS = [
+  DEFAULT_VIDEO_MODEL,
+  "veo-3.1-lite-generate-preview"
+];
+var MODEL_CATALOG_CACHE_TTL_MS = 5 * 60 * 1e3;
 var ALLOWED_MEDIA_MIME_TYPES = /* @__PURE__ */ new Set([
   "image/png",
   "image/jpeg",
@@ -67542,6 +68859,7 @@ var ALLOWED_MEDIA_MIME_TYPES = /* @__PURE__ */ new Set([
   "application/pdf"
 ]);
 var ai = null;
+var modelCatalogCache = null;
 function getApiKey() {
   const apiKey = process.env.GEMINI_API_KEY;
   if (!apiKey) {
@@ -67616,6 +68934,7 @@ var AnalyzeMediaOutputSchema = z3.object({
   savedPath: z3.string().optional()
 });
 var ListModelsOutputSchema = z3.object({
+  analyzeModels: z3.array(z3.string()),
   imageModels: z3.array(z3.string()),
   videoModels: z3.array(z3.string())
 });
@@ -67644,48 +68963,14 @@ var VideoStatusOutputSchema = z3.object({
   ),
   error: z3.string().optional()
 });
-var ANALYZE_MEDIA_TOOL = {
-  name: "analyze_media",
-  description: "Analyze an image or audio file from a URL or file path.",
-  inputSchema: z3.object({
-    prompt: z3.string().min(1).default("Describe this media.").describe("Optional question or instruction for the media."),
-    media_source: z3.string().min(1).describe("URL, file:// path, or local file path."),
-    mime_type: z3.string().optional().describe("Optional MIME type override."),
-    model: z3.string().optional().default(DEFAULT_TEXT_MODEL).describe("Gemini model to use for analysis."),
-    output_dir: z3.string().optional().describe(
-      "Optional directory to save the analysis result as a .txt file."
-    )
-  }).strict(),
-  outputSchema: AnalyzeMediaOutputSchema
-};
 var LIST_MODELS_TOOL = {
   name: "list_models",
-  description: "List available Gemini image and video models.",
+  description: "List available models for Gemini media tools.",
   inputSchema: z3.object({
-    capability: z3.enum(["all", "image", "video"]).default("all").describe("Filter by capability: image, video, or all.")
+    capability: z3.enum(["all", "analyze", "image", "video"]).default("all").describe("Filter by analyze, image, video, or all.")
   }).strict(),
   outputSchema: ListModelsOutputSchema
 };
-var GENERATE_IMAGE_TOOL = {
-  name: "generate_image",
-  description: "Generate an image using Imagen and optionally save it to disk.",
-  inputSchema: z3.object({
-    prompt: z3.string().min(1).describe("Description of the image to generate."),
-    aspect_ratio: z3.enum(["1:1", "16:9", "9:16"]).default("1:1").describe("Aspect ratio for the image."),
-    model: z3.string().default(DEFAULT_IMAGE_MODEL).describe("Imagen model to use."),
-    output_dir: z3.string().optional().describe("Directory to save the image file.")
-  }).strict(),
-  outputSchema: GenerateImageOutputSchema
-};
-var GENERATE_VIDEO_TOOL = {
-  name: "generate_video",
-  description: "Start an async video generation request using Veo.",
-  inputSchema: z3.object({
-    prompt: z3.string().min(1).describe("Description of the video to generate."),
-    model: z3.string().default(DEFAULT_VIDEO_MODEL).describe("Veo model to use.")
-  }).strict(),
-  outputSchema: GenerateVideoOutputSchema
-};
 var GET_VIDEO_STATUS_TOOL = {
   name: "get_video_status",
   description: "Check the status of a video generation request.",
@@ -67695,16 +68980,9 @@ var GET_VIDEO_STATUS_TOOL = {
   }).strict(),
   outputSchema: VideoStatusOutputSchema
 };
-var TOOL_DEFINITIONS = [
-  ANALYZE_MEDIA_TOOL,
-  LIST_MODELS_TOOL,
-  GENERATE_IMAGE_TOOL,
-  GENERATE_VIDEO_TOOL,
-  GET_VIDEO_STATUS_TOOL
-];
 var server = new Server(
   { name: "gemini-mcp", version: PACKAGE_VERSION },
-  { capabilities: { tools: {} } }
+  { capabilities: { tools: { listChanged: true } } }
 );
 function inferMimeTypeFromSource(source) {
   const withoutQuery = source.split("?")[0].split("#")[0];
@@ -67769,8 +69047,226 @@ function textResult(text, structuredContent) {
 function formatModelLines(models, title) {
   return [title, ...models.map((model) => `- ${model}`), ""];
 }
+function hasApiKey() {
+  return typeof process.env.GEMINI_API_KEY === "string" && process.env.GEMINI_API_KEY.length > 0;
+}
+function dedupeModels(models) {
+  return [...new Set(models.filter(Boolean))];
+}
+function normalizeModelOptions(models, defaultModel) {
+  return dedupeModels([defaultModel, ...models]);
+}
+function getFallbackModelCatalog() {
+  return {
+    analyzeModels: [...FALLBACK_ANALYZE_MEDIA_MODELS],
+    imageModels: [...FALLBACK_IMAGE_MODELS],
+    videoModels: [...FALLBACK_VIDEO_MODELS]
+  };
+}
+function isAnalyzeModel(model) {
+  const name = (model.name ?? "").replace("models/", "");
+  const methods = model.supportedGenerationMethods ?? [];
+  return name.startsWith("gemini-") && methods.includes("generateContent") && !name.includes("image") && !name.includes("embedding") && !name.includes("tts") && !name.includes("live");
+}
+function isImageGenerationModel(model) {
+  const name = (model.name ?? "").replace("models/", "");
+  return name.startsWith("imagen-");
+}
+function isVideoGenerationModel(model) {
+  const name = (model.name ?? "").replace("models/", "");
+  return name.startsWith("veo-");
+}
+async function loadLiveModelCatalog() {
+  if (modelCatalogCache && modelCatalogCache.expiresAt > Date.now()) {
+    return modelCatalogCache.catalog;
+  }
+  const resp = await fetch(
+    `https://generativelanguage.googleapis.com/v1beta/models?key=${getApiKey()}&pageSize=200`
+  );
+  if (!resp.ok) {
+    throw withStatusCode(
+      new Error("The model listing service is unavailable."),
+      resp.status
+    );
+  }
+  const data = await resp.json();
+  const models = data.models ?? [];
+  const catalog = {
+    analyzeModels: normalizeModelOptions(
+      models.filter(isAnalyzeModel).map((model) => model.name.replace("models/", "")),
+      DEFAULT_TEXT_MODEL
+    ),
+    imageModels: normalizeModelOptions(
+      models.filter(isImageGenerationModel).map((model) => model.name.replace("models/", "")),
+      DEFAULT_IMAGE_MODEL
+    ),
+    videoModels: normalizeModelOptions(
+      models.filter(isVideoGenerationModel).map((model) => model.name.replace("models/", "")),
+      DEFAULT_VIDEO_MODEL
+    )
+  };
+  modelCatalogCache = {
+    expiresAt: Date.now() + MODEL_CATALOG_CACHE_TTL_MS,
+    catalog
+  };
+  return catalog;
+}
+async function getToolModelCatalog() {
+  if (IS_MOCK || !hasApiKey()) {
+    return getFallbackModelCatalog();
+  }
+  try {
+    return await loadLiveModelCatalog();
+  } catch {
+    return getFallbackModelCatalog();
+  }
+}
+async function getValidationModelCatalog() {
+  if (IS_MOCK) {
+    return getFallbackModelCatalog();
+  }
+  if (!hasApiKey()) {
+    return null;
+  }
+  try {
+    return await loadLiveModelCatalog();
+  } catch {
+    return null;
+  }
+}
+function createModelSchema(models, defaultModel, description) {
+  const options = normalizeModelOptions(models, defaultModel);
+  return z3.enum(options).default(defaultModel).describe(description);
+}
+function buildAnalyzeMediaTool(catalog) {
+  return {
+    name: "analyze_media",
+    description: "Analyze an image or audio file from a URL or file path.",
+    inputSchema: z3.object({
+      prompt: z3.string().min(1).default("Describe this media.").describe(
+        "Optional question or instruction for the media."
+      ),
+      media_source: z3.string().min(1).describe("URL, file:// path, or local file path."),
+      mime_type: z3.string().optional().describe("Optional MIME type override."),
+      model: createModelSchema(
+        catalog.analyzeModels,
+        DEFAULT_TEXT_MODEL,
+        "Supported analyze_media model."
+      ),
+      output_dir: z3.string().optional().describe(
+        "Optional directory to save the analysis result as a .txt file."
+      )
+    }).strict(),
+    outputSchema: AnalyzeMediaOutputSchema
+  };
+}
+function buildGenerateImageTool(catalog) {
+  return {
+    name: "generate_image",
+    description: "Generate an image using Imagen and optionally save it to disk.",
+    inputSchema: z3.object({
+      prompt: z3.string().min(1).describe("Description of the image to generate."),
+      aspect_ratio: z3.enum(["1:1", "16:9", "9:16"]).default("1:1").describe("Aspect ratio for the image."),
+      model: createModelSchema(
+        catalog.imageModels,
+        DEFAULT_IMAGE_MODEL,
+        "Supported generate_image model."
+      ),
+      output_dir: z3.string().optional().describe("Directory to save the image file.")
+    }).strict(),
+    outputSchema: GenerateImageOutputSchema
+  };
+}
+function buildGenerateVideoTool(catalog) {
+  return {
+    name: "generate_video",
+    description: "Start an async video generation request using Veo.",
+    inputSchema: z3.object({
+      prompt: z3.string().min(1).describe("Description of the video to generate."),
+      model: createModelSchema(
+        catalog.videoModels,
+        DEFAULT_VIDEO_MODEL,
+        "Supported generate_video model."
+      )
+    }).strict(),
+    outputSchema: GenerateVideoOutputSchema
+  };
+}
+var TOOL_DEFINITIONS = [
+  buildAnalyzeMediaTool(getFallbackModelCatalog()),
+  LIST_MODELS_TOOL,
+  buildGenerateImageTool(getFallbackModelCatalog()),
+  buildGenerateVideoTool(getFallbackModelCatalog()),
+  GET_VIDEO_STATUS_TOOL
+];
+async function getToolDefinitions() {
+  const catalog = await getToolModelCatalog();
+  return [
+    buildAnalyzeMediaTool(catalog),
+    LIST_MODELS_TOOL,
+    buildGenerateImageTool(catalog),
+    buildGenerateVideoTool(catalog),
+    GET_VIDEO_STATUS_TOOL
+  ];
+}
+function toToolJsonSchema(schema, pipeStrategy) {
+  return toJsonSchemaCompat(schema, { strictUnions: true, pipeStrategy });
+}
+function toListedToolDefinition(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    inputSchema: toToolJsonSchema(tool.inputSchema, "input"),
+    outputSchema: toToolJsonSchema(tool.outputSchema, "output")
+  };
+}
+async function getListedToolDefinitions() {
+  return (await getToolDefinitions()).map(toListedToolDefinition);
+}
+function createModelValidationError(toolName, model, supportedModels) {
+  return createValidationError(
+    "model",
+    `"${model}" is not supported by ${toolName}. Verify today's date first (for example: Get-Date -Format o), then use list_models to inspect current models for this tool. Supported values: ${supportedModels.join(", ")}`
+  );
+}
+async function validateRequestedModel(toolName, requestedModel, supportedModels) {
+  if (toolName === "analyze_media") {
+    if (requestedModel.startsWith("gemini-1.5-") || requestedModel.startsWith("gemini-2.0-")) {
+      return createModelValidationError(
+        toolName,
+        requestedModel,
+        supportedModels
+      );
+    }
+  }
+  const catalog = await getValidationModelCatalog();
+  if (!catalog) {
+    return null;
+  }
+  if (!supportedModels.includes(requestedModel)) {
+    return createModelValidationError(
+      toolName,
+      requestedModel,
+      supportedModels
+    );
+  }
+  return null;
+}
+function isMissingGenerateContentModelError(message, model) {
+  return message.includes(`models/${model} is not found`) || message.includes("not supported for generateContent");
+}
 async function analyzeMedia(args) {
   const { prompt, media_source, mime_type, model, output_dir } = args;
+  const catalog = await getToolModelCatalog();
+  const requestedModel = model || DEFAULT_TEXT_MODEL;
+  const validationError = await validateRequestedModel(
+    "analyze_media",
+    requestedModel,
+    catalog.analyzeModels
+  );
+  if (validationError) {
+    return validationError;
+  }
   let media;
   try {
     media = await resolveMediaSource(media_source, mime_type);
@@ -67785,28 +69281,43 @@ async function analyzeMedia(args) {
     responseText = `[Mock] Analyzed media (${media.mimeType})
 Source: ${media.label}
 Prompt: "${prompt}"
-Model: ${model}
+Model: ${requestedModel}
 
 Mock response \u2014 no API call made.`;
   } else {
-    const response = await getAi().models.generateContent({
-      model: model || DEFAULT_TEXT_MODEL,
-      contents: [
-        {
-          role: "user",
-          parts: [
-            { text: prompt },
-            {
-              inlineData: {
-                data: media.data,
-                mimeType: media.mimeType
+    try {
+      const response = await getAi().models.generateContent({
+        model: requestedModel,
+        contents: [
+          {
+            role: "user",
+            parts: [
+              { text: prompt },
+              {
+                inlineData: {
+                  data: media.data,
+                  mimeType: media.mimeType
+                }
               }
-            }
-          ]
-        }
-      ]
-    });
-    responseText = response.text || "No analysis generated.";
+            ]
+          }
+        ]
+      });
+      responseText = response.text || "No analysis generated.";
+    } catch (error48) {
+      const errorMessage = getErrorMessage(error48);
+      if (isMissingGenerateContentModelError(errorMessage, requestedModel)) {
+        return createModelValidationError(
+          "analyze_media",
+          requestedModel,
+          catalog.analyzeModels
+        );
+      }
+      if (isErrorWithStatusCode(error48)) {
+        return createApiError(error48.message, error48.statusCode);
+      }
+      return createInternalError(error48);
+    }
   }
   let savedPath;
   if (output_dir) {
@@ -67842,59 +69353,53 @@ Mock response \u2014 no API call made.`;
 }
 async function listModels(args) {
   const { capability } = args;
-  if (IS_MOCK) {
-    const imageModels2 = [
-      DEFAULT_IMAGE_MODEL,
-      "imagen-3.0-ultra-generate-001",
-      "imagen-3.0-fast-generate-001"
-    ];
-    const videoModels2 = [DEFAULT_VIDEO_MODEL];
-    const lines2 = ["## Available Gemini Models", ""];
-    if (capability === "all" || capability === "image") {
-      lines2.push(
-        ...formatModelLines(imageModels2, "### \u{1F5BC}\uFE0F Image Generation")
-      );
-    }
-    if (capability === "all" || capability === "video") {
-      lines2.push(
-        ...formatModelLines(videoModels2, "### \u{1F3AC} Video Generation")
-      );
-    }
-    return textResult(lines2.join("\n").trim(), {
-      imageModels: capability === "video" ? [] : imageModels2,
-      videoModels: capability === "image" ? [] : videoModels2
-    });
-  }
-  const resp = await fetch(
-    `https://generativelanguage.googleapis.com/v1beta/models?key=${getApiKey()}&pageSize=200`
-  );
-  if (!resp.ok) {
-    return createApiError(
-      "The model listing service is unavailable.",
-      resp.status
+  const catalog = await getToolModelCatalog();
+  const analyzeModels = capability === "image" || capability === "video" ? [] : catalog.analyzeModels;
+  const imageModels = capability === "analyze" || capability === "video" ? [] : catalog.imageModels;
+  const videoModels = capability === "analyze" || capability === "image" ? [] : catalog.videoModels;
+  const lines = ["## Available Gemini Models", ""];
+  if (capability === "all" || capability === "analyze") {
+    lines.push(
+      ...formatModelLines(
+        analyzeModels,
+        "### \u{1F3A7} analyze_media (`generateContent`)"
+      )
     );
   }
-  const data = await resp.json();
-  const models = (data.models ?? []).map((model) => ({
-    name: (model.name ?? "").replace("models/", ""),
-    methods: model.supportedGenerationMethods ?? []
-  }));
-  const imageModels = models.filter((model) => model.methods.includes("predict")).map((model) => model.name).filter(Boolean);
-  const videoModels = models.filter((model) => model.name.startsWith("veo")).map((model) => model.name).filter(Boolean);
-  const lines = ["## Available Gemini Models", ""];
   if (capability === "all" || capability === "image") {
-    lines.push(...formatModelLines(imageModels, "### \u{1F5BC}\uFE0F Image Generation"));
+    lines.push(
+      ...formatModelLines(
+        imageModels,
+        "### \u{1F5BC}\uFE0F generate_image (`generateImages`)"
+      )
+    );
   }
   if (capability === "all" || capability === "video") {
-    lines.push(...formatModelLines(videoModels, "### \u{1F3AC} Video Generation"));
+    lines.push(
+      ...formatModelLines(
+        videoModels,
+        "### \u{1F3AC} generate_video (`generateVideos`)"
+      )
+    );
   }
   return textResult(lines.join("\n").trim() || "No models found.", {
-    imageModels: capability === "video" ? [] : imageModels,
-    videoModels: capability === "image" ? [] : videoModels
+    analyzeModels,
+    imageModels,
+    videoModels
   });
 }
 async function generateImage(args) {
   const { prompt, aspect_ratio, model, output_dir } = args;
+  const catalog = await getToolModelCatalog();
+  const requestedModel = model || DEFAULT_IMAGE_MODEL;
+  const validationError = await validateRequestedModel(
+    "generate_image",
+    requestedModel,
+    catalog.imageModels
+  );
+  if (validationError) {
+    return validationError;
+  }
   if (IS_MOCK) {
     const mockBase64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
     let savedPath;
@@ -67947,7 +69452,7 @@ Saved to: ${savedPath}` : ""}`
     };
   }
   const response = await getAi().models.generateImages({
-    model: model || DEFAULT_IMAGE_MODEL,
+    model: requestedModel,
     prompt,
     config: { numberOfImages: 1, aspectRatio: aspect_ratio }
   });
@@ -68001,6 +69506,16 @@ ${savedPaths.join("\n")}` : ""}`
 }
 async function generateVideo(args) {
   const { prompt, model } = args;
+  const catalog = await getToolModelCatalog();
+  const requestedModel = model || DEFAULT_VIDEO_MODEL;
+  const validationError = await validateRequestedModel(
+    "generate_video",
+    requestedModel,
+    catalog.videoModels
+  );
+  if (validationError) {
+    return validationError;
+  }
   if (IS_MOCK) {
     const opName2 = "mock-operations/123456";
     return textResult(
@@ -68013,7 +69528,7 @@ Call get_video_status to check progress.`,
     );
   }
   const operation = await getAi().models.generateVideos({
-    model: model || DEFAULT_VIDEO_MODEL,
+    model: requestedModel,
     prompt,
     config: { numberOfVideos: 1 }
   });
@@ -68140,26 +69655,30 @@ ${savedPaths.join("\n")}`);
 }
 async function handleToolCall(name, args) {
   try {
+    const toolDefinitions = await getToolDefinitions();
+    const analyzeMediaTool = toolDefinitions[0];
+    const listModelsTool = toolDefinitions[1];
+    const generateImageTool = toolDefinitions[2];
+    const generateVideoTool = toolDefinitions[3];
+    const getVideoStatusTool = toolDefinitions[4];
     switch (name) {
       case "analyze_media":
         return await analyzeMedia(
-          ANALYZE_MEDIA_TOOL.inputSchema.parse(args)
+          analyzeMediaTool.inputSchema.parse(args)
         );
       case "list_models":
-        return await listModels(
-          LIST_MODELS_TOOL.inputSchema.parse(args)
-        );
+        return await listModels(listModelsTool.inputSchema.parse(args));
       case "generate_image":
         return await generateImage(
-          GENERATE_IMAGE_TOOL.inputSchema.parse(args)
+          generateImageTool.inputSchema.parse(args)
         );
       case "generate_video":
         return await generateVideo(
-          GENERATE_VIDEO_TOOL.inputSchema.parse(args)
+          generateVideoTool.inputSchema.parse(args)
         );
       case "get_video_status":
         return await getVideoStatus(
-          GET_VIDEO_STATUS_TOOL.inputSchema.parse(args)
+          getVideoStatusTool.inputSchema.parse(args)
         );
       default:
         throw new Error(`Tool not found: ${name}`);
@@ -68177,9 +69696,9 @@ async function handleToolCall(name, args) {
     return createInternalError(error48);
   }
 }
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: [...TOOL_DEFINITIONS]
-}));
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return { tools: await getListedToolDefinitions() };
+});
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name, arguments: args } = request.params;
   return handleToolCall(name, args);
@@ -68208,6 +69727,8 @@ if (isMainModule(import.meta.url)) {
 }
 export {
   TOOL_DEFINITIONS,
+  getListedToolDefinitions,
+  getToolDefinitions,
   handleToolCall,
   runServer
 };