@crewai-ts/core 0.1.13 → 0.2.1

package/dist/chunk-CCOE6MLE.js

@@ -0,0 +1,896 @@
+// src/schema-utils.ts
+var JsonSchemaInfo = class JsonSchemaInfo2 {
+  name;
+  strict = true;
+  schema;
+  constructor(options) {
+    this.name = options.name;
+    this.schema = options.schema;
+    void options.strict;
+  }
+};
+var ModelDescription = class ModelDescription2 {
+  type = "json_schema";
+  json_schema;
+  constructor(options) {
+    this.json_schema = options.json_schema instanceof JsonSchemaInfo ? options.json_schema : new JsonSchemaInfo(options.json_schema);
+  }
+};
+var FORMAT_TYPE_MAP = {
+  "date-time": "string",
+  date: "string",
+  time: "string",
+  duration: "string"
+};
+var OPENAI_SUPPORTED_FORMATS = /* @__PURE__ */ new Set(["date-time", "date", "time", "duration"]);
+var STRICT_METADATA_KEYS = [
+  "title",
+  "default",
+  "examples",
+  "example",
+  "$comment",
+  "readOnly",
+  "writeOnly",
+  "deprecated"
+];
+var CLAUDE_STRICT_UNSUPPORTED = [
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "multipleOf",
+  "minLength",
+  "maxLength",
+  "pattern",
+  "minItems",
+  "maxItems",
+  "uniqueItems",
+  "minContains",
+  "maxContains",
+  "minProperties",
+  "maxProperties",
+  "patternProperties",
+  "propertyNames",
+  "dependentRequired",
+  "dependentSchemas"
+];
+function isSchemaRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isUnknownArray(value) {
+  return Array.isArray(value);
+}
+function cloneSchema(value) {
+  return structuredClone(value);
+}
+function localDefName(ref) {
+  const prefix = "#/$defs/";
+  return ref.startsWith(prefix) ? ref.slice(prefix.length) : null;
+}
+function walkSchema(value, visitor, seen = /* @__PURE__ */ new WeakSet()) {
+  if (Array.isArray(value)) {
+    if (seen.has(value)) {
+      return;
+    }
+    seen.add(value);
+    for (const item of value) {
+      walkSchema(item, visitor, seen);
+    }
+    return;
+  }
+  if (!isSchemaRecord(value)) {
+    return;
+  }
+  if (seen.has(value)) {
+    return;
+  }
+  seen.add(value);
+  visitor(value);
+  for (const child of Object.values(value)) {
+    walkSchema(child, visitor, seen);
+  }
+}
+function resolveRefs(schema) {
+  const defs = isSchemaRecord(schema.$defs) ? schema.$defs : {};
+  const schemaCopy = cloneSchema(schema);
+  const expanding = /* @__PURE__ */ new Set();
+  function resolveNode(node) {
+    if (Array.isArray(node)) {
+      return node.map((item) => resolveNode(item));
+    }
+    if (!isSchemaRecord(node)) {
+      return node;
+    }
+    const ref = node.$ref;
+    if (typeof ref === "string") {
+      const defName = localDefName(ref);
+      if (defName) {
+        const defSchema = defs[defName];
+        if (!isSchemaRecord(defSchema)) {
+          throw new Error(`Definition '${defName}' not found in $defs.`);
+        }
+        if (expanding.has(defName)) {
+          const stub = { type: typeof defSchema.type === "string" ? defSchema.type : "object" };
+          if (typeof defSchema.description === "string") {
+            stub.description = defSchema.description;
+          }
+          return stub;
+        }
+        expanding.add(defName);
+        try {
+          return resolveNode(cloneSchema(defSchema));
+        } finally {
+          expanding.delete(defName);
+        }
+      }
+    }
+    return Object.fromEntries(Object.entries(node).map(([key, value]) => [key, resolveNode(value)]));
+  }
+  return resolveNode(schemaCopy);
+}
+function addKeyInDictRecursively(schema, key, value, criteria) {
+  walkSchema(schema, (node) => {
+    if (criteria(node) && !(key in node)) {
+      node[key] = value;
+    }
+  });
+  return schema;
+}
+function forceAdditionalPropertiesFalse(schema) {
+  walkSchema(schema, (node) => {
+    if (node.type === "object") {
+      node.additionalProperties = false;
+      node.properties ??= {};
+      node.required ??= [];
+    }
+  });
+  return schema;
+}
+function stripUnsupportedFormats(schema) {
+  walkSchema(schema, (node) => {
+    if (typeof node.format === "string" && !OPENAI_SUPPORTED_FORMATS.has(node.format)) {
+      delete node.format;
+    }
+  });
+  return schema;
+}
+function ensureTypeInSchemas(schema) {
+  walkSchema(schema, (node) => {
+    for (const key of ["anyOf", "oneOf"]) {
+      const variants = node[key];
+      if (!isUnknownArray(variants)) {
+        continue;
+      }
+      for (let index = 0; index < variants.length; index += 1) {
+        const variant = variants[index];
+        if (isSchemaRecord(variant) && Object.keys(variant).length === 0) {
+          variants[index] = { type: "object" };
+        }
+      }
+    }
+  });
+  return schema;
+}
+function fixDiscriminatorMappings(schema) {
+  const properties = isSchemaRecord(schema.properties) ? schema.properties : null;
+  const output = properties && isSchemaRecord(properties.output) ? properties.output : null;
+  const discriminator = output && isSchemaRecord(output.discriminator) ? output.discriminator : null;
+  const mapping = discriminator && isSchemaRecord(discriminator.mapping) ? discriminator.mapping : null;
+  if (!discriminator || !mapping) {
+    return schema;
+  }
+  discriminator.mapping = Object.fromEntries(
+    Object.entries(mapping).map(([key, value]) => [key, typeof value === "string" ? value.split("/").at(-1) : value])
+  );
+  return schema;
+}
+function addConstToOneOfVariants(schema) {
+  const copy = cloneSchema(schema);
+  walkSchema(copy, (node) => {
+    const variants = node.oneOf;
+    const discriminator = isSchemaRecord(node.discriminator) ? node.discriminator : null;
+    const mapping = discriminator && isSchemaRecord(discriminator.mapping) ? discriminator.mapping : null;
+    const propertyName = discriminator ? discriminator.propertyName : void 0;
+    if (!Array.isArray(variants) || typeof propertyName !== "string" || !mapping) {
+      return;
+    }
+    for (const variant of variants) {
+      if (!isSchemaRecord(variant) || !isSchemaRecord(variant.properties)) {
+        continue;
+      }
+      const variantTitle = typeof variant.title === "string" ? variant.title : "";
+      const match = Object.entries(mapping).find(([, schemaName]) => {
+        return typeof schemaName === "string" && (variantTitle === schemaName || variantTitle.endsWith(schemaName));
+      });
+      if (!match) {
+        continue;
+      }
+      const target = variant.properties[propertyName];
+      if (isSchemaRecord(target)) {
+        target.const = match[0];
+      }
+    }
+  });
+  return copy;
+}
+function convertOneOfToAnyOf(schema) {
+  walkSchema(schema, (node) => {
+    if ("oneOf" in node) {
+      node.anyOf = node.oneOf;
+      delete node.oneOf;
+    }
+  });
+  return schema;
+}
+function ensureAllPropertiesRequired(schema) {
+  walkSchema(schema, (node) => {
+    if (node.type === "object" && isSchemaRecord(node.properties) && Object.keys(node.properties).length > 0) {
+      node.required = Object.keys(node.properties);
+    }
+  });
+  return schema;
+}
+function stripNullFromTypes(schema) {
+  walkSchema(schema, (node) => {
+    const anyOf = node.anyOf;
+    if (Array.isArray(anyOf)) {
+      const nonNull = anyOf.filter((option) => !isSchemaRecord(option) || option.type !== "null");
+      if (nonNull.length === 1 && isSchemaRecord(nonNull[0])) {
+        delete node.anyOf;
+        Object.assign(node, nonNull[0]);
+      } else if (nonNull.length > 1) {
+        node.anyOf = nonNull;
+      }
+    }
+    const typeValue = node.type;
+    if (Array.isArray(typeValue) && typeValue.includes("null")) {
+      const nonNullTypes = typeValue.filter((entry) => entry !== "null");
+      if (nonNullTypes.length === 1) {
+        node.type = nonNullTypes[0];
+      } else if (nonNullTypes.length > 1) {
+        node.type = nonNullTypes;
+      }
+    }
+  });
+  return schema;
+}
+function stripKeysRecursive(schema, keys) {
+  walkSchema(schema, (node) => {
+    for (const key of keys) {
+      Reflect.deleteProperty(node, key);
+    }
+  });
+  return schema;
+}
+var _strip_keys_recursive = stripKeysRecursive;
+function liftTopLevelAnyOf(schema) {
+  for (const key of ["anyOf", "oneOf", "allOf"]) {
+    const variants = schema[key];
+    if (!isUnknownArray(variants)) {
+      continue;
+    }
+    const objectVariants = variants.filter((variant) => {
+      return isSchemaRecord(variant) && variant.type === "object";
+    });
+    if (objectVariants.length === 1) {
+      Reflect.deleteProperty(schema, key);
+      Object.assign(schema, cloneSchema(objectVariants[0]));
+      break;
+    }
+  }
+  return schema;
+}
+function commonStrictPipeline(params) {
+  let sanitized = resolveRefs(cloneSchema(params));
+  delete sanitized.$defs;
+  sanitized = convertOneOfToAnyOf(sanitized);
+  sanitized = ensureTypeInSchemas(sanitized);
+  sanitized = forceAdditionalPropertiesFalse(sanitized);
+  sanitized = ensureAllPropertiesRequired(sanitized);
+  return stripKeysRecursive(sanitized, STRICT_METADATA_KEYS);
+}
+var _common_strict_pipeline = commonStrictPipeline;
+function sanitizeToolParamsForOpenAIStrict(params) {
+  if (!isSchemaRecord(params)) {
+    return params;
+  }
+  return stripUnsupportedFormats(commonStrictPipeline(params));
+}
+function sanitizeToolParamsForAnthropicStrict(params) {
+  if (!isSchemaRecord(params)) {
+    return params;
+  }
+  let sanitized = liftTopLevelAnyOf(commonStrictPipeline(params));
+  sanitized = stripKeysRecursive(sanitized, CLAUDE_STRICT_UNSUPPORTED);
+  return stripUnsupportedFormats(sanitized);
+}
+function sanitizeToolParamsForBedrockStrict(params) {
+  return sanitizeToolParamsForAnthropicStrict(params);
+}
+function describeValue(value) {
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "undefined") {
+    return "undefined";
+  }
+  if (typeof value === "symbol") {
+    return value.toString();
+  }
+  if (typeof value === "function") {
+    return value.name ? `[function ${value.name}]` : "[function]";
+  }
+  return JSON.stringify(value);
+}
+function buildRichFieldDescription(propSchema) {
+  const parts = [];
+  if (typeof propSchema.description === "string" && propSchema.description.length > 0) {
+    parts.push(propSchema.description);
+  }
+  if (typeof propSchema.format === "string" && propSchema.format.length > 0) {
+    parts.push(`Format: ${propSchema.format}`);
+  }
+  if (Array.isArray(propSchema.enum) && propSchema.enum.length > 0) {
+    parts.push(`Allowed values: [${propSchema.enum.map((value) => describeValue(value)).join(", ")}]`);
+  }
+  if (typeof propSchema.pattern === "string" && propSchema.pattern.length > 0) {
+    parts.push(`Pattern: ${propSchema.pattern}`);
+  }
+  if (propSchema.minimum !== void 0) {
+    parts.push(`Minimum: ${describeValue(propSchema.minimum)}`);
+  }
+  if (propSchema.maximum !== void 0) {
+    parts.push(`Maximum: ${describeValue(propSchema.maximum)}`);
+  }
+  if (propSchema.minLength !== void 0) {
+    parts.push(`Min length: ${describeValue(propSchema.minLength)}`);
+  }
+  if (propSchema.maxLength !== void 0) {
+    parts.push(`Max length: ${describeValue(propSchema.maxLength)}`);
+  }
+  if (Array.isArray(propSchema.examples) && propSchema.examples.length > 0) {
+    parts.push(`Examples: ${propSchema.examples.slice(0, 3).map((value) => describeValue(value)).join(", ")}`);
+  }
+  return parts.join(". ");
+}
+function _inline_top_level_ref(schema, rootSchema = schema) {
+  const copy = cloneSchema(schema);
+  const ref = copy.$ref;
+  const defName = typeof ref === "string" ? localDefName(ref) : null;
+  const defs = isSchemaRecord(copy.$defs) ? copy.$defs : isSchemaRecord(rootSchema.$defs) ? rootSchema.$defs : {};
+  const defSchema = defName ? defs[defName] : null;
+  if (isSchemaRecord(defSchema)) {
+    const resolved = cloneSchema(defSchema);
+    resolved.$defs ??= defs;
+    return resolved;
+  }
+  return copy;
+}
+function _process_oneof(schema) {
+  return addConstToOneOfVariants(schema);
+}
+function generateModelDescription(name, schema, options = {}) {
+  let jsonSchema = forceAdditionalPropertiesFalse(cloneSchema(schema));
+  jsonSchema = stripUnsupportedFormats(jsonSchema);
+  jsonSchema = ensureTypeInSchemas(jsonSchema);
+  jsonSchema = resolveRefs(jsonSchema);
+  delete jsonSchema.$defs;
+  jsonSchema = fixDiscriminatorMappings(jsonSchema);
+  jsonSchema = convertOneOfToAnyOf(jsonSchema);
+  jsonSchema = ensureAllPropertiesRequired(jsonSchema);
+  if (options.stripNullTypes ?? true) {
+    jsonSchema = stripNullFromTypes(jsonSchema);
+  }
+  return {
+    type: "json_schema",
+    json_schema: {
+      name,
+      strict: true,
+      schema: jsonSchema
+    }
+  };
+}
+var resolve_refs = resolveRefs;
+var add_key_in_dict_recursively = addKeyInDictRecursively;
+var force_additional_properties_false = forceAdditionalPropertiesFalse;
+var strip_unsupported_formats = stripUnsupportedFormats;
+var ensure_type_in_schemas = ensureTypeInSchemas;
+var fix_discriminator_mappings = fixDiscriminatorMappings;
+var add_const_to_oneof_variants = addConstToOneOfVariants;
+var convert_oneof_to_anyof = convertOneOfToAnyOf;
+var ensure_all_properties_required = ensureAllPropertiesRequired;
+var strip_null_from_types = stripNullFromTypes;
+var lift_top_level_anyof = liftTopLevelAnyOf;
+var sanitize_tool_params_for_openai_strict = sanitizeToolParamsForOpenAIStrict;
+var sanitize_tool_params_for_anthropic_strict = sanitizeToolParamsForAnthropicStrict;
+var sanitize_tool_params_for_bedrock_strict = sanitizeToolParamsForBedrockStrict;
+var build_rich_field_description = buildRichFieldDescription;
+var generate_model_description = generateModelDescription;
+function serializeModelClass(model) {
+  if (typeof model === "function") {
+    return { title: model.name || "Model", type: "object" };
+  }
+  if (model && typeof model === "object" && "schema" in model) {
+    const schema = model.schema;
+    return schema && typeof schema === "object" && !Array.isArray(schema) ? schema : {};
+  }
+  return {};
+}
+var serialize_model_class = serializeModelClass;
+function coerceCreateModelOptions(value) {
+  if (!isSchemaRecord(value)) {
+    return {};
+  }
+  const options = {};
+  if (isSchemaRecord(value.rootSchema)) {
+    options.rootSchema = value.rootSchema;
+  }
+  if (isSchemaRecord(value.root_schema)) {
+    options.root_schema = value.root_schema;
+  }
+  if (typeof value.modelName === "string") {
+    options.modelName = value.modelName;
+  }
+  if (typeof value.model_name === "string") {
+    options.model_name = value.model_name;
+  }
+  if (typeof value.enrichDescriptions === "boolean") {
+    options.enrichDescriptions = value.enrichDescriptions;
+  }
+  if (typeof value.enrich_descriptions === "boolean") {
+    options.enrich_descriptions = value.enrich_descriptions;
+  }
+  return options;
+}
+function createValidationError(path, message) {
+  return new Error(`${path}: ${message}`);
+}
+function schemaTypeMatches(schema, expected) {
+  return schema.type === expected || Array.isArray(schema.type) && schema.type.includes(expected);
+}
+function numericConstraint(schema, key) {
+  const value = schema[key];
+  return typeof value === "number" && !Number.isNaN(value) ? value : null;
+}
+function isValidDateString(value) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (!match) {
+    return false;
+  }
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const date = new Date(Date.UTC(year, month - 1, day));
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}
+function dateFromDateString(value) {
+  const [year, month, day] = value.split("-").map((part) => Number(part));
+  return new Date(Date.UTC(year ?? 0, (month ?? 1) - 1, day ?? 1));
+}
+function isValidTimeString(value) {
+  const match = /^(\d{2}):(\d{2})(?::(\d{2})(?:\.\d+)?)?$/.exec(value);
+  if (!match) {
+    return false;
+  }
+  const hour = Number(match[1]);
+  const minute = Number(match[2]);
+  const second = match[3] === void 0 ? 0 : Number(match[3]);
+  return hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59 && second >= 0 && second <= 59;
+}
+function assertStringFormat(schema, value, path) {
+  if (schema.format === "date" && !isValidDateString(value)) {
+    throw createValidationError(path, "format date");
+  }
+  if (schema.format === "date-time" && Number.isNaN(Date.parse(value))) {
+    throw createValidationError(path, "format date-time");
+  }
+  if (schema.format === "time" && !isValidTimeString(value)) {
+    throw createValidationError(path, "format time");
+  }
+}
+function coerceFormattedString(schema, value) {
+  if (schema.format === "date") {
+    return dateFromDateString(value);
+  }
+  if (schema.format === "date-time") {
+    return new Date(value);
+  }
+  return value;
+}
+function isDateFormatSchema(schema) {
+  return schema.format === "date" || schema.format === "date-time";
+}
+function assertStringConstraints(schema, value, path) {
+  assertStringFormat(schema, value, path);
+  const minLength = numericConstraint(schema, "minLength");
+  if (minLength !== null && value.length < minLength) {
+    throw createValidationError(path, `minLength ${String(minLength)}`);
+  }
+  const maxLength = numericConstraint(schema, "maxLength");
+  if (maxLength !== null && value.length > maxLength) {
+    throw createValidationError(path, `maxLength ${String(maxLength)}`);
+  }
+  if (typeof schema.pattern === "string" && !new RegExp(schema.pattern).test(value)) {
+    throw createValidationError(path, `pattern ${schema.pattern}`);
+  }
+}
+function assertNumberConstraints(schema, value, path) {
+  const minimum = numericConstraint(schema, "minimum");
+  if (minimum !== null && value < minimum) {
+    throw createValidationError(path, `minimum ${String(minimum)}`);
+  }
+  const exclusiveMinimum = numericConstraint(schema, "exclusiveMinimum");
+  if (exclusiveMinimum !== null && value <= exclusiveMinimum) {
+    throw createValidationError(path, `exclusiveMinimum ${String(exclusiveMinimum)}`);
+  }
+  const maximum = numericConstraint(schema, "maximum");
+  if (maximum !== null && value > maximum) {
+    throw createValidationError(path, `maximum ${String(maximum)}`);
+  }
+  const exclusiveMaximum = numericConstraint(schema, "exclusiveMaximum");
+  if (exclusiveMaximum !== null && value >= exclusiveMaximum) {
+    throw createValidationError(path, `exclusiveMaximum ${String(exclusiveMaximum)}`);
+  }
+  const multipleOf = numericConstraint(schema, "multipleOf");
+  if (multipleOf !== null && multipleOf !== 0 && Math.abs(value / multipleOf - Math.round(value / multipleOf)) > Number.EPSILON) {
+    throw createValidationError(path, `multipleOf ${String(multipleOf)}`);
+  }
+}
+function effectiveSchema(schema, rootSchema) {
+  if (typeof schema.$ref === "string") {
+    const resolved = _resolve_ref(schema.$ref, rootSchema);
+    if (isSchemaRecord(schema.$defs) && !("$defs" in resolved)) {
+      resolved.$defs = schema.$defs;
+    }
+    return resolved;
+  }
+  if (Array.isArray(schema.allOf)) {
+    return _merge_all_of_schemas(schema.allOf.filter(isSchemaRecord), rootSchema);
+  }
+  return schema;
+}
+var SUPPORTED_SCHEMA_TYPES = /* @__PURE__ */ new Set(["null", "string", "integer", "number", "boolean", "array", "object"]);
+function validateSupportedSchemaTypes(schema, rootSchema, seen = /* @__PURE__ */ new WeakSet(), seenRefs = /* @__PURE__ */ new Set()) {
+  if (seen.has(schema)) {
+    return;
+  }
+  seen.add(schema);
+  if (typeof schema.$ref === "string") {
+    if (seenRefs.has(schema.$ref)) {
+      return;
+    }
+    const nextSeenRefs = new Set(seenRefs);
+    nextSeenRefs.add(schema.$ref);
+    validateSupportedSchemaTypes(_resolve_ref(schema.$ref, rootSchema), rootSchema, seen, nextSeenRefs);
+    return;
+  }
+  const resolved = effectiveSchema(schema, rootSchema);
+  if (resolved !== schema) {
+    validateSupportedSchemaTypes(resolved, rootSchema, seen, seenRefs);
+    return;
+  }
+  const typeValue = resolved.type;
+  if (typeof typeValue === "string" && !SUPPORTED_SCHEMA_TYPES.has(typeValue)) {
+    throw new Error(`Unsupported JSON schema type: ${typeValue} from ${JSON.stringify(resolved)}`);
+  }
+  if (Array.isArray(typeValue)) {
+    for (const entry of typeValue) {
+      if (typeof entry === "string" && !SUPPORTED_SCHEMA_TYPES.has(entry)) {
+        throw new Error(`Unsupported JSON schema type: ${entry} from ${JSON.stringify(resolved)}`);
+      }
+    }
+  }
+  for (const key of ["anyOf", "oneOf", "allOf"]) {
+    const variants = resolved[key];
+    if (!Array.isArray(variants)) {
+      continue;
+    }
+    for (const variant of variants) {
+      if (isSchemaRecord(variant)) {
+        validateSupportedSchemaTypes(variant, rootSchema, seen, seenRefs);
+      }
+    }
+  }
+  if (isSchemaRecord(resolved.items)) {
+    validateSupportedSchemaTypes(resolved.items, rootSchema, seen, seenRefs);
+  }
+  if (isSchemaRecord(resolved.properties)) {
+    for (const value of Object.values(resolved.properties)) {
+      if (isSchemaRecord(value)) {
+        validateSupportedSchemaTypes(value, rootSchema, seen, seenRefs);
+      }
+    }
+  }
+}
+function validateSchemaValue(schema, value, path, rootSchema, seen = /* @__PURE__ */ new Set()) {
+  const resolved = effectiveSchema(schema, rootSchema);
+  if (seen.has(resolved)) {
+    return value;
+  }
+  const nextSeen = new Set(seen);
+  nextSeen.add(resolved);
+  const variants = Array.isArray(resolved.anyOf) ? resolved.anyOf : Array.isArray(resolved.oneOf) ? resolved.oneOf : null;
+  if (variants) {
+    const errors = [];
+    for (const variant of variants) {
+      if (!isSchemaRecord(variant)) {
+        continue;
+      }
+      try {
+        return validateSchemaValue(variant, value, path, rootSchema, nextSeen);
+      } catch (error) {
+        errors.push(error instanceof Error ? error.message : String(error));
+      }
+    }
+    throw createValidationError(path, `value did not match any schema${errors.length > 0 ? ` (${errors.join("; ")})` : ""}`);
+  }
+  if ("const" in resolved && value !== resolved.const) {
+    throw createValidationError(path, `expected const ${describeValue(resolved.const)}`);
+  }
+  if (Array.isArray(resolved.enum) && !resolved.enum.includes(value)) {
+    throw createValidationError(path, `expected one of ${resolved.enum.map((entry) => describeValue(entry)).join(", ")}`);
+  }
+  const typeValue = resolved.type;
+  if (Array.isArray(typeValue)) {
+    const errors = [];
+    for (const type of typeValue) {
+      if (typeof type !== "string") {
+        continue;
+      }
+      try {
+        return validateSchemaValue({ ...resolved, type }, value, path, rootSchema, nextSeen);
+      } catch (error) {
+        errors.push(error instanceof Error ? error.message : String(error));
+      }
+    }
+    throw createValidationError(path, `value did not match any declared type${errors.length > 0 ? ` (${errors.join("; ")})` : ""}`);
+  }
+  switch (typeValue) {
+    case void 0:
+      return value;
+    case "null":
+      if (value !== null) {
+        throw createValidationError(path, "expected null");
+      }
+      return null;
+    case "string":
+      if (value instanceof Date && isDateFormatSchema(resolved)) {
+        if (Number.isNaN(value.getTime())) {
+          throw createValidationError(path, `format ${String(resolved.format)}`);
+        }
+        return value;
+      }
+      if (typeof value !== "string") {
+        throw createValidationError(path, "expected string");
+      }
+      assertStringConstraints(resolved, value, path);
+      return coerceFormattedString(resolved, value);
+    case "integer":
+      if (typeof value !== "number" || !Number.isInteger(value)) {
+        throw createValidationError(path, "expected integer");
+      }
+      assertNumberConstraints(resolved, value, path);
+      return value;
+    case "number":
+      if (typeof value !== "number" || Number.isNaN(value)) {
+        throw createValidationError(path, "expected number");
+      }
+      assertNumberConstraints(resolved, value, path);
+      return value;
+    case "boolean":
+      if (typeof value !== "boolean") {
+        throw createValidationError(path, "expected boolean");
+      }
+      return value;
+    case "array": {
+      if (!Array.isArray(value)) {
+        throw createValidationError(path, "expected array");
+      }
+      const itemSchema = isSchemaRecord(resolved.items) ? resolved.items : null;
+      const items = value;
+      return itemSchema ? items.map((item, index) => validateSchemaValue(itemSchema, item, `${path}.${String(index)}`, rootSchema, nextSeen)) : items.slice();
+    }
+    case "object": {
+      if (!isSchemaRecord(value)) {
+        throw createValidationError(path, "expected object");
+      }
+      const properties = isSchemaRecord(resolved.properties) ? resolved.properties : null;
+      if (!properties) {
+        return { ...value };
+      }
+      if (resolved.additionalProperties === false) {
+        for (const key of Object.keys(value)) {
+          if (!(key in properties)) {
+            throw createValidationError(`${path}.${key}`, "extra field not permitted");
+          }
+        }
+      }
+      const required = Array.isArray(resolved.required) ? resolved.required.filter((entry) => typeof entry === "string") : [];
+      const output = {};
+      for (const [propertyName, propertySchema] of Object.entries(properties)) {
+        if (!isSchemaRecord(propertySchema)) {
+          continue;
+        }
+        if (!(propertyName in value)) {
+          if (required.includes(propertyName)) {
+            throw createValidationError(`${path}.${propertyName}`, "field required");
+          }
+          output[propertyName] = null;
+          continue;
+        }
+        output[propertyName] = validateSchemaValue(propertySchema, value[propertyName], `${path}.${propertyName}`, rootSchema, nextSeen);
+      }
+      return output;
+    }
+    default:
+      throw new Error(`Unsupported JSON schema type: ${String(typeValue)}`);
+  }
+}
+function buildModelFields(schema, rootSchema, enrichDescriptions) {
+  const properties = isSchemaRecord(schema.properties) ? schema.properties : {};
+  const required = Array.isArray(schema.required) ? schema.required.filter((entry) => typeof entry === "string") : [];
+  const fields = {};
+  for (const [name, propertySchema] of Object.entries(properties)) {
+    if (!isSchemaRecord(propertySchema)) {
+      continue;
+    }
+    const resolved = effectiveSchema(propertySchema, rootSchema);
+    const description = enrichDescriptions ? buildRichFieldDescription(resolved) : typeof resolved.description === "string" ? resolved.description : null;
+    const field = {
+      name,
+      required: required.includes(name),
+      description,
+      schema: resolved
+    };
+    if (typeof propertySchema.$ref !== "string" && schemaTypeMatches(resolved, "object") && isSchemaRecord(resolved.properties)) {
+      field.annotation = createModelFromSchema(resolved, {
+        rootSchema,
+        modelName: typeof resolved.title === "string" ? resolved.title : `${name[0]?.toUpperCase() ?? "Nested"}${name.slice(1)}`,
+        enrichDescriptions
+      });
+    }
+    fields[name] = field;
+  }
+  return fields;
+}
+function createModelFromSchema(schemaOrName, schemaOrOptions = {}, maybeOptions = {}) {
+  let schema;
+  let options;
+  let explicitModelName;
+  if (typeof schemaOrName === "string") {
+    explicitModelName = schemaOrName;
+    schema = isSchemaRecord(schemaOrOptions) ? schemaOrOptions : {};
+    options = maybeOptions;
+  } else {
+    explicitModelName = null;
+    schema = schemaOrName;
+    options = coerceCreateModelOptions(schemaOrOptions);
+  }
+  const modelName = explicitModelName ?? options.modelName ?? options.model_name ?? (typeof schema.title === "string" ? schema.title : "DynamicModel");
+  const enrichDescriptions = options.enrichDescriptions ?? options.enrich_descriptions ?? false;
+  const rootSchema = forceAdditionalPropertiesFalse(cloneSchema(options.rootSchema ?? options.root_schema ?? schema));
+  const resolvedSchema = forceAdditionalPropertiesFalse(_inline_top_level_ref(cloneSchema(schema), rootSchema));
+  const normalizedSchema = Array.isArray(resolvedSchema.allOf) ? _merge_all_of_schemas(resolvedSchema.allOf.filter(isSchemaRecord), resolvedSchema) : resolvedSchema;
+  const effectiveRoot = isSchemaRecord(normalizedSchema.$defs) ? normalizedSchema : rootSchema;
+  validateSupportedSchemaTypes(normalizedSchema, effectiveRoot);
+  const modelFields = buildModelFields(normalizedSchema, effectiveRoot, enrichDescriptions);
+  return {
+    name: modelName,
+    __name__: modelName,
+    schema: normalizedSchema,
+    model_fields: modelFields,
+    modelFields,
+    modelValidate(value) {
+      return validateSchemaValue(normalizedSchema, value, modelName, effectiveRoot);
+    },
+    model_validate(value) {
+      return this.modelValidate(value);
+    }
+  };
+}
+var create_model_from_schema = createModelFromSchema;
+function _resolve_ref(ref, rootSchema) {
+  const defName = localDefName(ref);
+  const defs = isSchemaRecord(rootSchema.$defs) ? rootSchema.$defs : {};
+  const defSchema = defName ? defs[defName] : null;
+  if (!isSchemaRecord(defSchema)) {
+    throw new Error(`Definition '${defName ?? ref}' not found in $defs.`);
+  }
+  return cloneSchema(defSchema);
+}
+function _merge_all_of_schemas(schemas, rootSchema = {}) {
+  const merged = { type: "object", properties: {}, required: [] };
+  const requiredValues = (value) => Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+  for (const schema of schemas) {
+    const resolved = typeof schema.$ref === "string" ? _resolve_ref(schema.$ref, rootSchema) : schema;
+    Object.assign(merged, cloneSchema(resolved), {
+      properties: {
+        ...isSchemaRecord(merged.properties) ? merged.properties : {},
+        ...isSchemaRecord(resolved.properties) ? resolved.properties : {}
+      },
+      required: [...requiredValues(merged.required), ...requiredValues(resolved.required)]
+    });
+  }
+  merged.required = [...new Set(requiredValues(merged.required))];
+  return merged;
+}
+function _json_schema_to_pydantic_type(schema) {
+  const typeValue = schema.type;
+  if (typeof typeValue === "string") {
+    return typeValue;
+  }
+  if (Array.isArray(typeValue)) {
+    return typeValue.filter((entry) => typeof entry === "string").join(" | ") || "unknown";
+  }
+  return "unknown";
+}
+function _json_schema_to_pydantic_field(name, schema, required = []) {
+  return {
+    name,
+    type: _json_schema_to_pydantic_type(schema),
+    required: required.includes(name),
+    schema
+  };
+}
+function _build_model_from_schema(schema, _effectiveRoot = schema, options = {}) {
+  void _effectiveRoot;
+  return createModelFromSchema(options.model_name ?? (typeof schema.title === "string" ? schema.title : "DynamicModel"), schema);
+}
+
+export {
+  JsonSchemaInfo,
+  ModelDescription,
+  FORMAT_TYPE_MAP,
+  OPENAI_SUPPORTED_FORMATS,
+  resolveRefs,
+  addKeyInDictRecursively,
+  forceAdditionalPropertiesFalse,
+  stripUnsupportedFormats,
+  ensureTypeInSchemas,
+  fixDiscriminatorMappings,
+  addConstToOneOfVariants,
+  convertOneOfToAnyOf,
+  ensureAllPropertiesRequired,
+  stripNullFromTypes,
+  _strip_keys_recursive,
+  liftTopLevelAnyOf,
+  _common_strict_pipeline,
+  sanitizeToolParamsForOpenAIStrict,
+  sanitizeToolParamsForAnthropicStrict,
+  sanitizeToolParamsForBedrockStrict,
+  buildRichFieldDescription,
+  _inline_top_level_ref,
+  _process_oneof,
+  generateModelDescription,
+  resolve_refs,
+  add_key_in_dict_recursively,
+  force_additional_properties_false,
+  strip_unsupported_formats,
+  ensure_type_in_schemas,
+  fix_discriminator_mappings,
+  add_const_to_oneof_variants,
+  convert_oneof_to_anyof,
+  ensure_all_properties_required,
+  strip_null_from_types,
+  lift_top_level_anyof,
+  sanitize_tool_params_for_openai_strict,
+  sanitize_tool_params_for_anthropic_strict,
+  sanitize_tool_params_for_bedrock_strict,
+  build_rich_field_description,
+  generate_model_description,
+  serializeModelClass,
+  serialize_model_class,
+  createModelFromSchema,
+  create_model_from_schema,
+  _resolve_ref,
+  _merge_all_of_schemas,
+  _json_schema_to_pydantic_type,
+  _json_schema_to_pydantic_field,
+  _build_model_from_schema
+};