@langchain/core 1.2.0-dev-1765937705265 → 1.2.0-dev-1775763803878

package/dist/utils/json_schema.cjs

@@ -1,34 +1,57 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
-const require_zod = require('./types/zod.cjs');
-const require_zodToJsonSchema = require('./zod-to-json-schema/zodToJsonSchema.cjs');
-require('./zod-to-json-schema/index.cjs');
-const zod_v4_core = require_rolldown_runtime.__toESM(require("zod/v4/core"));
-const __cfworker_json_schema = require_rolldown_runtime.__toESM(require("@cfworker/json-schema"));
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_zod = require("./types/zod.cjs");
+const require_zodToJsonSchema = require("./zod-to-json-schema/zodToJsonSchema.cjs");
+require("./zod-to-json-schema/index.cjs");
+const require_utils_standard_schema = require("./standard_schema.cjs");
+let zod_v4_core = require("zod/v4/core");
+let _cfworker_json_schema = require("@cfworker/json-schema");
 //#region src/utils/json_schema.ts
-var json_schema_exports = {};
-require_rolldown_runtime.__export(json_schema_exports, {
-	Validator: () => __cfworker_json_schema.Validator,
-	deepCompareStrict: () => __cfworker_json_schema.deepCompareStrict,
+var json_schema_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	Validator: () => _cfworker_json_schema.Validator,
+	deepCompareStrict: () => _cfworker_json_schema.deepCompareStrict,
 	toJsonSchema: () => toJsonSchema,
 	validatesOnlyStrings: () => validatesOnlyStrings
 });
 /**
-* Converts a Zod schema or JSON schema to a JSON schema.
+* WeakMap cache for Zod/Standard-Schema → JSON Schema conversions.
+*
+* Keyed on the schema object reference. Since Zod schemas are immutable and
+* the same `tool.schema` reference is passed on every LLM call, this
+* eliminates redundant serializations. For example, an agent with 6 tools
+* doing 15 steps across 3 parallel subagents would otherwise run 270
+* identical conversions per invocation.
+*
+* Only used when no custom `params` are passed (the common case for tool
+* binding). WeakMap ensures cached entries are GC'd when the schema goes
+* out of scope.
+*
+* @internal
+*/
+const _jsonSchemaCache = /* @__PURE__ */ new WeakMap();
+/**
+* Converts a Standard JSON schema, Zod schema or JSON schema to a JSON schema.
+* Results are cached by schema reference when no custom params are passed.
 * @param schema - The schema to convert.
 * @param params - The parameters to pass to the toJSONSchema function.
 * @returns The converted schema.
 */
 function toJsonSchema(schema, params) {
-	if (require_zod.isZodSchemaV4(schema)) {
-		const inputSchema = require_zod.interopZodTransformInputSchema(schema, true);
-		if (require_zod.isZodObjectV4(inputSchema)) {
-			const strictSchema = require_zod.interopZodObjectStrict(inputSchema, true);
-			return (0, zod_v4_core.toJSONSchema)(strictSchema, params);
-		} else return (0, zod_v4_core.toJSONSchema)(schema, params);
+	const canCache = !params && schema != null && typeof schema === "object";
+	if (canCache) {
+		const cached = _jsonSchemaCache.get(schema);
+		if (cached) return cached;
 	}
-	if (require_zod.isZodSchemaV3(schema)) return require_zodToJsonSchema.zodToJsonSchema(schema);
-	return schema;
+	let result;
+	if (require_utils_standard_schema.isStandardJsonSchema(schema) && !require_zod.isZodSchemaV4(schema)) result = schema["~standard"].jsonSchema.input({ target: "draft-07" });
+	else if (require_zod.isZodSchemaV4(schema)) {
+		const inputSchema = require_zod.interopZodTransformInputSchema(schema, true);
+		if (require_zod.isZodObjectV4(inputSchema)) result = (0, zod_v4_core.toJSONSchema)(require_zod.interopZodObjectStrict(inputSchema, true), params);
+		else result = (0, zod_v4_core.toJSONSchema)(schema, params);
+	} else if (require_zod.isZodSchemaV3(schema)) result = require_zodToJsonSchema.zodToJsonSchema(schema);
+	else result = schema;
+	if (canCache && result != null && typeof result === "object") _jsonSchemaCache.set(schema, result);
+	return result;
 }
 /**
 * Validates if a JSON schema validates only strings. May return false negatives in some edge cases
@@ -54,32 +77,32 @@ function validatesOnlyStrings(schema) {
 	if ("not" in schema) return false;
 	if ("$ref" in schema && typeof schema.$ref === "string") {
 		const ref = schema.$ref;
-		const resolved = (0, __cfworker_json_schema.dereference)(schema);
+		const resolved = (0, _cfworker_json_schema.dereference)(schema);
 		if (resolved[ref]) return validatesOnlyStrings(resolved[ref]);
 		return false;
 	}
 	return false;
 }
-
 //#endregion
-Object.defineProperty(exports, 'Validator', {
-  enumerable: true,
-  get: function () {
-    return __cfworker_json_schema.Validator;
-  }
+Object.defineProperty(exports, "Validator", {
+	enumerable: true,
+	get: function() {
+		return _cfworker_json_schema.Validator;
+	}
 });
-Object.defineProperty(exports, 'deepCompareStrict', {
-  enumerable: true,
-  get: function () {
-    return __cfworker_json_schema.deepCompareStrict;
-  }
+Object.defineProperty(exports, "deepCompareStrict", {
+	enumerable: true,
+	get: function() {
+		return _cfworker_json_schema.deepCompareStrict;
+	}
 });
-Object.defineProperty(exports, 'json_schema_exports', {
-  enumerable: true,
-  get: function () {
-    return json_schema_exports;
-  }
+Object.defineProperty(exports, "json_schema_exports", {
+	enumerable: true,
+	get: function() {
+		return json_schema_exports;
+	}
 });
 exports.toJsonSchema = toJsonSchema;
 exports.validatesOnlyStrings = validatesOnlyStrings;
+
 //# sourceMappingURL=json_schema.cjs.map

package/dist/utils/json_schema.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"json_schema.cjs","names":["schema: InteropZodType | JSONSchema","params?: ToJSONSchemaParams","isZodSchemaV4","interopZodTransformInputSchema","isZodObjectV4","interopZodObjectStrict","isZodSchemaV3","zodToJsonSchema","schema: unknown"],"sources":["../../src/utils/json_schema.ts"],"sourcesContent":["import { toJSONSchema } from \"zod/v4/core\";\nimport { dereference, type Schema } from \"@cfworker/json-schema\";\nimport {\n  isZodSchemaV3,\n  isZodSchemaV4,\n  InteropZodType,\n  interopZodObjectStrict,\n  isZodObjectV4,\n  ZodObjectV4,\n  interopZodTransformInputSchema,\n} from \"./types/zod.js\";\nimport {\n  type JsonSchema7Type as JSONSchema,\n  zodToJsonSchema,\n} from \"./zod-to-json-schema/index.js\";\n\nexport { deepCompareStrict, Validator } from \"@cfworker/json-schema\";\n\nexport type ToJSONSchemaParams = NonNullable<\n  Parameters<typeof toJSONSchema>[1]\n>;\n\n/**\n * Converts a Zod schema or JSON schema to a JSON schema.\n * @param schema - The schema to convert.\n * @param params - The parameters to pass to the toJSONSchema function.\n * @returns The converted schema.\n */\nexport function toJsonSchema(\n  schema: InteropZodType | JSONSchema,\n  params?: ToJSONSchemaParams\n): JSONSchema {\n  if (isZodSchemaV4(schema)) {\n    const inputSchema = interopZodTransformInputSchema(schema, true);\n    if (isZodObjectV4(inputSchema)) {\n      const strictSchema = interopZodObjectStrict(\n        inputSchema,\n        true\n      ) as ZodObjectV4;\n      return toJSONSchema(strictSchema, params);\n    } else {\n      return toJSONSchema(schema, params);\n    }\n  }\n  if (isZodSchemaV3(schema)) {\n    return zodToJsonSchema(schema);\n  }\n  return schema as JSONSchema;\n}\n\n/**\n * Validates if a JSON schema validates only strings. May return false negatives in some edge cases\n * (like recursive or unresolvable refs).\n *\n * @param schema - The schema to validate.\n * @returns `true` if the schema validates only strings, `false` otherwise.\n */\nexport function validatesOnlyStrings(schema: unknown): boolean {\n  // Null, undefined, or empty schema\n  if (\n    !schema ||\n    typeof schema !== \"object\" ||\n    Object.keys(schema).length === 0 ||\n    Array.isArray(schema)\n  ) {\n    return false; // Validates anything, not just strings\n  }\n\n  // Explicit type constraint\n  if (\"type\" in schema) {\n    if (typeof schema.type === \"string\") {\n      return schema.type === \"string\";\n    }\n\n    if (Array.isArray(schema.type)) {\n      // not sure why someone would do `\"type\": [\"string\"]` or especially `\"type\": [\"string\",\n      // \"string\", \"string\", ...]` but we're not here to judge\n      return schema.type.every((t) => t === \"string\");\n    }\n    return false; // Invalid or non-string type\n  }\n\n  // Enum with only string values\n  if (\"enum\" in schema) {\n    return (\n      Array.isArray(schema.enum) &&\n      schema.enum.length > 0 &&\n      schema.enum.every((val) => typeof val === \"string\")\n    );\n  }\n\n  // String constant\n  if (\"const\" in schema) {\n    return typeof schema.const === \"string\";\n  }\n\n  // Schema combinations\n  if (\"allOf\" in schema && Array.isArray(schema.allOf)) {\n    // If any subschema validates only strings, then the overall schema validates only strings\n    return schema.allOf.some((subschema) => validatesOnlyStrings(subschema));\n  }\n\n  if (\n    (\"anyOf\" in schema && Array.isArray(schema.anyOf)) ||\n    (\"oneOf\" in schema && Array.isArray(schema.oneOf))\n  ) {\n    const subschemas = (\n      \"anyOf\" in schema ? schema.anyOf : schema.oneOf\n    ) as unknown[];\n\n    // All subschemas must validate only strings\n    return (\n      subschemas.length > 0 &&\n      subschemas.every((subschema) => validatesOnlyStrings(subschema))\n    );\n  }\n\n  // We're not going to try on this one, it's too complex - we just assume if it has a \"not\" key and hasn't matched one of the above checks, it's not a string schema.\n  if (\"not\" in schema) {\n    return false; // The not case can validate non-strings\n  }\n\n  if (\"$ref\" in schema && typeof schema.$ref === \"string\") {\n    const ref = schema.$ref as string;\n    const resolved = dereference(schema as Schema);\n    if (resolved[ref]) {\n      return validatesOnlyStrings(resolved[ref]);\n    }\n    return false;\n  }\n\n  // ignore recursive refs and other cases where type is omitted for now\n  // ignore other cases for now where type is omitted\n\n  return false;\n}\n\n// Re-export of the types used throughout langchain for json schema serialization.\n// The plan is to eventually nix zod-to-json-schema altogether in place for\n// zod v4 / a more standardized way of serializing validated inputs, so its re-exported\n// here to remove the dependency on zod-to-json-schema in downstream packages until\n// a determination is made.\n\nexport {\n  type JsonSchema7Type,\n  type JsonSchema7Type as JSONSchema,\n  type JsonSchema7ArrayType,\n  type JsonSchema7ObjectType,\n  type JsonSchema7StringType,\n  type JsonSchema7NumberType,\n  type JsonSchema7NullableType,\n} from \"./zod-to-json-schema/index.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,aACdA,QACAC,QACY;AACZ,KAAIC,0BAAc,OAAO,EAAE;EACzB,MAAM,cAAcC,2CAA+B,QAAQ,KAAK;AAChE,MAAIC,0BAAc,YAAY,EAAE;GAC9B,MAAM,eAAeC,mCACnB,aACA,KACD;AACD,wCAAoB,cAAc,OAAO;EAC1C,MACC,sCAAoB,QAAQ,OAAO;CAEtC;AACD,KAAIC,0BAAc,OAAO,CACvB,QAAOC,wCAAgB,OAAO;AAEhC,QAAO;AACR;;;;;;;;AASD,SAAgB,qBAAqBC,QAA0B;AAE7D,KACE,CAAC,UACD,OAAO,WAAW,YAClB,OAAO,KAAK,OAAO,CAAC,WAAW,KAC/B,MAAM,QAAQ,OAAO,CAErB,QAAO;AAIT,KAAI,UAAU,QAAQ;AACpB,MAAI,OAAO,OAAO,SAAS,SACzB,QAAO,OAAO,SAAS;AAGzB,MAAI,MAAM,QAAQ,OAAO,KAAK,CAG5B,QAAO,OAAO,KAAK,MAAM,CAAC,MAAM,MAAM,SAAS;AAEjD,SAAO;CACR;AAGD,KAAI,UAAU,OACZ,QACE,MAAM,QAAQ,OAAO,KAAK,IAC1B,OAAO,KAAK,SAAS,KACrB,OAAO,KAAK,MAAM,CAAC,QAAQ,OAAO,QAAQ,SAAS;AAKvD,KAAI,WAAW,OACb,QAAO,OAAO,OAAO,UAAU;AAIjC,KAAI,WAAW,UAAU,MAAM,QAAQ,OAAO,MAAM,CAElD,QAAO,OAAO,MAAM,KAAK,CAAC,cAAc,qBAAqB,UAAU,CAAC;AAG1E,KACG,WAAW,UAAU,MAAM,QAAQ,OAAO,MAAM,IAChD,WAAW,UAAU,MAAM,QAAQ,OAAO,MAAM,EACjD;EACA,MAAM,aACJ,WAAW,SAAS,OAAO,QAAQ,OAAO;AAI5C,SACE,WAAW,SAAS,KACpB,WAAW,MAAM,CAAC,cAAc,qBAAqB,UAAU,CAAC;CAEnE;AAGD,KAAI,SAAS,OACX,QAAO;AAGT,KAAI,UAAU,UAAU,OAAO,OAAO,SAAS,UAAU;EACvD,MAAM,MAAM,OAAO;EACnB,MAAM,mDAAuB,OAAiB;AAC9C,MAAI,SAAS,KACX,QAAO,qBAAqB,SAAS,KAAK;AAE5C,SAAO;CACR;AAKD,QAAO;AACR"}
+{"version":3,"file":"json_schema.cjs","names":["isStandardJsonSchema","isZodSchemaV4","interopZodTransformInputSchema","isZodObjectV4","interopZodObjectStrict","isZodSchemaV3","zodToJsonSchema"],"sources":["../../src/utils/json_schema.ts"],"sourcesContent":["import { toJSONSchema, type $ZodType } from \"zod/v4/core\";\nimport { dereference, type Schema } from \"@cfworker/json-schema\";\nimport {\n  isZodSchemaV3,\n  isZodSchemaV4,\n  InteropZodType,\n  interopZodObjectStrict,\n  isZodObjectV4,\n  interopZodTransformInputSchema,\n} from \"./types/zod.js\";\nimport {\n  type JsonSchema7Type as JSONSchema,\n  zodToJsonSchema,\n} from \"./zod-to-json-schema/index.js\";\nimport { StandardJSONSchemaV1 } from \"@standard-schema/spec\";\nimport { isStandardJsonSchema } from \"./standard_schema.js\";\n\nexport { deepCompareStrict, Validator } from \"@cfworker/json-schema\";\n\nexport type ToJSONSchemaParams = NonNullable<\n  Parameters<typeof toJSONSchema>[1]\n>;\n\n/**\n * WeakMap cache for Zod/Standard-Schema → JSON Schema conversions.\n *\n * Keyed on the schema object reference. Since Zod schemas are immutable and\n * the same `tool.schema` reference is passed on every LLM call, this\n * eliminates redundant serializations. For example, an agent with 6 tools\n * doing 15 steps across 3 parallel subagents would otherwise run 270\n * identical conversions per invocation.\n *\n * Only used when no custom `params` are passed (the common case for tool\n * binding). WeakMap ensures cached entries are GC'd when the schema goes\n * out of scope.\n *\n * @internal\n */\nconst _jsonSchemaCache = new WeakMap<object, JSONSchema>();\n\n/**\n * Converts a Standard JSON schema, Zod schema or JSON schema to a JSON schema.\n * Results are cached by schema reference when no custom params are passed.\n * @param schema - The schema to convert.\n * @param params - The parameters to pass to the toJSONSchema function.\n * @returns The converted schema.\n */\nexport function toJsonSchema(\n  schema: StandardJSONSchemaV1 | InteropZodType | JSONSchema,\n  params?: ToJSONSchemaParams\n): JSONSchema {\n  // Cache when no custom params are passed (the default for tool binding).\n  // Params can change the output (e.g., different target draft), so we\n  // bypass the cache when they're provided.\n  const canCache = !params && schema != null && typeof schema === \"object\";\n\n  if (canCache) {\n    const cached = _jsonSchemaCache.get(schema);\n    if (cached) return cached;\n  }\n\n  let result: JSONSchema;\n\n  if (isStandardJsonSchema(schema) && !isZodSchemaV4(schema)) {\n    result = schema[\"~standard\"].jsonSchema.input({\n      target: \"draft-07\",\n    }) as JSONSchema;\n  } else if (isZodSchemaV4(schema)) {\n    const inputSchema = interopZodTransformInputSchema(schema, true);\n    if (isZodObjectV4(inputSchema)) {\n      const strictSchema = interopZodObjectStrict(inputSchema, true);\n      result = toJSONSchema(strictSchema as unknown as $ZodType, params);\n    } else {\n      result = toJSONSchema(schema as unknown as $ZodType, params);\n    }\n  } else if (isZodSchemaV3(schema)) {\n    result = zodToJsonSchema(schema as never);\n  } else {\n    result = schema as JSONSchema;\n  }\n\n  if (canCache && result != null && typeof result === \"object\") {\n    _jsonSchemaCache.set(schema, result);\n  }\n\n  return result;\n}\n\n/**\n * Validates if a JSON schema validates only strings. May return false negatives in some edge cases\n * (like recursive or unresolvable refs).\n *\n * @param schema - The schema to validate.\n * @returns `true` if the schema validates only strings, `false` otherwise.\n */\nexport function validatesOnlyStrings(schema: unknown): boolean {\n  // Null, undefined, or empty schema\n  if (\n    !schema ||\n    typeof schema !== \"object\" ||\n    Object.keys(schema).length === 0 ||\n    Array.isArray(schema)\n  ) {\n    return false; // Validates anything, not just strings\n  }\n\n  // Explicit type constraint\n  if (\"type\" in schema) {\n    if (typeof schema.type === \"string\") {\n      return schema.type === \"string\";\n    }\n\n    if (Array.isArray(schema.type)) {\n      // not sure why someone would do `\"type\": [\"string\"]` or especially `\"type\": [\"string\",\n      // \"string\", \"string\", ...]` but we're not here to judge\n      return schema.type.every((t) => t === \"string\");\n    }\n    return false; // Invalid or non-string type\n  }\n\n  // Enum with only string values\n  if (\"enum\" in schema) {\n    return (\n      Array.isArray(schema.enum) &&\n      schema.enum.length > 0 &&\n      schema.enum.every((val) => typeof val === \"string\")\n    );\n  }\n\n  // String constant\n  if (\"const\" in schema) {\n    return typeof schema.const === \"string\";\n  }\n\n  // Schema combinations\n  if (\"allOf\" in schema && Array.isArray(schema.allOf)) {\n    // If any subschema validates only strings, then the overall schema validates only strings\n    return schema.allOf.some((subschema) => validatesOnlyStrings(subschema));\n  }\n\n  if (\n    (\"anyOf\" in schema && Array.isArray(schema.anyOf)) ||\n    (\"oneOf\" in schema && Array.isArray(schema.oneOf))\n  ) {\n    const subschemas = (\n      \"anyOf\" in schema ? schema.anyOf : schema.oneOf\n    ) as unknown[];\n\n    // All subschemas must validate only strings\n    return (\n      subschemas.length > 0 &&\n      subschemas.every((subschema) => validatesOnlyStrings(subschema))\n    );\n  }\n\n  // We're not going to try on this one, it's too complex - we just assume if it has a \"not\" key and hasn't matched one of the above checks, it's not a string schema.\n  if (\"not\" in schema) {\n    return false; // The not case can validate non-strings\n  }\n\n  if (\"$ref\" in schema && typeof schema.$ref === \"string\") {\n    const ref = schema.$ref as string;\n    const resolved = dereference(schema as Schema);\n    if (resolved[ref]) {\n      return validatesOnlyStrings(resolved[ref]);\n    }\n    return false;\n  }\n\n  // ignore recursive refs and other cases where type is omitted for now\n  // ignore other cases for now where type is omitted\n\n  return false;\n}\n\n// Re-export of the types used throughout langchain for json schema serialization.\n// The plan is to eventually nix zod-to-json-schema altogether in place for\n// zod v4 / a more standardized way of serializing validated inputs, so its re-exported\n// here to remove the dependency on zod-to-json-schema in downstream packages until\n// a determination is made.\n\nexport {\n  type JsonSchema7Type,\n  type JsonSchema7Type as JSONSchema,\n  type JsonSchema7ArrayType,\n  type JsonSchema7ObjectType,\n  type JsonSchema7StringType,\n  type JsonSchema7NumberType,\n  type JsonSchema7NullableType,\n} from \"./zod-to-json-schema/index.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,MAAM,mCAAmB,IAAI,SAA6B;;;;;;;;AAS1D,SAAgB,aACd,QACA,QACY;CAIZ,MAAM,WAAW,CAAC,UAAU,UAAU,QAAQ,OAAO,WAAW;AAEhE,KAAI,UAAU;EACZ,MAAM,SAAS,iBAAiB,IAAI,OAAO;AAC3C,MAAI,OAAQ,QAAO;;CAGrB,IAAI;AAEJ,KAAIA,8BAAAA,qBAAqB,OAAO,IAAI,CAACC,YAAAA,cAAc,OAAO,CACxD,UAAS,OAAO,aAAa,WAAW,MAAM,EAC5C,QAAQ,YACT,CAAC;UACOA,YAAAA,cAAc,OAAO,EAAE;EAChC,MAAM,cAAcC,YAAAA,+BAA+B,QAAQ,KAAK;AAChE,MAAIC,YAAAA,cAAc,YAAY,CAE5B,WAAA,GAAA,YAAA,cADqBC,YAAAA,uBAAuB,aAAa,KAAK,EACH,OAAO;MAElE,WAAA,GAAA,YAAA,cAAsB,QAA+B,OAAO;YAErDC,YAAAA,cAAc,OAAO,CAC9B,UAASC,wBAAAA,gBAAgB,OAAgB;KAEzC,UAAS;AAGX,KAAI,YAAY,UAAU,QAAQ,OAAO,WAAW,SAClD,kBAAiB,IAAI,QAAQ,OAAO;AAGtC,QAAO;;;;;;;;;AAUT,SAAgB,qBAAqB,QAA0B;AAE7D,KACE,CAAC,UACD,OAAO,WAAW,YAClB,OAAO,KAAK,OAAO,CAAC,WAAW,KAC/B,MAAM,QAAQ,OAAO,CAErB,QAAO;AAIT,KAAI,UAAU,QAAQ;AACpB,MAAI,OAAO,OAAO,SAAS,SACzB,QAAO,OAAO,SAAS;AAGzB,MAAI,MAAM,QAAQ,OAAO,KAAK,CAG5B,QAAO,OAAO,KAAK,OAAO,MAAM,MAAM,SAAS;AAEjD,SAAO;;AAIT,KAAI,UAAU,OACZ,QACE,MAAM,QAAQ,OAAO,KAAK,IAC1B,OAAO,KAAK,SAAS,KACrB,OAAO,KAAK,OAAO,QAAQ,OAAO,QAAQ,SAAS;AAKvD,KAAI,WAAW,OACb,QAAO,OAAO,OAAO,UAAU;AAIjC,KAAI,WAAW,UAAU,MAAM,QAAQ,OAAO,MAAM,CAElD,QAAO,OAAO,MAAM,MAAM,cAAc,qBAAqB,UAAU,CAAC;AAG1E,KACG,WAAW,UAAU,MAAM,QAAQ,OAAO,MAAM,IAChD,WAAW,UAAU,MAAM,QAAQ,OAAO,MAAM,EACjD;EACA,MAAM,aACJ,WAAW,SAAS,OAAO,QAAQ,OAAO;AAI5C,SACE,WAAW,SAAS,KACpB,WAAW,OAAO,cAAc,qBAAqB,UAAU,CAAC;;AAKpE,KAAI,SAAS,OACX,QAAO;AAGT,KAAI,UAAU,UAAU,OAAO,OAAO,SAAS,UAAU;EACvD,MAAM,MAAM,OAAO;EACnB,MAAM,YAAA,GAAA,sBAAA,aAAuB,OAAiB;AAC9C,MAAI,SAAS,KACX,QAAO,qBAAqB,SAAS,KAAK;AAE5C,SAAO;;AAMT,QAAO"}

package/dist/utils/json_schema.d.cts

@@ -5,18 +5,20 @@ import { JsonSchema7StringType } from "./zod-to-json-schema/parsers/string.cjs";
 import { JsonSchema7NullableType } from "./zod-to-json-schema/parsers/nullable.cjs";
 import { JsonSchema7ObjectType } from "./zod-to-json-schema/parsers/object.cjs";
 import { JsonSchema7Type } from "./zod-to-json-schema/parseTypes.cjs";
+import { StandardJSONSchemaV1 } from "@standard-schema/spec";
 import { toJSONSchema } from "zod/v4/core";
 import { Validator, deepCompareStrict } from "@cfworker/json-schema";
 
 //#region src/utils/json_schema.d.ts
 type ToJSONSchemaParams = NonNullable<Parameters<typeof toJSONSchema>[1]>;
 /**
- * Converts a Zod schema or JSON schema to a JSON schema.
+ * Converts a Standard JSON schema, Zod schema or JSON schema to a JSON schema.
+ * Results are cached by schema reference when no custom params are passed.
  * @param schema - The schema to convert.
  * @param params - The parameters to pass to the toJSONSchema function.
  * @returns The converted schema.
  */
-declare function toJsonSchema(schema: InteropZodType | JsonSchema7Type, params?: ToJSONSchemaParams): JsonSchema7Type;
+declare function toJsonSchema(schema: StandardJSONSchemaV1 | InteropZodType | JsonSchema7Type, params?: ToJSONSchemaParams): JsonSchema7Type;
 /**
  * Validates if a JSON schema validates only strings. May return false negatives in some edge cases
  * (like recursive or unresolvable refs).

package/dist/utils/json_schema.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"json_schema.d.cts","names":["toJSONSchema","InteropZodType","JsonSchema7Type","JSONSchema","deepCompareStrict","Validator","ToJSONSchemaParams","Parameters","NonNullable","toJsonSchema","validatesOnlyStrings","JsonSchema7ArrayType","JsonSchema7ObjectType","JsonSchema7StringType","JsonSchema7NumberType","JsonSchema7NullableType"],"sources":["../../src/utils/json_schema.d.ts"],"sourcesContent":["import { toJSONSchema } from \"zod/v4/core\";\nimport { InteropZodType } from \"./types/zod.js\";\nimport { type JsonSchema7Type as JSONSchema } from \"./zod-to-json-schema/index.js\";\nexport { deepCompareStrict, Validator } from \"@cfworker/json-schema\";\nexport type ToJSONSchemaParams = NonNullable<Parameters<typeof toJSONSchema>[1]>;\n/**\n * Converts a Zod schema or JSON schema to a JSON schema.\n * @param schema - The schema to convert.\n * @param params - The parameters to pass to the toJSONSchema function.\n * @returns The converted schema.\n */\nexport declare function toJsonSchema(schema: InteropZodType | JSONSchema, params?: ToJSONSchemaParams): JSONSchema;\n/**\n * Validates if a JSON schema validates only strings. May return false negatives in some edge cases\n * (like recursive or unresolvable refs).\n *\n * @param schema - The schema to validate.\n * @returns `true` if the schema validates only strings, `false` otherwise.\n */\nexport declare function validatesOnlyStrings(schema: unknown): boolean;\nexport { type JsonSchema7Type, type JsonSchema7Type as JSONSchema, type JsonSchema7ArrayType, type JsonSchema7ObjectType, type JsonSchema7StringType, type JsonSchema7NumberType, type JsonSchema7NullableType, } from \"./zod-to-json-schema/index.js\";\n//# sourceMappingURL=json_schema.d.ts.map"],"mappings":";;;;;;;;;;;KAIYM,kBAAAA,GAAqBE,YAAYD,kBAAkBP;;;;;;;AAAnDM,iBAOYG,YAAAA,CAPM,MAAA,EAOeR,cAPf,GAOgCE,eAPhC,EAAA,MAAA,CAAA,EAOqDG,kBAPrD,CAAA,EAO0EH,eAP1E;;;;AAAc;AAO5C;;;AAAmFG,iBAQ3DI,oBAAAA,CAR2DJ,MAAAA,EAAAA,OAAAA,CAAAA,EAAAA,OAAAA"}
+{"version":3,"file":"json_schema.d.cts","names":[],"sources":["../../src/utils/json_schema.ts"],"mappings":";;;;;;;;;;;;KAmBY,kBAAA,GAAqB,WAAA,CAC/B,UAAA,QAAkB,YAAA;;;;;;;;iBA2BJ,YAAA,CACd,MAAA,EAAQ,oBAAA,GAAuB,cAAA,GAAiB,eAAA,EAChD,MAAA,GAAS,kBAAA,GACR,eAAA;;;;;;;;iBA6Ca,oBAAA,CAAqB,MAAA"}

package/dist/utils/json_schema.d.ts

@@ -5,19 +5,20 @@ import { JsonSchema7StringType } from "./zod-to-json-schema/parsers/string.js";
 import { JsonSchema7NullableType } from "./zod-to-json-schema/parsers/nullable.js";
 import { JsonSchema7ObjectType } from "./zod-to-json-schema/parsers/object.js";
 import { JsonSchema7Type } from "./zod-to-json-schema/parseTypes.js";
-import "./zod-to-json-schema/index.js";
 import { toJSONSchema } from "zod/v4/core";
 import { Validator, deepCompareStrict } from "@cfworker/json-schema";
+import { StandardJSONSchemaV1 } from "@standard-schema/spec";
 
 //#region src/utils/json_schema.d.ts
 type ToJSONSchemaParams = NonNullable<Parameters<typeof toJSONSchema>[1]>;
 /**
- * Converts a Zod schema or JSON schema to a JSON schema.
+ * Converts a Standard JSON schema, Zod schema or JSON schema to a JSON schema.
+ * Results are cached by schema reference when no custom params are passed.
  * @param schema - The schema to convert.
  * @param params - The parameters to pass to the toJSONSchema function.
  * @returns The converted schema.
  */
-declare function toJsonSchema(schema: InteropZodType | JsonSchema7Type, params?: ToJSONSchemaParams): JsonSchema7Type;
+declare function toJsonSchema(schema: StandardJSONSchemaV1 | InteropZodType | JsonSchema7Type, params?: ToJSONSchemaParams): JsonSchema7Type;
 /**
  * Validates if a JSON schema validates only strings. May return false negatives in some edge cases
  * (like recursive or unresolvable refs).

package/dist/utils/json_schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"json_schema.d.ts","names":["toJSONSchema","InteropZodType","JsonSchema7Type","JSONSchema","deepCompareStrict","Validator","ToJSONSchemaParams","Parameters","NonNullable","toJsonSchema","validatesOnlyStrings","JsonSchema7ArrayType","JsonSchema7ObjectType","JsonSchema7StringType","JsonSchema7NumberType","JsonSchema7NullableType"],"sources":["../../src/utils/json_schema.d.ts"],"sourcesContent":["import { toJSONSchema } from \"zod/v4/core\";\nimport { InteropZodType } from \"./types/zod.js\";\nimport { type JsonSchema7Type as JSONSchema } from \"./zod-to-json-schema/index.js\";\nexport { deepCompareStrict, Validator } from \"@cfworker/json-schema\";\nexport type ToJSONSchemaParams = NonNullable<Parameters<typeof toJSONSchema>[1]>;\n/**\n * Converts a Zod schema or JSON schema to a JSON schema.\n * @param schema - The schema to convert.\n * @param params - The parameters to pass to the toJSONSchema function.\n * @returns The converted schema.\n */\nexport declare function toJsonSchema(schema: InteropZodType | JSONSchema, params?: ToJSONSchemaParams): JSONSchema;\n/**\n * Validates if a JSON schema validates only strings. May return false negatives in some edge cases\n * (like recursive or unresolvable refs).\n *\n * @param schema - The schema to validate.\n * @returns `true` if the schema validates only strings, `false` otherwise.\n */\nexport declare function validatesOnlyStrings(schema: unknown): boolean;\nexport { type JsonSchema7Type, type JsonSchema7Type as JSONSchema, type JsonSchema7ArrayType, type JsonSchema7ObjectType, type JsonSchema7StringType, type JsonSchema7NumberType, type JsonSchema7NullableType, } from \"./zod-to-json-schema/index.js\";\n//# sourceMappingURL=json_schema.d.ts.map"],"mappings":";;;;;;;;;;;;KAIYM,kBAAAA,GAAqBE,YAAYD,kBAAkBP;;;;;;;iBAOvCS,YAAAA,SAAqBR,iBAAiBE,0BAAqBG,qBAAqBH;AAPxG;;;;AAA4C;AAO5C;;AAA8DA,iBAQtCO,oBAAAA,CARsCP,MAAAA,EAAAA,OAAAA,CAAAA,EAAAA,OAAAA"}
+{"version":3,"file":"json_schema.d.ts","names":[],"sources":["../../src/utils/json_schema.ts"],"mappings":";;;;;;;;;;;;KAmBY,kBAAA,GAAqB,WAAA,CAC/B,UAAA,QAAkB,YAAA;;;;;;;;iBA2BJ,YAAA,CACd,MAAA,EAAQ,oBAAA,GAAuB,cAAA,GAAiB,eAAA,EAChD,MAAA,GAAS,kBAAA,GACR,eAAA;;;;;;;;iBA6Ca,oBAAA,CAAqB,MAAA"}

package/dist/utils/json_schema.js

@@ -1,34 +1,56 @@
-import { __export } from "../_virtual/rolldown_runtime.js";
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
 import { interopZodObjectStrict, interopZodTransformInputSchema, isZodObjectV4, isZodSchemaV3, isZodSchemaV4 } from "./types/zod.js";
 import { zodToJsonSchema } from "./zod-to-json-schema/zodToJsonSchema.js";
 import "./zod-to-json-schema/index.js";
+import { isStandardJsonSchema } from "./standard_schema.js";
 import { toJSONSchema } from "zod/v4/core";
 import { Validator, deepCompareStrict, dereference } from "@cfworker/json-schema";
-
 //#region src/utils/json_schema.ts
-var json_schema_exports = {};
-__export(json_schema_exports, {
+var json_schema_exports = /* @__PURE__ */ __exportAll({
 	Validator: () => Validator,
 	deepCompareStrict: () => deepCompareStrict,
 	toJsonSchema: () => toJsonSchema,
 	validatesOnlyStrings: () => validatesOnlyStrings
 });
 /**
-* Converts a Zod schema or JSON schema to a JSON schema.
+* WeakMap cache for Zod/Standard-Schema → JSON Schema conversions.
+*
+* Keyed on the schema object reference. Since Zod schemas are immutable and
+* the same `tool.schema` reference is passed on every LLM call, this
+* eliminates redundant serializations. For example, an agent with 6 tools
+* doing 15 steps across 3 parallel subagents would otherwise run 270
+* identical conversions per invocation.
+*
+* Only used when no custom `params` are passed (the common case for tool
+* binding). WeakMap ensures cached entries are GC'd when the schema goes
+* out of scope.
+*
+* @internal
+*/
+const _jsonSchemaCache = /* @__PURE__ */ new WeakMap();
+/**
+* Converts a Standard JSON schema, Zod schema or JSON schema to a JSON schema.
+* Results are cached by schema reference when no custom params are passed.
 * @param schema - The schema to convert.
 * @param params - The parameters to pass to the toJSONSchema function.
 * @returns The converted schema.
 */
 function toJsonSchema(schema, params) {
-	if (isZodSchemaV4(schema)) {
-		const inputSchema = interopZodTransformInputSchema(schema, true);
-		if (isZodObjectV4(inputSchema)) {
-			const strictSchema = interopZodObjectStrict(inputSchema, true);
-			return toJSONSchema(strictSchema, params);
-		} else return toJSONSchema(schema, params);
+	const canCache = !params && schema != null && typeof schema === "object";
+	if (canCache) {
+		const cached = _jsonSchemaCache.get(schema);
+		if (cached) return cached;
 	}
-	if (isZodSchemaV3(schema)) return zodToJsonSchema(schema);
-	return schema;
+	let result;
+	if (isStandardJsonSchema(schema) && !isZodSchemaV4(schema)) result = schema["~standard"].jsonSchema.input({ target: "draft-07" });
+	else if (isZodSchemaV4(schema)) {
+		const inputSchema = interopZodTransformInputSchema(schema, true);
+		if (isZodObjectV4(inputSchema)) result = toJSONSchema(interopZodObjectStrict(inputSchema, true), params);
+		else result = toJSONSchema(schema, params);
+	} else if (isZodSchemaV3(schema)) result = zodToJsonSchema(schema);
+	else result = schema;
+	if (canCache && result != null && typeof result === "object") _jsonSchemaCache.set(schema, result);
+	return result;
 }
 /**
 * Validates if a JSON schema validates only strings. May return false negatives in some edge cases
@@ -60,7 +82,7 @@ function validatesOnlyStrings(schema) {
 	}
 	return false;
 }
-
 //#endregion
 export { Validator, deepCompareStrict, json_schema_exports, toJsonSchema, validatesOnlyStrings };
+
 //# sourceMappingURL=json_schema.js.map

package/dist/utils/json_schema.js.map

@@ -1 +1 @@
-{"version":3,"file":"json_schema.js","names":["schema: InteropZodType | JSONSchema","params?: ToJSONSchemaParams","schema: unknown"],"sources":["../../src/utils/json_schema.ts"],"sourcesContent":["import { toJSONSchema } from \"zod/v4/core\";\nimport { dereference, type Schema } from \"@cfworker/json-schema\";\nimport {\n  isZodSchemaV3,\n  isZodSchemaV4,\n  InteropZodType,\n  interopZodObjectStrict,\n  isZodObjectV4,\n  ZodObjectV4,\n  interopZodTransformInputSchema,\n} from \"./types/zod.js\";\nimport {\n  type JsonSchema7Type as JSONSchema,\n  zodToJsonSchema,\n} from \"./zod-to-json-schema/index.js\";\n\nexport { deepCompareStrict, Validator } from \"@cfworker/json-schema\";\n\nexport type ToJSONSchemaParams = NonNullable<\n  Parameters<typeof toJSONSchema>[1]\n>;\n\n/**\n * Converts a Zod schema or JSON schema to a JSON schema.\n * @param schema - The schema to convert.\n * @param params - The parameters to pass to the toJSONSchema function.\n * @returns The converted schema.\n */\nexport function toJsonSchema(\n  schema: InteropZodType | JSONSchema,\n  params?: ToJSONSchemaParams\n): JSONSchema {\n  if (isZodSchemaV4(schema)) {\n    const inputSchema = interopZodTransformInputSchema(schema, true);\n    if (isZodObjectV4(inputSchema)) {\n      const strictSchema = interopZodObjectStrict(\n        inputSchema,\n        true\n      ) as ZodObjectV4;\n      return toJSONSchema(strictSchema, params);\n    } else {\n      return toJSONSchema(schema, params);\n    }\n  }\n  if (isZodSchemaV3(schema)) {\n    return zodToJsonSchema(schema);\n  }\n  return schema as JSONSchema;\n}\n\n/**\n * Validates if a JSON schema validates only strings. May return false negatives in some edge cases\n * (like recursive or unresolvable refs).\n *\n * @param schema - The schema to validate.\n * @returns `true` if the schema validates only strings, `false` otherwise.\n */\nexport function validatesOnlyStrings(schema: unknown): boolean {\n  // Null, undefined, or empty schema\n  if (\n    !schema ||\n    typeof schema !== \"object\" ||\n    Object.keys(schema).length === 0 ||\n    Array.isArray(schema)\n  ) {\n    return false; // Validates anything, not just strings\n  }\n\n  // Explicit type constraint\n  if (\"type\" in schema) {\n    if (typeof schema.type === \"string\") {\n      return schema.type === \"string\";\n    }\n\n    if (Array.isArray(schema.type)) {\n      // not sure why someone would do `\"type\": [\"string\"]` or especially `\"type\": [\"string\",\n      // \"string\", \"string\", ...]` but we're not here to judge\n      return schema.type.every((t) => t === \"string\");\n    }\n    return false; // Invalid or non-string type\n  }\n\n  // Enum with only string values\n  if (\"enum\" in schema) {\n    return (\n      Array.isArray(schema.enum) &&\n      schema.enum.length > 0 &&\n      schema.enum.every((val) => typeof val === \"string\")\n    );\n  }\n\n  // String constant\n  if (\"const\" in schema) {\n    return typeof schema.const === \"string\";\n  }\n\n  // Schema combinations\n  if (\"allOf\" in schema && Array.isArray(schema.allOf)) {\n    // If any subschema validates only strings, then the overall schema validates only strings\n    return schema.allOf.some((subschema) => validatesOnlyStrings(subschema));\n  }\n\n  if (\n    (\"anyOf\" in schema && Array.isArray(schema.anyOf)) ||\n    (\"oneOf\" in schema && Array.isArray(schema.oneOf))\n  ) {\n    const subschemas = (\n      \"anyOf\" in schema ? schema.anyOf : schema.oneOf\n    ) as unknown[];\n\n    // All subschemas must validate only strings\n    return (\n      subschemas.length > 0 &&\n      subschemas.every((subschema) => validatesOnlyStrings(subschema))\n    );\n  }\n\n  // We're not going to try on this one, it's too complex - we just assume if it has a \"not\" key and hasn't matched one of the above checks, it's not a string schema.\n  if (\"not\" in schema) {\n    return false; // The not case can validate non-strings\n  }\n\n  if (\"$ref\" in schema && typeof schema.$ref === \"string\") {\n    const ref = schema.$ref as string;\n    const resolved = dereference(schema as Schema);\n    if (resolved[ref]) {\n      return validatesOnlyStrings(resolved[ref]);\n    }\n    return false;\n  }\n\n  // ignore recursive refs and other cases where type is omitted for now\n  // ignore other cases for now where type is omitted\n\n  return false;\n}\n\n// Re-export of the types used throughout langchain for json schema serialization.\n// The plan is to eventually nix zod-to-json-schema altogether in place for\n// zod v4 / a more standardized way of serializing validated inputs, so its re-exported\n// here to remove the dependency on zod-to-json-schema in downstream packages until\n// a determination is made.\n\nexport {\n  type JsonSchema7Type,\n  type JsonSchema7Type as JSONSchema,\n  type JsonSchema7ArrayType,\n  type JsonSchema7ObjectType,\n  type JsonSchema7StringType,\n  type JsonSchema7NumberType,\n  type JsonSchema7NullableType,\n} from \"./zod-to-json-schema/index.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,aACdA,QACAC,QACY;AACZ,KAAI,cAAc,OAAO,EAAE;EACzB,MAAM,cAAc,+BAA+B,QAAQ,KAAK;AAChE,MAAI,cAAc,YAAY,EAAE;GAC9B,MAAM,eAAe,uBACnB,aACA,KACD;AACD,UAAO,aAAa,cAAc,OAAO;EAC1C,MACC,QAAO,aAAa,QAAQ,OAAO;CAEtC;AACD,KAAI,cAAc,OAAO,CACvB,QAAO,gBAAgB,OAAO;AAEhC,QAAO;AACR;;;;;;;;AASD,SAAgB,qBAAqBC,QAA0B;AAE7D,KACE,CAAC,UACD,OAAO,WAAW,YAClB,OAAO,KAAK,OAAO,CAAC,WAAW,KAC/B,MAAM,QAAQ,OAAO,CAErB,QAAO;AAIT,KAAI,UAAU,QAAQ;AACpB,MAAI,OAAO,OAAO,SAAS,SACzB,QAAO,OAAO,SAAS;AAGzB,MAAI,MAAM,QAAQ,OAAO,KAAK,CAG5B,QAAO,OAAO,KAAK,MAAM,CAAC,MAAM,MAAM,SAAS;AAEjD,SAAO;CACR;AAGD,KAAI,UAAU,OACZ,QACE,MAAM,QAAQ,OAAO,KAAK,IAC1B,OAAO,KAAK,SAAS,KACrB,OAAO,KAAK,MAAM,CAAC,QAAQ,OAAO,QAAQ,SAAS;AAKvD,KAAI,WAAW,OACb,QAAO,OAAO,OAAO,UAAU;AAIjC,KAAI,WAAW,UAAU,MAAM,QAAQ,OAAO,MAAM,CAElD,QAAO,OAAO,MAAM,KAAK,CAAC,cAAc,qBAAqB,UAAU,CAAC;AAG1E,KACG,WAAW,UAAU,MAAM,QAAQ,OAAO,MAAM,IAChD,WAAW,UAAU,MAAM,QAAQ,OAAO,MAAM,EACjD;EACA,MAAM,aACJ,WAAW,SAAS,OAAO,QAAQ,OAAO;AAI5C,SACE,WAAW,SAAS,KACpB,WAAW,MAAM,CAAC,cAAc,qBAAqB,UAAU,CAAC;CAEnE;AAGD,KAAI,SAAS,OACX,QAAO;AAGT,KAAI,UAAU,UAAU,OAAO,OAAO,SAAS,UAAU;EACvD,MAAM,MAAM,OAAO;EACnB,MAAM,WAAW,YAAY,OAAiB;AAC9C,MAAI,SAAS,KACX,QAAO,qBAAqB,SAAS,KAAK;AAE5C,SAAO;CACR;AAKD,QAAO;AACR"}
+{"version":3,"file":"json_schema.js","names":[],"sources":["../../src/utils/json_schema.ts"],"sourcesContent":["import { toJSONSchema, type $ZodType } from \"zod/v4/core\";\nimport { dereference, type Schema } from \"@cfworker/json-schema\";\nimport {\n  isZodSchemaV3,\n  isZodSchemaV4,\n  InteropZodType,\n  interopZodObjectStrict,\n  isZodObjectV4,\n  interopZodTransformInputSchema,\n} from \"./types/zod.js\";\nimport {\n  type JsonSchema7Type as JSONSchema,\n  zodToJsonSchema,\n} from \"./zod-to-json-schema/index.js\";\nimport { StandardJSONSchemaV1 } from \"@standard-schema/spec\";\nimport { isStandardJsonSchema } from \"./standard_schema.js\";\n\nexport { deepCompareStrict, Validator } from \"@cfworker/json-schema\";\n\nexport type ToJSONSchemaParams = NonNullable<\n  Parameters<typeof toJSONSchema>[1]\n>;\n\n/**\n * WeakMap cache for Zod/Standard-Schema → JSON Schema conversions.\n *\n * Keyed on the schema object reference. Since Zod schemas are immutable and\n * the same `tool.schema` reference is passed on every LLM call, this\n * eliminates redundant serializations. For example, an agent with 6 tools\n * doing 15 steps across 3 parallel subagents would otherwise run 270\n * identical conversions per invocation.\n *\n * Only used when no custom `params` are passed (the common case for tool\n * binding). WeakMap ensures cached entries are GC'd when the schema goes\n * out of scope.\n *\n * @internal\n */\nconst _jsonSchemaCache = new WeakMap<object, JSONSchema>();\n\n/**\n * Converts a Standard JSON schema, Zod schema or JSON schema to a JSON schema.\n * Results are cached by schema reference when no custom params are passed.\n * @param schema - The schema to convert.\n * @param params - The parameters to pass to the toJSONSchema function.\n * @returns The converted schema.\n */\nexport function toJsonSchema(\n  schema: StandardJSONSchemaV1 | InteropZodType | JSONSchema,\n  params?: ToJSONSchemaParams\n): JSONSchema {\n  // Cache when no custom params are passed (the default for tool binding).\n  // Params can change the output (e.g., different target draft), so we\n  // bypass the cache when they're provided.\n  const canCache = !params && schema != null && typeof schema === \"object\";\n\n  if (canCache) {\n    const cached = _jsonSchemaCache.get(schema);\n    if (cached) return cached;\n  }\n\n  let result: JSONSchema;\n\n  if (isStandardJsonSchema(schema) && !isZodSchemaV4(schema)) {\n    result = schema[\"~standard\"].jsonSchema.input({\n      target: \"draft-07\",\n    }) as JSONSchema;\n  } else if (isZodSchemaV4(schema)) {\n    const inputSchema = interopZodTransformInputSchema(schema, true);\n    if (isZodObjectV4(inputSchema)) {\n      const strictSchema = interopZodObjectStrict(inputSchema, true);\n      result = toJSONSchema(strictSchema as unknown as $ZodType, params);\n    } else {\n      result = toJSONSchema(schema as unknown as $ZodType, params);\n    }\n  } else if (isZodSchemaV3(schema)) {\n    result = zodToJsonSchema(schema as never);\n  } else {\n    result = schema as JSONSchema;\n  }\n\n  if (canCache && result != null && typeof result === \"object\") {\n    _jsonSchemaCache.set(schema, result);\n  }\n\n  return result;\n}\n\n/**\n * Validates if a JSON schema validates only strings. May return false negatives in some edge cases\n * (like recursive or unresolvable refs).\n *\n * @param schema - The schema to validate.\n * @returns `true` if the schema validates only strings, `false` otherwise.\n */\nexport function validatesOnlyStrings(schema: unknown): boolean {\n  // Null, undefined, or empty schema\n  if (\n    !schema ||\n    typeof schema !== \"object\" ||\n    Object.keys(schema).length === 0 ||\n    Array.isArray(schema)\n  ) {\n    return false; // Validates anything, not just strings\n  }\n\n  // Explicit type constraint\n  if (\"type\" in schema) {\n    if (typeof schema.type === \"string\") {\n      return schema.type === \"string\";\n    }\n\n    if (Array.isArray(schema.type)) {\n      // not sure why someone would do `\"type\": [\"string\"]` or especially `\"type\": [\"string\",\n      // \"string\", \"string\", ...]` but we're not here to judge\n      return schema.type.every((t) => t === \"string\");\n    }\n    return false; // Invalid or non-string type\n  }\n\n  // Enum with only string values\n  if (\"enum\" in schema) {\n    return (\n      Array.isArray(schema.enum) &&\n      schema.enum.length > 0 &&\n      schema.enum.every((val) => typeof val === \"string\")\n    );\n  }\n\n  // String constant\n  if (\"const\" in schema) {\n    return typeof schema.const === \"string\";\n  }\n\n  // Schema combinations\n  if (\"allOf\" in schema && Array.isArray(schema.allOf)) {\n    // If any subschema validates only strings, then the overall schema validates only strings\n    return schema.allOf.some((subschema) => validatesOnlyStrings(subschema));\n  }\n\n  if (\n    (\"anyOf\" in schema && Array.isArray(schema.anyOf)) ||\n    (\"oneOf\" in schema && Array.isArray(schema.oneOf))\n  ) {\n    const subschemas = (\n      \"anyOf\" in schema ? schema.anyOf : schema.oneOf\n    ) as unknown[];\n\n    // All subschemas must validate only strings\n    return (\n      subschemas.length > 0 &&\n      subschemas.every((subschema) => validatesOnlyStrings(subschema))\n    );\n  }\n\n  // We're not going to try on this one, it's too complex - we just assume if it has a \"not\" key and hasn't matched one of the above checks, it's not a string schema.\n  if (\"not\" in schema) {\n    return false; // The not case can validate non-strings\n  }\n\n  if (\"$ref\" in schema && typeof schema.$ref === \"string\") {\n    const ref = schema.$ref as string;\n    const resolved = dereference(schema as Schema);\n    if (resolved[ref]) {\n      return validatesOnlyStrings(resolved[ref]);\n    }\n    return false;\n  }\n\n  // ignore recursive refs and other cases where type is omitted for now\n  // ignore other cases for now where type is omitted\n\n  return false;\n}\n\n// Re-export of the types used throughout langchain for json schema serialization.\n// The plan is to eventually nix zod-to-json-schema altogether in place for\n// zod v4 / a more standardized way of serializing validated inputs, so its re-exported\n// here to remove the dependency on zod-to-json-schema in downstream packages until\n// a determination is made.\n\nexport {\n  type JsonSchema7Type,\n  type JsonSchema7Type as JSONSchema,\n  type JsonSchema7ArrayType,\n  type JsonSchema7ObjectType,\n  type JsonSchema7StringType,\n  type JsonSchema7NumberType,\n  type JsonSchema7NullableType,\n} from \"./zod-to-json-schema/index.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,MAAM,mCAAmB,IAAI,SAA6B;;;;;;;;AAS1D,SAAgB,aACd,QACA,QACY;CAIZ,MAAM,WAAW,CAAC,UAAU,UAAU,QAAQ,OAAO,WAAW;AAEhE,KAAI,UAAU;EACZ,MAAM,SAAS,iBAAiB,IAAI,OAAO;AAC3C,MAAI,OAAQ,QAAO;;CAGrB,IAAI;AAEJ,KAAI,qBAAqB,OAAO,IAAI,CAAC,cAAc,OAAO,CACxD,UAAS,OAAO,aAAa,WAAW,MAAM,EAC5C,QAAQ,YACT,CAAC;UACO,cAAc,OAAO,EAAE;EAChC,MAAM,cAAc,+BAA+B,QAAQ,KAAK;AAChE,MAAI,cAAc,YAAY,CAE5B,UAAS,aADY,uBAAuB,aAAa,KAAK,EACH,OAAO;MAElE,UAAS,aAAa,QAA+B,OAAO;YAErD,cAAc,OAAO,CAC9B,UAAS,gBAAgB,OAAgB;KAEzC,UAAS;AAGX,KAAI,YAAY,UAAU,QAAQ,OAAO,WAAW,SAClD,kBAAiB,IAAI,QAAQ,OAAO;AAGtC,QAAO;;;;;;;;;AAUT,SAAgB,qBAAqB,QAA0B;AAE7D,KACE,CAAC,UACD,OAAO,WAAW,YAClB,OAAO,KAAK,OAAO,CAAC,WAAW,KAC/B,MAAM,QAAQ,OAAO,CAErB,QAAO;AAIT,KAAI,UAAU,QAAQ;AACpB,MAAI,OAAO,OAAO,SAAS,SACzB,QAAO,OAAO,SAAS;AAGzB,MAAI,MAAM,QAAQ,OAAO,KAAK,CAG5B,QAAO,OAAO,KAAK,OAAO,MAAM,MAAM,SAAS;AAEjD,SAAO;;AAIT,KAAI,UAAU,OACZ,QACE,MAAM,QAAQ,OAAO,KAAK,IAC1B,OAAO,KAAK,SAAS,KACrB,OAAO,KAAK,OAAO,QAAQ,OAAO,QAAQ,SAAS;AAKvD,KAAI,WAAW,OACb,QAAO,OAAO,OAAO,UAAU;AAIjC,KAAI,WAAW,UAAU,MAAM,QAAQ,OAAO,MAAM,CAElD,QAAO,OAAO,MAAM,MAAM,cAAc,qBAAqB,UAAU,CAAC;AAG1E,KACG,WAAW,UAAU,MAAM,QAAQ,OAAO,MAAM,IAChD,WAAW,UAAU,MAAM,QAAQ,OAAO,MAAM,EACjD;EACA,MAAM,aACJ,WAAW,SAAS,OAAO,QAAQ,OAAO;AAI5C,SACE,WAAW,SAAS,KACpB,WAAW,OAAO,cAAc,qBAAqB,UAAU,CAAC;;AAKpE,KAAI,SAAS,OACX,QAAO;AAGT,KAAI,UAAU,UAAU,OAAO,OAAO,SAAS,UAAU;EACvD,MAAM,MAAM,OAAO;EACnB,MAAM,WAAW,YAAY,OAAiB;AAC9C,MAAI,SAAS,KACX,QAAO,qBAAqB,SAAS,KAAK;AAE5C,SAAO;;AAMT,QAAO"}

package/dist/utils/math.cjs

@@ -1,14 +1,13 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
-const require_similarities = require('./ml-distance/similarities.cjs');
-const require_distances = require('./ml-distance/distances.cjs');
-const require_euclidean = require('./ml-distance-euclidean/euclidean.cjs');
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_similarities = require("./ml-distance/similarities.cjs");
+const require_distances = require("./ml-distance/distances.cjs");
+const require_euclidean = require("./ml-distance-euclidean/euclidean.cjs");
 //#region src/utils/math.ts
-var math_exports = {};
-require_rolldown_runtime.__export(math_exports, {
+var math_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	cosineSimilarity: () => cosineSimilarity,
 	euclideanDistance: () => euclideanDistance,
-	innerProduct: () => innerProduct$1,
+	innerProduct: () => innerProduct,
 	matrixFunc: () => matrixFunc,
 	maximalMarginalRelevance: () => maximalMarginalRelevance,
 	normalize: () => normalize
@@ -46,7 +45,7 @@ function normalize(M, similarity = false) {
 function cosineSimilarity(X, Y) {
 	return matrixFunc(X, Y, require_similarities.cosine);
 }
-function innerProduct$1(X, Y) {
+function innerProduct(X, Y) {
 	return matrixFunc(X, Y, require_distances.innerProduct);
 }
 function euclideanDistance(X, Y) {
@@ -65,8 +64,7 @@ function euclideanDistance(X, Y) {
 */
 function maximalMarginalRelevance(queryEmbedding, embeddingList, lambda = .5, k = 4) {
 	if (Math.min(k, embeddingList.length) <= 0) return [];
-	const queryEmbeddingExpanded = Array.isArray(queryEmbedding[0]) ? queryEmbedding : [queryEmbedding];
-	const similarityToQuery = cosineSimilarity(queryEmbeddingExpanded, embeddingList)[0];
+	const similarityToQuery = cosineSimilarity(Array.isArray(queryEmbedding[0]) ? queryEmbedding : [queryEmbedding], embeddingList)[0];
 	const mostSimilarEmbeddingIndex = argMax(similarityToQuery).maxIndex;
 	const selectedEmbeddings = [embeddingList[mostSimilarEmbeddingIndex]];
 	const selectedEmbeddingsIndexes = [mostSimilarEmbeddingIndex];
@@ -113,18 +111,18 @@ function argMax(array) {
 function matrixMaxVal(arrays) {
 	return arrays.reduce((acc, array) => Math.max(acc, argMax(array).maxValue), 0);
 }
-
 //#endregion
 exports.cosineSimilarity = cosineSimilarity;
 exports.euclideanDistance = euclideanDistance;
-exports.innerProduct = innerProduct$1;
-Object.defineProperty(exports, 'math_exports', {
-  enumerable: true,
-  get: function () {
-    return math_exports;
-  }
+exports.innerProduct = innerProduct;
+Object.defineProperty(exports, "math_exports", {
+	enumerable: true,
+	get: function() {
+		return math_exports;
+	}
 });
 exports.matrixFunc = matrixFunc;
 exports.maximalMarginalRelevance = maximalMarginalRelevance;
 exports.normalize = normalize;
+
 //# sourceMappingURL=math.cjs.map

package/dist/utils/math.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"math.cjs","names":["X: number[][]","Y: number[][]","func: VectorFunction","M: number[][]","cosine","innerProduct","innerProductDistance","euclidean","queryEmbedding: number[] | number[][]","embeddingList: number[][]","array: number[]","arrays: number[][]"],"sources":["../../src/utils/math.ts"],"sourcesContent":["import { cosine } from \"./ml-distance/similarities.js\";\nimport { innerProduct as innerProductDistance } from \"./ml-distance/distances.js\";\nimport { euclidean } from \"./ml-distance-euclidean/euclidean.js\";\n\ntype VectorFunction = (xVector: number[], yVector: number[]) => number;\n\n/**\n * Apply a row-wise function between two matrices with the same number of columns.\n *\n * @param {number[][]} X - The first matrix.\n * @param {number[][]} Y - The second matrix.\n * @param {VectorFunction} func - The function to apply.\n *\n * @throws {Error} If the number of columns in X and Y are not the same.\n *\n * @returns {number[][] | [[]]} A matrix where each row represents the result of applying the function between the corresponding rows of X and Y.\n */\n\nexport function matrixFunc(\n  X: number[][],\n  Y: number[][],\n  func: VectorFunction\n): number[][] {\n  if (\n    X.length === 0 ||\n    X[0].length === 0 ||\n    Y.length === 0 ||\n    Y[0].length === 0\n  ) {\n    return [[]];\n  }\n\n  if (X[0].length !== Y[0].length) {\n    throw new Error(\n      `Number of columns in X and Y must be the same. X has shape ${[\n        X.length,\n        X[0].length,\n      ]} and Y has shape ${[Y.length, Y[0].length]}.`\n    );\n  }\n\n  return X.map((xVector) =>\n    Y.map((yVector) => func(xVector, yVector)).map((similarity) =>\n      Number.isNaN(similarity) ? 0 : similarity\n    )\n  );\n}\n\nexport function normalize(M: number[][], similarity = false): number[][] {\n  const max = matrixMaxVal(M);\n  return M.map((row) =>\n    row.map((val) => (similarity ? 1 - val / max : val / max))\n  );\n}\n\n/**\n * This function calculates the row-wise cosine similarity between two matrices with the same number of columns.\n *\n * @param {number[][]} X - The first matrix.\n * @param {number[][]} Y - The second matrix.\n *\n * @throws {Error} If the number of columns in X and Y are not the same.\n *\n * @returns {number[][] | [[]]} A matrix where each row represents the cosine similarity values between the corresponding rows of X and Y.\n */\nexport function cosineSimilarity(X: number[][], Y: number[][]): number[][] {\n  return matrixFunc(X, Y, cosine);\n}\n\nexport function innerProduct(X: number[][], Y: number[][]): number[][] {\n  return matrixFunc(X, Y, innerProductDistance);\n}\n\nexport function euclideanDistance(X: number[][], Y: number[][]): number[][] {\n  return matrixFunc(X, Y, euclidean);\n}\n\n/**\n * This function implements the Maximal Marginal Relevance algorithm\n * to select a set of embeddings that maximizes the diversity and relevance to a query embedding.\n *\n * @param {number[]|number[][]} queryEmbedding - The query embedding.\n * @param {number[][]} embeddingList - The list of embeddings to select from.\n * @param {number} [lambda=0.5] - The trade-off parameter between relevance and diversity.\n * @param {number} [k=4] - The maximum number of embeddings to select.\n *\n * @returns {number[]} The indexes of the selected embeddings in the embeddingList.\n */\nexport function maximalMarginalRelevance(\n  queryEmbedding: number[] | number[][],\n  embeddingList: number[][],\n  lambda = 0.5,\n  k = 4\n): number[] {\n  if (Math.min(k, embeddingList.length) <= 0) {\n    return [];\n  }\n\n  const queryEmbeddingExpanded = (\n    Array.isArray(queryEmbedding[0]) ? queryEmbedding : [queryEmbedding]\n  ) as number[][];\n\n  const similarityToQuery = cosineSimilarity(\n    queryEmbeddingExpanded,\n    embeddingList\n  )[0];\n  const mostSimilarEmbeddingIndex = argMax(similarityToQuery).maxIndex;\n\n  const selectedEmbeddings = [embeddingList[mostSimilarEmbeddingIndex]];\n  const selectedEmbeddingsIndexes = [mostSimilarEmbeddingIndex];\n\n  while (selectedEmbeddingsIndexes.length < Math.min(k, embeddingList.length)) {\n    let bestScore = -Infinity;\n    let bestIndex = -1;\n\n    const similarityToSelected = cosineSimilarity(\n      embeddingList,\n      selectedEmbeddings\n    );\n\n    similarityToQuery.forEach((queryScore, queryScoreIndex) => {\n      if (selectedEmbeddingsIndexes.includes(queryScoreIndex)) {\n        return;\n      }\n      const maxSimilarityToSelected = Math.max(\n        ...similarityToSelected[queryScoreIndex]\n      );\n      const score =\n        lambda * queryScore - (1 - lambda) * maxSimilarityToSelected;\n\n      if (score > bestScore) {\n        bestScore = score;\n        bestIndex = queryScoreIndex;\n      }\n    });\n    selectedEmbeddings.push(embeddingList[bestIndex]);\n    selectedEmbeddingsIndexes.push(bestIndex);\n  }\n\n  return selectedEmbeddingsIndexes;\n}\n\ntype MaxInfo = {\n  maxIndex: number;\n  maxValue: number;\n};\n\n/**\n * Finds the index of the maximum value in the given array.\n * @param {number[]} array - The input array.\n *\n * @returns {number} The index of the maximum value in the array. If the array is empty, returns -1.\n */\nfunction argMax(array: number[]): MaxInfo {\n  if (array.length === 0) {\n    return {\n      maxIndex: -1,\n      maxValue: NaN,\n    };\n  }\n\n  let maxValue = array[0];\n  let maxIndex = 0;\n\n  for (let i = 1; i < array.length; i += 1) {\n    if (array[i] > maxValue) {\n      maxIndex = i;\n      maxValue = array[i];\n    }\n  }\n  return { maxIndex, maxValue };\n}\n\nfunction matrixMaxVal(arrays: number[][]): number {\n  return arrays.reduce(\n    (acc, array) => Math.max(acc, argMax(array).maxValue),\n    0\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAkBA,SAAgB,WACdA,GACAC,GACAC,MACY;AACZ,KACE,EAAE,WAAW,KACb,EAAE,GAAG,WAAW,KAChB,EAAE,WAAW,KACb,EAAE,GAAG,WAAW,EAEhB,QAAO,CAAC,CAAE,CAAC;AAGb,KAAI,EAAE,GAAG,WAAW,EAAE,GAAG,OACvB,OAAM,IAAI,MACR,CAAC,2DAA2D,EAAE,CAC5D,EAAE,QACF,EAAE,GAAG,MACN,EAAC,iBAAiB,EAAE,CAAC,EAAE,QAAQ,EAAE,GAAG,MAAO,EAAC,CAAC,CAAC;AAInD,QAAO,EAAE,IAAI,CAAC,YACZ,EAAE,IAAI,CAAC,YAAY,KAAK,SAAS,QAAQ,CAAC,CAAC,IAAI,CAAC,eAC9C,OAAO,MAAM,WAAW,GAAG,IAAI,WAChC,CACF;AACF;AAED,SAAgB,UAAUC,GAAe,aAAa,OAAmB;CACvE,MAAM,MAAM,aAAa,EAAE;AAC3B,QAAO,EAAE,IAAI,CAAC,QACZ,IAAI,IAAI,CAAC,QAAS,aAAa,IAAI,MAAM,MAAM,MAAM,IAAK,CAC3D;AACF;;;;;;;;;;;AAYD,SAAgB,iBAAiBH,GAAeC,GAA2B;AACzE,QAAO,WAAW,GAAG,GAAGG,4BAAO;AAChC;AAED,SAAgBC,eAAaL,GAAeC,GAA2B;AACrE,QAAO,WAAW,GAAG,GAAGK,+BAAqB;AAC9C;AAED,SAAgB,kBAAkBN,GAAeC,GAA2B;AAC1E,QAAO,WAAW,GAAG,GAAGM,4BAAU;AACnC;;;;;;;;;;;;AAaD,SAAgB,yBACdC,gBACAC,eACA,SAAS,IACT,IAAI,GACM;AACV,KAAI,KAAK,IAAI,GAAG,cAAc,OAAO,IAAI,EACvC,QAAO,CAAE;CAGX,MAAM,yBACJ,MAAM,QAAQ,eAAe,GAAG,GAAG,iBAAiB,CAAC,cAAe;CAGtE,MAAM,oBAAoB,iBACxB,wBACA,cACD,CAAC;CACF,MAAM,4BAA4B,OAAO,kBAAkB,CAAC;CAE5D,MAAM,qBAAqB,CAAC,cAAc,0BAA2B;CACrE,MAAM,4BAA4B,CAAC,yBAA0B;AAE7D,QAAO,0BAA0B,SAAS,KAAK,IAAI,GAAG,cAAc,OAAO,EAAE;EAC3E,IAAI,YAAY;EAChB,IAAI,YAAY;EAEhB,MAAM,uBAAuB,iBAC3B,eACA,mBACD;EAED,kBAAkB,QAAQ,CAAC,YAAY,oBAAoB;AACzD,OAAI,0BAA0B,SAAS,gBAAgB,CACrD;GAEF,MAAM,0BAA0B,KAAK,IACnC,GAAG,qBAAqB,iBACzB;GACD,MAAM,QACJ,SAAS,cAAc,IAAI,UAAU;AAEvC,OAAI,QAAQ,WAAW;IACrB,YAAY;IACZ,YAAY;GACb;EACF,EAAC;EACF,mBAAmB,KAAK,cAAc,WAAW;EACjD,0BAA0B,KAAK,UAAU;CAC1C;AAED,QAAO;AACR;;;;;;;AAaD,SAAS,OAAOC,OAA0B;AACxC,KAAI,MAAM,WAAW,EACnB,QAAO;EACL,UAAU;EACV,UAAU;CACX;CAGH,IAAI,WAAW,MAAM;CACrB,IAAI,WAAW;AAEf,MAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,EACrC,KAAI,MAAM,KAAK,UAAU;EACvB,WAAW;EACX,WAAW,MAAM;CAClB;AAEH,QAAO;EAAE;EAAU;CAAU;AAC9B;AAED,SAAS,aAAaC,QAA4B;AAChD,QAAO,OAAO,OACZ,CAAC,KAAK,UAAU,KAAK,IAAI,KAAK,OAAO,MAAM,CAAC,SAAS,EACrD,EACD;AACF"}
+{"version":3,"file":"math.cjs","names":["cosine","innerProductDistance","euclidean"],"sources":["../../src/utils/math.ts"],"sourcesContent":["import { cosine } from \"./ml-distance/similarities.js\";\nimport { innerProduct as innerProductDistance } from \"./ml-distance/distances.js\";\nimport { euclidean } from \"./ml-distance-euclidean/euclidean.js\";\n\ntype VectorFunction = (xVector: number[], yVector: number[]) => number;\n\n/**\n * Apply a row-wise function between two matrices with the same number of columns.\n *\n * @param {number[][]} X - The first matrix.\n * @param {number[][]} Y - The second matrix.\n * @param {VectorFunction} func - The function to apply.\n *\n * @throws {Error} If the number of columns in X and Y are not the same.\n *\n * @returns {number[][] | [[]]} A matrix where each row represents the result of applying the function between the corresponding rows of X and Y.\n */\n\nexport function matrixFunc(\n  X: number[][],\n  Y: number[][],\n  func: VectorFunction\n): number[][] {\n  if (\n    X.length === 0 ||\n    X[0].length === 0 ||\n    Y.length === 0 ||\n    Y[0].length === 0\n  ) {\n    return [[]];\n  }\n\n  if (X[0].length !== Y[0].length) {\n    throw new Error(\n      `Number of columns in X and Y must be the same. X has shape ${[\n        X.length,\n        X[0].length,\n      ]} and Y has shape ${[Y.length, Y[0].length]}.`\n    );\n  }\n\n  return X.map((xVector) =>\n    Y.map((yVector) => func(xVector, yVector)).map((similarity) =>\n      Number.isNaN(similarity) ? 0 : similarity\n    )\n  );\n}\n\nexport function normalize(M: number[][], similarity = false): number[][] {\n  const max = matrixMaxVal(M);\n  return M.map((row) =>\n    row.map((val) => (similarity ? 1 - val / max : val / max))\n  );\n}\n\n/**\n * This function calculates the row-wise cosine similarity between two matrices with the same number of columns.\n *\n * @param {number[][]} X - The first matrix.\n * @param {number[][]} Y - The second matrix.\n *\n * @throws {Error} If the number of columns in X and Y are not the same.\n *\n * @returns {number[][] | [[]]} A matrix where each row represents the cosine similarity values between the corresponding rows of X and Y.\n */\nexport function cosineSimilarity(X: number[][], Y: number[][]): number[][] {\n  return matrixFunc(X, Y, cosine);\n}\n\nexport function innerProduct(X: number[][], Y: number[][]): number[][] {\n  return matrixFunc(X, Y, innerProductDistance);\n}\n\nexport function euclideanDistance(X: number[][], Y: number[][]): number[][] {\n  return matrixFunc(X, Y, euclidean);\n}\n\n/**\n * This function implements the Maximal Marginal Relevance algorithm\n * to select a set of embeddings that maximizes the diversity and relevance to a query embedding.\n *\n * @param {number[]|number[][]} queryEmbedding - The query embedding.\n * @param {number[][]} embeddingList - The list of embeddings to select from.\n * @param {number} [lambda=0.5] - The trade-off parameter between relevance and diversity.\n * @param {number} [k=4] - The maximum number of embeddings to select.\n *\n * @returns {number[]} The indexes of the selected embeddings in the embeddingList.\n */\nexport function maximalMarginalRelevance(\n  queryEmbedding: number[] | number[][],\n  embeddingList: number[][],\n  lambda = 0.5,\n  k = 4\n): number[] {\n  if (Math.min(k, embeddingList.length) <= 0) {\n    return [];\n  }\n\n  const queryEmbeddingExpanded = (\n    Array.isArray(queryEmbedding[0]) ? queryEmbedding : [queryEmbedding]\n  ) as number[][];\n\n  const similarityToQuery = cosineSimilarity(\n    queryEmbeddingExpanded,\n    embeddingList\n  )[0];\n  const mostSimilarEmbeddingIndex = argMax(similarityToQuery).maxIndex;\n\n  const selectedEmbeddings = [embeddingList[mostSimilarEmbeddingIndex]];\n  const selectedEmbeddingsIndexes = [mostSimilarEmbeddingIndex];\n\n  while (selectedEmbeddingsIndexes.length < Math.min(k, embeddingList.length)) {\n    let bestScore = -Infinity;\n    let bestIndex = -1;\n\n    const similarityToSelected = cosineSimilarity(\n      embeddingList,\n      selectedEmbeddings\n    );\n\n    similarityToQuery.forEach((queryScore, queryScoreIndex) => {\n      if (selectedEmbeddingsIndexes.includes(queryScoreIndex)) {\n        return;\n      }\n      const maxSimilarityToSelected = Math.max(\n        ...similarityToSelected[queryScoreIndex]\n      );\n      const score =\n        lambda * queryScore - (1 - lambda) * maxSimilarityToSelected;\n\n      if (score > bestScore) {\n        bestScore = score;\n        bestIndex = queryScoreIndex;\n      }\n    });\n    selectedEmbeddings.push(embeddingList[bestIndex]);\n    selectedEmbeddingsIndexes.push(bestIndex);\n  }\n\n  return selectedEmbeddingsIndexes;\n}\n\ntype MaxInfo = {\n  maxIndex: number;\n  maxValue: number;\n};\n\n/**\n * Finds the index of the maximum value in the given array.\n * @param {number[]} array - The input array.\n *\n * @returns {number} The index of the maximum value in the array. If the array is empty, returns -1.\n */\nfunction argMax(array: number[]): MaxInfo {\n  if (array.length === 0) {\n    return {\n      maxIndex: -1,\n      maxValue: NaN,\n    };\n  }\n\n  let maxValue = array[0];\n  let maxIndex = 0;\n\n  for (let i = 1; i < array.length; i += 1) {\n    if (array[i] > maxValue) {\n      maxIndex = i;\n      maxValue = array[i];\n    }\n  }\n  return { maxIndex, maxValue };\n}\n\nfunction matrixMaxVal(arrays: number[][]): number {\n  return arrays.reduce(\n    (acc, array) => Math.max(acc, argMax(array).maxValue),\n    0\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAkBA,SAAgB,WACd,GACA,GACA,MACY;AACZ,KACE,EAAE,WAAW,KACb,EAAE,GAAG,WAAW,KAChB,EAAE,WAAW,KACb,EAAE,GAAG,WAAW,EAEhB,QAAO,CAAC,EAAE,CAAC;AAGb,KAAI,EAAE,GAAG,WAAW,EAAE,GAAG,OACvB,OAAM,IAAI,MACR,8DAA8D,CAC5D,EAAE,QACF,EAAE,GAAG,OACN,CAAC,mBAAmB,CAAC,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,GAC9C;AAGH,QAAO,EAAE,KAAK,YACZ,EAAE,KAAK,YAAY,KAAK,SAAS,QAAQ,CAAC,CAAC,KAAK,eAC9C,OAAO,MAAM,WAAW,GAAG,IAAI,WAChC,CACF;;AAGH,SAAgB,UAAU,GAAe,aAAa,OAAmB;CACvE,MAAM,MAAM,aAAa,EAAE;AAC3B,QAAO,EAAE,KAAK,QACZ,IAAI,KAAK,QAAS,aAAa,IAAI,MAAM,MAAM,MAAM,IAAK,CAC3D;;;;;;;;;;;;AAaH,SAAgB,iBAAiB,GAAe,GAA2B;AACzE,QAAO,WAAW,GAAG,GAAGA,qBAAAA,OAAO;;AAGjC,SAAgB,aAAa,GAAe,GAA2B;AACrE,QAAO,WAAW,GAAG,GAAGC,kBAAAA,aAAqB;;AAG/C,SAAgB,kBAAkB,GAAe,GAA2B;AAC1E,QAAO,WAAW,GAAG,GAAGC,kBAAAA,UAAU;;;;;;;;;;;;;AAcpC,SAAgB,yBACd,gBACA,eACA,SAAS,IACT,IAAI,GACM;AACV,KAAI,KAAK,IAAI,GAAG,cAAc,OAAO,IAAI,EACvC,QAAO,EAAE;CAOX,MAAM,oBAAoB,iBAHxB,MAAM,QAAQ,eAAe,GAAG,GAAG,iBAAiB,CAAC,eAAe,EAKpE,cACD,CAAC;CACF,MAAM,4BAA4B,OAAO,kBAAkB,CAAC;CAE5D,MAAM,qBAAqB,CAAC,cAAc,2BAA2B;CACrE,MAAM,4BAA4B,CAAC,0BAA0B;AAE7D,QAAO,0BAA0B,SAAS,KAAK,IAAI,GAAG,cAAc,OAAO,EAAE;EAC3E,IAAI,YAAY;EAChB,IAAI,YAAY;EAEhB,MAAM,uBAAuB,iBAC3B,eACA,mBACD;AAED,oBAAkB,SAAS,YAAY,oBAAoB;AACzD,OAAI,0BAA0B,SAAS,gBAAgB,CACrD;GAEF,MAAM,0BAA0B,KAAK,IACnC,GAAG,qBAAqB,iBACzB;GACD,MAAM,QACJ,SAAS,cAAc,IAAI,UAAU;AAEvC,OAAI,QAAQ,WAAW;AACrB,gBAAY;AACZ,gBAAY;;IAEd;AACF,qBAAmB,KAAK,cAAc,WAAW;AACjD,4BAA0B,KAAK,UAAU;;AAG3C,QAAO;;;;;;;;AAcT,SAAS,OAAO,OAA0B;AACxC,KAAI,MAAM,WAAW,EACnB,QAAO;EACL,UAAU;EACV,UAAU;EACX;CAGH,IAAI,WAAW,MAAM;CACrB,IAAI,WAAW;AAEf,MAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,EACrC,KAAI,MAAM,KAAK,UAAU;AACvB,aAAW;AACX,aAAW,MAAM;;AAGrB,QAAO;EAAE;EAAU;EAAU;;AAG/B,SAAS,aAAa,QAA4B;AAChD,QAAO,OAAO,QACX,KAAK,UAAU,KAAK,IAAI,KAAK,OAAO,MAAM,CAAC,SAAS,EACrD,EACD"}

package/dist/utils/math.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"math.d.cts","names":["VectorFunction","matrixFunc","normalize","cosineSimilarity","innerProduct","euclideanDistance","maximalMarginalRelevance"],"sources":["../../src/utils/math.d.ts"],"sourcesContent":["type VectorFunction = (xVector: number[], yVector: number[]) => number;\n/**\n * Apply a row-wise function between two matrices with the same number of columns.\n *\n * @param {number[][]} X - The first matrix.\n * @param {number[][]} Y - The second matrix.\n * @param {VectorFunction} func - The function to apply.\n *\n * @throws {Error} If the number of columns in X and Y are not the same.\n *\n * @returns {number[][] | [[]]} A matrix where each row represents the result of applying the function between the corresponding rows of X and Y.\n */\nexport declare function matrixFunc(X: number[][], Y: number[][], func: VectorFunction): number[][];\nexport declare function normalize(M: number[][], similarity?: boolean): number[][];\n/**\n * This function calculates the row-wise cosine similarity between two matrices with the same number of columns.\n *\n * @param {number[][]} X - The first matrix.\n * @param {number[][]} Y - The second matrix.\n *\n * @throws {Error} If the number of columns in X and Y are not the same.\n *\n * @returns {number[][] | [[]]} A matrix where each row represents the cosine similarity values between the corresponding rows of X and Y.\n */\nexport declare function cosineSimilarity(X: number[][], Y: number[][]): number[][];\nexport declare function innerProduct(X: number[][], Y: number[][]): number[][];\nexport declare function euclideanDistance(X: number[][], Y: number[][]): number[][];\n/**\n * This function implements the Maximal Marginal Relevance algorithm\n * to select a set of embeddings that maximizes the diversity and relevance to a query embedding.\n *\n * @param {number[]|number[][]} queryEmbedding - The query embedding.\n * @param {number[][]} embeddingList - The list of embeddings to select from.\n * @param {number} [lambda=0.5] - The trade-off parameter between relevance and diversity.\n * @param {number} [k=4] - The maximum number of embeddings to select.\n *\n * @returns {number[]} The indexes of the selected embeddings in the embeddingList.\n */\nexport declare function maximalMarginalRelevance(queryEmbedding: number[] | number[][], embeddingList: number[][], lambda?: number, k?: number): number[];\nexport {};\n//# sourceMappingURL=math.d.ts.map"],"mappings":";KAAKA,cAAAA;;AAYL;AACA;AAWA;AACA;AACA;AAYA;;;;;iBA1BwBC,UAAAA,qCAA+CD;iBAC/CE,SAAAA;;;;;;;;;;;iBAWAC,gBAAAA;iBACAC,YAAAA;iBACAC,iBAAAA;;;;;;;;;;;;iBAYAC,wBAAAA"}
+{"version":3,"file":"math.d.cts","names":[],"sources":["../../src/utils/math.ts"],"mappings":";KAIK,cAAA,IAAkB,OAAA,YAAmB,OAAA;;;;;;AAc1C;;;;;;iBAAgB,UAAA,CACd,CAAA,cACA,CAAA,cACA,IAAA,EAAM,cAAA;AAAA,iBA2BQ,SAAA,CAAU,CAAA,cAAe,UAAA;;;AAAzC;;;;;AAiBA;;;iBAAgB,gBAAA,CAAiB,CAAA,cAAe,CAAA;AAAA,iBAIhC,YAAA,CAAa,CAAA,cAAe,CAAA;AAAA,iBAI5B,iBAAA,CAAkB,CAAA,cAAe,CAAA;;;;;AAAjD;;;;;AAeA;;iBAAgB,wBAAA,CACd,cAAA,yBACA,aAAA,cACA,MAAA,WACA,CAAA"}

package/dist/utils/math.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"math.d.ts","names":["VectorFunction","matrixFunc","normalize","cosineSimilarity","innerProduct","euclideanDistance","maximalMarginalRelevance"],"sources":["../../src/utils/math.d.ts"],"sourcesContent":["type VectorFunction = (xVector: number[], yVector: number[]) => number;\n/**\n * Apply a row-wise function between two matrices with the same number of columns.\n *\n * @param {number[][]} X - The first matrix.\n * @param {number[][]} Y - The second matrix.\n * @param {VectorFunction} func - The function to apply.\n *\n * @throws {Error} If the number of columns in X and Y are not the same.\n *\n * @returns {number[][] | [[]]} A matrix where each row represents the result of applying the function between the corresponding rows of X and Y.\n */\nexport declare function matrixFunc(X: number[][], Y: number[][], func: VectorFunction): number[][];\nexport declare function normalize(M: number[][], similarity?: boolean): number[][];\n/**\n * This function calculates the row-wise cosine similarity between two matrices with the same number of columns.\n *\n * @param {number[][]} X - The first matrix.\n * @param {number[][]} Y - The second matrix.\n *\n * @throws {Error} If the number of columns in X and Y are not the same.\n *\n * @returns {number[][] | [[]]} A matrix where each row represents the cosine similarity values between the corresponding rows of X and Y.\n */\nexport declare function cosineSimilarity(X: number[][], Y: number[][]): number[][];\nexport declare function innerProduct(X: number[][], Y: number[][]): number[][];\nexport declare function euclideanDistance(X: number[][], Y: number[][]): number[][];\n/**\n * This function implements the Maximal Marginal Relevance algorithm\n * to select a set of embeddings that maximizes the diversity and relevance to a query embedding.\n *\n * @param {number[]|number[][]} queryEmbedding - The query embedding.\n * @param {number[][]} embeddingList - The list of embeddings to select from.\n * @param {number} [lambda=0.5] - The trade-off parameter between relevance and diversity.\n * @param {number} [k=4] - The maximum number of embeddings to select.\n *\n * @returns {number[]} The indexes of the selected embeddings in the embeddingList.\n */\nexport declare function maximalMarginalRelevance(queryEmbedding: number[] | number[][], embeddingList: number[][], lambda?: number, k?: number): number[];\nexport {};\n//# sourceMappingURL=math.d.ts.map"],"mappings":";KAAKA,cAAAA;;AAYL;AACA;AAWA;AACA;AACA;AAYA;;;;;iBA1BwBC,UAAAA,qCAA+CD;iBAC/CE,SAAAA;;;;;;;;;;;iBAWAC,gBAAAA;iBACAC,YAAAA;iBACAC,iBAAAA;;;;;;;;;;;;iBAYAC,wBAAAA"}
+{"version":3,"file":"math.d.ts","names":[],"sources":["../../src/utils/math.ts"],"mappings":";KAIK,cAAA,IAAkB,OAAA,YAAmB,OAAA;;;;;;AAc1C;;;;;;iBAAgB,UAAA,CACd,CAAA,cACA,CAAA,cACA,IAAA,EAAM,cAAA;AAAA,iBA2BQ,SAAA,CAAU,CAAA,cAAe,UAAA;;;AAAzC;;;;;AAiBA;;;iBAAgB,gBAAA,CAAiB,CAAA,cAAe,CAAA;AAAA,iBAIhC,YAAA,CAAa,CAAA,cAAe,CAAA;AAAA,iBAI5B,iBAAA,CAAkB,CAAA,cAAe,CAAA;;;;;AAAjD;;;;;AAeA;;iBAAgB,wBAAA,CACd,cAAA,yBACA,aAAA,cACA,MAAA,WACA,CAAA"}

package/dist/utils/math.js

@@ -1,14 +1,12 @@
-import { __export } from "../_virtual/rolldown_runtime.js";
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
 import { cosine } from "./ml-distance/similarities.js";
-import { innerProduct } from "./ml-distance/distances.js";
+import { innerProduct as innerProduct$1 } from "./ml-distance/distances.js";
 import { euclidean } from "./ml-distance-euclidean/euclidean.js";
-
 //#region src/utils/math.ts
-var math_exports = {};
-__export(math_exports, {
+var math_exports = /* @__PURE__ */ __exportAll({
 	cosineSimilarity: () => cosineSimilarity,
 	euclideanDistance: () => euclideanDistance,
-	innerProduct: () => innerProduct$1,
+	innerProduct: () => innerProduct,
 	matrixFunc: () => matrixFunc,
 	maximalMarginalRelevance: () => maximalMarginalRelevance,
 	normalize: () => normalize
@@ -46,8 +44,8 @@ function normalize(M, similarity = false) {
 function cosineSimilarity(X, Y) {
 	return matrixFunc(X, Y, cosine);
 }
-function innerProduct$1(X, Y) {
-	return matrixFunc(X, Y, innerProduct);
+function innerProduct(X, Y) {
+	return matrixFunc(X, Y, innerProduct$1);
 }
 function euclideanDistance(X, Y) {
 	return matrixFunc(X, Y, euclidean);
@@ -65,8 +63,7 @@ function euclideanDistance(X, Y) {
 */
 function maximalMarginalRelevance(queryEmbedding, embeddingList, lambda = .5, k = 4) {
 	if (Math.min(k, embeddingList.length) <= 0) return [];
-	const queryEmbeddingExpanded = Array.isArray(queryEmbedding[0]) ? queryEmbedding : [queryEmbedding];
-	const similarityToQuery = cosineSimilarity(queryEmbeddingExpanded, embeddingList)[0];
+	const similarityToQuery = cosineSimilarity(Array.isArray(queryEmbedding[0]) ? queryEmbedding : [queryEmbedding], embeddingList)[0];
 	const mostSimilarEmbeddingIndex = argMax(similarityToQuery).maxIndex;
 	const selectedEmbeddings = [embeddingList[mostSimilarEmbeddingIndex]];
 	const selectedEmbeddingsIndexes = [mostSimilarEmbeddingIndex];
@@ -113,7 +110,7 @@ function argMax(array) {
 function matrixMaxVal(arrays) {
 	return arrays.reduce((acc, array) => Math.max(acc, argMax(array).maxValue), 0);
 }
-
 //#endregion
-export { cosineSimilarity, euclideanDistance, innerProduct$1 as innerProduct, math_exports, matrixFunc, maximalMarginalRelevance, normalize };
+export { cosineSimilarity, euclideanDistance, innerProduct, math_exports, matrixFunc, maximalMarginalRelevance, normalize };
+
 //# sourceMappingURL=math.js.map

package/dist/utils/math.js.map

@@ -1 +1 @@
-{"version":3,"file":"math.js","names":["X: number[][]","Y: number[][]","func: VectorFunction","M: number[][]","innerProduct","innerProductDistance","queryEmbedding: number[] | number[][]","embeddingList: number[][]","array: number[]","arrays: number[][]"],"sources":["../../src/utils/math.ts"],"sourcesContent":["import { cosine } from \"./ml-distance/similarities.js\";\nimport { innerProduct as innerProductDistance } from \"./ml-distance/distances.js\";\nimport { euclidean } from \"./ml-distance-euclidean/euclidean.js\";\n\ntype VectorFunction = (xVector: number[], yVector: number[]) => number;\n\n/**\n * Apply a row-wise function between two matrices with the same number of columns.\n *\n * @param {number[][]} X - The first matrix.\n * @param {number[][]} Y - The second matrix.\n * @param {VectorFunction} func - The function to apply.\n *\n * @throws {Error} If the number of columns in X and Y are not the same.\n *\n * @returns {number[][] | [[]]} A matrix where each row represents the result of applying the function between the corresponding rows of X and Y.\n */\n\nexport function matrixFunc(\n  X: number[][],\n  Y: number[][],\n  func: VectorFunction\n): number[][] {\n  if (\n    X.length === 0 ||\n    X[0].length === 0 ||\n    Y.length === 0 ||\n    Y[0].length === 0\n  ) {\n    return [[]];\n  }\n\n  if (X[0].length !== Y[0].length) {\n    throw new Error(\n      `Number of columns in X and Y must be the same. X has shape ${[\n        X.length,\n        X[0].length,\n      ]} and Y has shape ${[Y.length, Y[0].length]}.`\n    );\n  }\n\n  return X.map((xVector) =>\n    Y.map((yVector) => func(xVector, yVector)).map((similarity) =>\n      Number.isNaN(similarity) ? 0 : similarity\n    )\n  );\n}\n\nexport function normalize(M: number[][], similarity = false): number[][] {\n  const max = matrixMaxVal(M);\n  return M.map((row) =>\n    row.map((val) => (similarity ? 1 - val / max : val / max))\n  );\n}\n\n/**\n * This function calculates the row-wise cosine similarity between two matrices with the same number of columns.\n *\n * @param {number[][]} X - The first matrix.\n * @param {number[][]} Y - The second matrix.\n *\n * @throws {Error} If the number of columns in X and Y are not the same.\n *\n * @returns {number[][] | [[]]} A matrix where each row represents the cosine similarity values between the corresponding rows of X and Y.\n */\nexport function cosineSimilarity(X: number[][], Y: number[][]): number[][] {\n  return matrixFunc(X, Y, cosine);\n}\n\nexport function innerProduct(X: number[][], Y: number[][]): number[][] {\n  return matrixFunc(X, Y, innerProductDistance);\n}\n\nexport function euclideanDistance(X: number[][], Y: number[][]): number[][] {\n  return matrixFunc(X, Y, euclidean);\n}\n\n/**\n * This function implements the Maximal Marginal Relevance algorithm\n * to select a set of embeddings that maximizes the diversity and relevance to a query embedding.\n *\n * @param {number[]|number[][]} queryEmbedding - The query embedding.\n * @param {number[][]} embeddingList - The list of embeddings to select from.\n * @param {number} [lambda=0.5] - The trade-off parameter between relevance and diversity.\n * @param {number} [k=4] - The maximum number of embeddings to select.\n *\n * @returns {number[]} The indexes of the selected embeddings in the embeddingList.\n */\nexport function maximalMarginalRelevance(\n  queryEmbedding: number[] | number[][],\n  embeddingList: number[][],\n  lambda = 0.5,\n  k = 4\n): number[] {\n  if (Math.min(k, embeddingList.length) <= 0) {\n    return [];\n  }\n\n  const queryEmbeddingExpanded = (\n    Array.isArray(queryEmbedding[0]) ? queryEmbedding : [queryEmbedding]\n  ) as number[][];\n\n  const similarityToQuery = cosineSimilarity(\n    queryEmbeddingExpanded,\n    embeddingList\n  )[0];\n  const mostSimilarEmbeddingIndex = argMax(similarityToQuery).maxIndex;\n\n  const selectedEmbeddings = [embeddingList[mostSimilarEmbeddingIndex]];\n  const selectedEmbeddingsIndexes = [mostSimilarEmbeddingIndex];\n\n  while (selectedEmbeddingsIndexes.length < Math.min(k, embeddingList.length)) {\n    let bestScore = -Infinity;\n    let bestIndex = -1;\n\n    const similarityToSelected = cosineSimilarity(\n      embeddingList,\n      selectedEmbeddings\n    );\n\n    similarityToQuery.forEach((queryScore, queryScoreIndex) => {\n      if (selectedEmbeddingsIndexes.includes(queryScoreIndex)) {\n        return;\n      }\n      const maxSimilarityToSelected = Math.max(\n        ...similarityToSelected[queryScoreIndex]\n      );\n      const score =\n        lambda * queryScore - (1 - lambda) * maxSimilarityToSelected;\n\n      if (score > bestScore) {\n        bestScore = score;\n        bestIndex = queryScoreIndex;\n      }\n    });\n    selectedEmbeddings.push(embeddingList[bestIndex]);\n    selectedEmbeddingsIndexes.push(bestIndex);\n  }\n\n  return selectedEmbeddingsIndexes;\n}\n\ntype MaxInfo = {\n  maxIndex: number;\n  maxValue: number;\n};\n\n/**\n * Finds the index of the maximum value in the given array.\n * @param {number[]} array - The input array.\n *\n * @returns {number} The index of the maximum value in the array. If the array is empty, returns -1.\n */\nfunction argMax(array: number[]): MaxInfo {\n  if (array.length === 0) {\n    return {\n      maxIndex: -1,\n      maxValue: NaN,\n    };\n  }\n\n  let maxValue = array[0];\n  let maxIndex = 0;\n\n  for (let i = 1; i < array.length; i += 1) {\n    if (array[i] > maxValue) {\n      maxIndex = i;\n      maxValue = array[i];\n    }\n  }\n  return { maxIndex, maxValue };\n}\n\nfunction matrixMaxVal(arrays: number[][]): number {\n  return arrays.reduce(\n    (acc, array) => Math.max(acc, argMax(array).maxValue),\n    0\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAkBA,SAAgB,WACdA,GACAC,GACAC,MACY;AACZ,KACE,EAAE,WAAW,KACb,EAAE,GAAG,WAAW,KAChB,EAAE,WAAW,KACb,EAAE,GAAG,WAAW,EAEhB,QAAO,CAAC,CAAE,CAAC;AAGb,KAAI,EAAE,GAAG,WAAW,EAAE,GAAG,OACvB,OAAM,IAAI,MACR,CAAC,2DAA2D,EAAE,CAC5D,EAAE,QACF,EAAE,GAAG,MACN,EAAC,iBAAiB,EAAE,CAAC,EAAE,QAAQ,EAAE,GAAG,MAAO,EAAC,CAAC,CAAC;AAInD,QAAO,EAAE,IAAI,CAAC,YACZ,EAAE,IAAI,CAAC,YAAY,KAAK,SAAS,QAAQ,CAAC,CAAC,IAAI,CAAC,eAC9C,OAAO,MAAM,WAAW,GAAG,IAAI,WAChC,CACF;AACF;AAED,SAAgB,UAAUC,GAAe,aAAa,OAAmB;CACvE,MAAM,MAAM,aAAa,EAAE;AAC3B,QAAO,EAAE,IAAI,CAAC,QACZ,IAAI,IAAI,CAAC,QAAS,aAAa,IAAI,MAAM,MAAM,MAAM,IAAK,CAC3D;AACF;;;;;;;;;;;AAYD,SAAgB,iBAAiBH,GAAeC,GAA2B;AACzE,QAAO,WAAW,GAAG,GAAG,OAAO;AAChC;AAED,SAAgBG,eAAaJ,GAAeC,GAA2B;AACrE,QAAO,WAAW,GAAG,GAAGI,aAAqB;AAC9C;AAED,SAAgB,kBAAkBL,GAAeC,GAA2B;AAC1E,QAAO,WAAW,GAAG,GAAG,UAAU;AACnC;;;;;;;;;;;;AAaD,SAAgB,yBACdK,gBACAC,eACA,SAAS,IACT,IAAI,GACM;AACV,KAAI,KAAK,IAAI,GAAG,cAAc,OAAO,IAAI,EACvC,QAAO,CAAE;CAGX,MAAM,yBACJ,MAAM,QAAQ,eAAe,GAAG,GAAG,iBAAiB,CAAC,cAAe;CAGtE,MAAM,oBAAoB,iBACxB,wBACA,cACD,CAAC;CACF,MAAM,4BAA4B,OAAO,kBAAkB,CAAC;CAE5D,MAAM,qBAAqB,CAAC,cAAc,0BAA2B;CACrE,MAAM,4BAA4B,CAAC,yBAA0B;AAE7D,QAAO,0BAA0B,SAAS,KAAK,IAAI,GAAG,cAAc,OAAO,EAAE;EAC3E,IAAI,YAAY;EAChB,IAAI,YAAY;EAEhB,MAAM,uBAAuB,iBAC3B,eACA,mBACD;EAED,kBAAkB,QAAQ,CAAC,YAAY,oBAAoB;AACzD,OAAI,0BAA0B,SAAS,gBAAgB,CACrD;GAEF,MAAM,0BAA0B,KAAK,IACnC,GAAG,qBAAqB,iBACzB;GACD,MAAM,QACJ,SAAS,cAAc,IAAI,UAAU;AAEvC,OAAI,QAAQ,WAAW;IACrB,YAAY;IACZ,YAAY;GACb;EACF,EAAC;EACF,mBAAmB,KAAK,cAAc,WAAW;EACjD,0BAA0B,KAAK,UAAU;CAC1C;AAED,QAAO;AACR;;;;;;;AAaD,SAAS,OAAOC,OAA0B;AACxC,KAAI,MAAM,WAAW,EACnB,QAAO;EACL,UAAU;EACV,UAAU;CACX;CAGH,IAAI,WAAW,MAAM;CACrB,IAAI,WAAW;AAEf,MAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,EACrC,KAAI,MAAM,KAAK,UAAU;EACvB,WAAW;EACX,WAAW,MAAM;CAClB;AAEH,QAAO;EAAE;EAAU;CAAU;AAC9B;AAED,SAAS,aAAaC,QAA4B;AAChD,QAAO,OAAO,OACZ,CAAC,KAAK,UAAU,KAAK,IAAI,KAAK,OAAO,MAAM,CAAC,SAAS,EACrD,EACD;AACF"}
+{"version":3,"file":"math.js","names":["innerProductDistance"],"sources":["../../src/utils/math.ts"],"sourcesContent":["import { cosine } from \"./ml-distance/similarities.js\";\nimport { innerProduct as innerProductDistance } from \"./ml-distance/distances.js\";\nimport { euclidean } from \"./ml-distance-euclidean/euclidean.js\";\n\ntype VectorFunction = (xVector: number[], yVector: number[]) => number;\n\n/**\n * Apply a row-wise function between two matrices with the same number of columns.\n *\n * @param {number[][]} X - The first matrix.\n * @param {number[][]} Y - The second matrix.\n * @param {VectorFunction} func - The function to apply.\n *\n * @throws {Error} If the number of columns in X and Y are not the same.\n *\n * @returns {number[][] | [[]]} A matrix where each row represents the result of applying the function between the corresponding rows of X and Y.\n */\n\nexport function matrixFunc(\n  X: number[][],\n  Y: number[][],\n  func: VectorFunction\n): number[][] {\n  if (\n    X.length === 0 ||\n    X[0].length === 0 ||\n    Y.length === 0 ||\n    Y[0].length === 0\n  ) {\n    return [[]];\n  }\n\n  if (X[0].length !== Y[0].length) {\n    throw new Error(\n      `Number of columns in X and Y must be the same. X has shape ${[\n        X.length,\n        X[0].length,\n      ]} and Y has shape ${[Y.length, Y[0].length]}.`\n    );\n  }\n\n  return X.map((xVector) =>\n    Y.map((yVector) => func(xVector, yVector)).map((similarity) =>\n      Number.isNaN(similarity) ? 0 : similarity\n    )\n  );\n}\n\nexport function normalize(M: number[][], similarity = false): number[][] {\n  const max = matrixMaxVal(M);\n  return M.map((row) =>\n    row.map((val) => (similarity ? 1 - val / max : val / max))\n  );\n}\n\n/**\n * This function calculates the row-wise cosine similarity between two matrices with the same number of columns.\n *\n * @param {number[][]} X - The first matrix.\n * @param {number[][]} Y - The second matrix.\n *\n * @throws {Error} If the number of columns in X and Y are not the same.\n *\n * @returns {number[][] | [[]]} A matrix where each row represents the cosine similarity values between the corresponding rows of X and Y.\n */\nexport function cosineSimilarity(X: number[][], Y: number[][]): number[][] {\n  return matrixFunc(X, Y, cosine);\n}\n\nexport function innerProduct(X: number[][], Y: number[][]): number[][] {\n  return matrixFunc(X, Y, innerProductDistance);\n}\n\nexport function euclideanDistance(X: number[][], Y: number[][]): number[][] {\n  return matrixFunc(X, Y, euclidean);\n}\n\n/**\n * This function implements the Maximal Marginal Relevance algorithm\n * to select a set of embeddings that maximizes the diversity and relevance to a query embedding.\n *\n * @param {number[]|number[][]} queryEmbedding - The query embedding.\n * @param {number[][]} embeddingList - The list of embeddings to select from.\n * @param {number} [lambda=0.5] - The trade-off parameter between relevance and diversity.\n * @param {number} [k=4] - The maximum number of embeddings to select.\n *\n * @returns {number[]} The indexes of the selected embeddings in the embeddingList.\n */\nexport function maximalMarginalRelevance(\n  queryEmbedding: number[] | number[][],\n  embeddingList: number[][],\n  lambda = 0.5,\n  k = 4\n): number[] {\n  if (Math.min(k, embeddingList.length) <= 0) {\n    return [];\n  }\n\n  const queryEmbeddingExpanded = (\n    Array.isArray(queryEmbedding[0]) ? queryEmbedding : [queryEmbedding]\n  ) as number[][];\n\n  const similarityToQuery = cosineSimilarity(\n    queryEmbeddingExpanded,\n    embeddingList\n  )[0];\n  const mostSimilarEmbeddingIndex = argMax(similarityToQuery).maxIndex;\n\n  const selectedEmbeddings = [embeddingList[mostSimilarEmbeddingIndex]];\n  const selectedEmbeddingsIndexes = [mostSimilarEmbeddingIndex];\n\n  while (selectedEmbeddingsIndexes.length < Math.min(k, embeddingList.length)) {\n    let bestScore = -Infinity;\n    let bestIndex = -1;\n\n    const similarityToSelected = cosineSimilarity(\n      embeddingList,\n      selectedEmbeddings\n    );\n\n    similarityToQuery.forEach((queryScore, queryScoreIndex) => {\n      if (selectedEmbeddingsIndexes.includes(queryScoreIndex)) {\n        return;\n      }\n      const maxSimilarityToSelected = Math.max(\n        ...similarityToSelected[queryScoreIndex]\n      );\n      const score =\n        lambda * queryScore - (1 - lambda) * maxSimilarityToSelected;\n\n      if (score > bestScore) {\n        bestScore = score;\n        bestIndex = queryScoreIndex;\n      }\n    });\n    selectedEmbeddings.push(embeddingList[bestIndex]);\n    selectedEmbeddingsIndexes.push(bestIndex);\n  }\n\n  return selectedEmbeddingsIndexes;\n}\n\ntype MaxInfo = {\n  maxIndex: number;\n  maxValue: number;\n};\n\n/**\n * Finds the index of the maximum value in the given array.\n * @param {number[]} array - The input array.\n *\n * @returns {number} The index of the maximum value in the array. If the array is empty, returns -1.\n */\nfunction argMax(array: number[]): MaxInfo {\n  if (array.length === 0) {\n    return {\n      maxIndex: -1,\n      maxValue: NaN,\n    };\n  }\n\n  let maxValue = array[0];\n  let maxIndex = 0;\n\n  for (let i = 1; i < array.length; i += 1) {\n    if (array[i] > maxValue) {\n      maxIndex = i;\n      maxValue = array[i];\n    }\n  }\n  return { maxIndex, maxValue };\n}\n\nfunction matrixMaxVal(arrays: number[][]): number {\n  return arrays.reduce(\n    (acc, array) => Math.max(acc, argMax(array).maxValue),\n    0\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAkBA,SAAgB,WACd,GACA,GACA,MACY;AACZ,KACE,EAAE,WAAW,KACb,EAAE,GAAG,WAAW,KAChB,EAAE,WAAW,KACb,EAAE,GAAG,WAAW,EAEhB,QAAO,CAAC,EAAE,CAAC;AAGb,KAAI,EAAE,GAAG,WAAW,EAAE,GAAG,OACvB,OAAM,IAAI,MACR,8DAA8D,CAC5D,EAAE,QACF,EAAE,GAAG,OACN,CAAC,mBAAmB,CAAC,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,GAC9C;AAGH,QAAO,EAAE,KAAK,YACZ,EAAE,KAAK,YAAY,KAAK,SAAS,QAAQ,CAAC,CAAC,KAAK,eAC9C,OAAO,MAAM,WAAW,GAAG,IAAI,WAChC,CACF;;AAGH,SAAgB,UAAU,GAAe,aAAa,OAAmB;CACvE,MAAM,MAAM,aAAa,EAAE;AAC3B,QAAO,EAAE,KAAK,QACZ,IAAI,KAAK,QAAS,aAAa,IAAI,MAAM,MAAM,MAAM,IAAK,CAC3D;;;;;;;;;;;;AAaH,SAAgB,iBAAiB,GAAe,GAA2B;AACzE,QAAO,WAAW,GAAG,GAAG,OAAO;;AAGjC,SAAgB,aAAa,GAAe,GAA2B;AACrE,QAAO,WAAW,GAAG,GAAGA,eAAqB;;AAG/C,SAAgB,kBAAkB,GAAe,GAA2B;AAC1E,QAAO,WAAW,GAAG,GAAG,UAAU;;;;;;;;;;;;;AAcpC,SAAgB,yBACd,gBACA,eACA,SAAS,IACT,IAAI,GACM;AACV,KAAI,KAAK,IAAI,GAAG,cAAc,OAAO,IAAI,EACvC,QAAO,EAAE;CAOX,MAAM,oBAAoB,iBAHxB,MAAM,QAAQ,eAAe,GAAG,GAAG,iBAAiB,CAAC,eAAe,EAKpE,cACD,CAAC;CACF,MAAM,4BAA4B,OAAO,kBAAkB,CAAC;CAE5D,MAAM,qBAAqB,CAAC,cAAc,2BAA2B;CACrE,MAAM,4BAA4B,CAAC,0BAA0B;AAE7D,QAAO,0BAA0B,SAAS,KAAK,IAAI,GAAG,cAAc,OAAO,EAAE;EAC3E,IAAI,YAAY;EAChB,IAAI,YAAY;EAEhB,MAAM,uBAAuB,iBAC3B,eACA,mBACD;AAED,oBAAkB,SAAS,YAAY,oBAAoB;AACzD,OAAI,0BAA0B,SAAS,gBAAgB,CACrD;GAEF,MAAM,0BAA0B,KAAK,IACnC,GAAG,qBAAqB,iBACzB;GACD,MAAM,QACJ,SAAS,cAAc,IAAI,UAAU;AAEvC,OAAI,QAAQ,WAAW;AACrB,gBAAY;AACZ,gBAAY;;IAEd;AACF,qBAAmB,KAAK,cAAc,WAAW;AACjD,4BAA0B,KAAK,UAAU;;AAG3C,QAAO;;;;;;;;AAcT,SAAS,OAAO,OAA0B;AACxC,KAAI,MAAM,WAAW,EACnB,QAAO;EACL,UAAU;EACV,UAAU;EACX;CAGH,IAAI,WAAW,MAAM;CACrB,IAAI,WAAW;AAEf,MAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,EACrC,KAAI,MAAM,KAAK,UAAU;AACvB,aAAW;AACX,aAAW,MAAM;;AAGrB,QAAO;EAAE;EAAU;EAAU;;AAG/B,SAAS,aAAa,QAA4B;AAChD,QAAO,OAAO,QACX,KAAK,UAAU,KAAK,IAAI,KAAK,OAAO,MAAM,CAAC,SAAS,EACrD,EACD"}

package/dist/utils/ml-distance/distances.cjs

@@ -1,4 +1,3 @@
-
 //#region src/utils/ml-distance/distances.ts
 /**
 *Returns the Inner Product similarity between vectors a and b
@@ -12,7 +11,7 @@ function innerProduct(a, b) {
 	for (let i = 0; i < a.length; i++) ans += a[i] * b[i];
 	return ans;
 }
-
 //#endregion
 exports.innerProduct = innerProduct;
+
 //# sourceMappingURL=distances.cjs.map

package/dist/utils/ml-distance/distances.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"distances.cjs","names":["a: number[]","b: number[]"],"sources":["../../../src/utils/ml-distance/distances.ts"],"sourcesContent":["/**\n *Returns the Inner Product similarity between vectors a and b\n * @link [Inner Product Similarity algorithm](https://www.naun.org/main/NAUN/ijmmas/mmmas-49.pdf)\n * @param a - first vector\n * @param b - second vector\n *\n */\nexport function innerProduct(a: number[], b: number[]): number {\n  let ans = 0;\n  for (let i = 0; i < a.length; i++) {\n    ans += a[i] * b[i];\n  }\n  return ans;\n}\n"],"mappings":";;;;;;;;;AAOA,SAAgB,aAAaA,GAAaC,GAAqB;CAC7D,IAAI,MAAM;AACV,MAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,KAC5B,OAAO,EAAE,KAAK,EAAE;AAElB,QAAO;AACR"}
+{"version":3,"file":"distances.cjs","names":[],"sources":["../../../src/utils/ml-distance/distances.ts"],"sourcesContent":["/**\n *Returns the Inner Product similarity between vectors a and b\n * @link [Inner Product Similarity algorithm](https://www.naun.org/main/NAUN/ijmmas/mmmas-49.pdf)\n * @param a - first vector\n * @param b - second vector\n *\n */\nexport function innerProduct(a: number[], b: number[]): number {\n  let ans = 0;\n  for (let i = 0; i < a.length; i++) {\n    ans += a[i] * b[i];\n  }\n  return ans;\n}\n"],"mappings":";;;;;;;;AAOA,SAAgB,aAAa,GAAa,GAAqB;CAC7D,IAAI,MAAM;AACV,MAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,IAC5B,QAAO,EAAE,KAAK,EAAE;AAElB,QAAO"}