@langchain/core 1.1.35 → 1.1.37

package/dist/utils/json_schema.cjs

@@ -14,20 +14,44 @@ var json_schema_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	validatesOnlyStrings: () => validatesOnlyStrings
 });
 /**
+* 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_utils_standard_schema.isStandardJsonSchema(schema) && !require_zod.isZodSchemaV4(schema)) return schema["~standard"].jsonSchema.input({ target: "draft-07" });
-	if (require_zod.isZodSchemaV4(schema)) {
-		const inputSchema = require_zod.interopZodTransformInputSchema(schema, true);
-		if (require_zod.isZodObjectV4(inputSchema)) return (0, zod_v4_core.toJSONSchema)(require_zod.interopZodObjectStrict(inputSchema, true), 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

package/dist/utils/json_schema.cjs.map

@@ -1 +1 @@
-{"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 * Converts a Standard JSON schema, 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: StandardJSONSchemaV1 | InteropZodType | JSONSchema,\n  params?: ToJSONSchemaParams\n): JSONSchema {\n  if (isStandardJsonSchema(schema) && !isZodSchemaV4(schema)) {\n    return schema[\"~standard\"].jsonSchema.input({\n      target: \"draft-07\",\n    }) as JSONSchema;\n  }\n  if (isZodSchemaV4(schema)) {\n    const inputSchema = interopZodTransformInputSchema(schema, true);\n    if (isZodObjectV4(inputSchema)) {\n      const strictSchema = interopZodObjectStrict(inputSchema, true);\n      return toJSONSchema(strictSchema as unknown as $ZodType, params);\n    } else {\n      return toJSONSchema(schema as unknown as $ZodType, params);\n    }\n  }\n  if (isZodSchemaV3(schema)) {\n    return zodToJsonSchema(schema as never);\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":";;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,aACd,QACA,QACY;AACZ,KAAIA,8BAAAA,qBAAqB,OAAO,IAAI,CAACC,YAAAA,cAAc,OAAO,CACxD,QAAO,OAAO,aAAa,WAAW,MAAM,EAC1C,QAAQ,YACT,CAAC;AAEJ,KAAIA,YAAAA,cAAc,OAAO,EAAE;EACzB,MAAM,cAAcC,YAAAA,+BAA+B,QAAQ,KAAK;AAChE,MAAIC,YAAAA,cAAc,YAAY,CAE5B,SAAA,GAAA,YAAA,cADqBC,YAAAA,uBAAuB,aAAa,KAAK,EACL,OAAO;MAEhE,SAAA,GAAA,YAAA,cAAoB,QAA+B,OAAO;;AAG9D,KAAIC,YAAAA,cAAc,OAAO,CACvB,QAAOC,wBAAAA,gBAAgB,OAAgB;AAEzC,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"}
+{"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

@@ -13,6 +13,7 @@ import { Validator, deepCompareStrict } from "@cfworker/json-schema";
 type ToJSONSchemaParams = NonNullable<Parameters<typeof toJSONSchema>[1]>;
 /**
  * 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.

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

@@ -1 +1 @@
-{"version":3,"file":"json_schema.d.cts","names":[],"sources":["../../src/utils/json_schema.ts"],"mappings":";;;;;;;;;;;;KAmBY,kBAAA,GAAqB,WAAA,CAC/B,UAAA,QAAkB,YAAA;;;;;;;iBASJ,YAAA,CACd,MAAA,EAAQ,oBAAA,GAAuB,cAAA,GAAiB,eAAA,EAChD,MAAA,GAAS,kBAAA,GACR,eAAA;;;;;;;;iBA4Ba,oBAAA,CAAqB,MAAA"}
+{"version":3,"file":"json_schema.d.cts","names":[],"sources":["../../src/utils/json_schema.ts"],"mappings":";;;;;;;;;;;;KAmBY,kBAAA,GAAqB,WAAA,CAC/B,UAAA,QAAkB,YAAA;;;;;;;AADpB;iBA4BgB,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

@@ -13,6 +13,7 @@ import { StandardJSONSchemaV1 } from "@standard-schema/spec";
 type ToJSONSchemaParams = NonNullable<Parameters<typeof toJSONSchema>[1]>;
 /**
  * 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.

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

@@ -1 +1 @@
-{"version":3,"file":"json_schema.d.ts","names":[],"sources":["../../src/utils/json_schema.ts"],"mappings":";;;;;;;;;;;;KAmBY,kBAAA,GAAqB,WAAA,CAC/B,UAAA,QAAkB,YAAA;;;;;;;iBASJ,YAAA,CACd,MAAA,EAAQ,oBAAA,GAAuB,cAAA,GAAiB,eAAA,EAChD,MAAA,GAAS,kBAAA,GACR,eAAA;AAbH;;;;;;;AAAA,iBAyCgB,oBAAA,CAAqB,MAAA"}
+{"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

@@ -13,20 +13,44 @@ var json_schema_exports = /* @__PURE__ */ __exportAll({
 	validatesOnlyStrings: () => validatesOnlyStrings
 });
 /**
+* 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 (isStandardJsonSchema(schema) && !isZodSchemaV4(schema)) return schema["~standard"].jsonSchema.input({ target: "draft-07" });
-	if (isZodSchemaV4(schema)) {
-		const inputSchema = interopZodTransformInputSchema(schema, true);
-		if (isZodObjectV4(inputSchema)) return toJSONSchema(interopZodObjectStrict(inputSchema, true), 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

package/dist/utils/json_schema.js.map

@@ -1 +1 @@
-{"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 * Converts a Standard JSON schema, 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: StandardJSONSchemaV1 | InteropZodType | JSONSchema,\n  params?: ToJSONSchemaParams\n): JSONSchema {\n  if (isStandardJsonSchema(schema) && !isZodSchemaV4(schema)) {\n    return schema[\"~standard\"].jsonSchema.input({\n      target: \"draft-07\",\n    }) as JSONSchema;\n  }\n  if (isZodSchemaV4(schema)) {\n    const inputSchema = interopZodTransformInputSchema(schema, true);\n    if (isZodObjectV4(inputSchema)) {\n      const strictSchema = interopZodObjectStrict(inputSchema, true);\n      return toJSONSchema(strictSchema as unknown as $ZodType, params);\n    } else {\n      return toJSONSchema(schema as unknown as $ZodType, params);\n    }\n  }\n  if (isZodSchemaV3(schema)) {\n    return zodToJsonSchema(schema as never);\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":";;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,aACd,QACA,QACY;AACZ,KAAI,qBAAqB,OAAO,IAAI,CAAC,cAAc,OAAO,CACxD,QAAO,OAAO,aAAa,WAAW,MAAM,EAC1C,QAAQ,YACT,CAAC;AAEJ,KAAI,cAAc,OAAO,EAAE;EACzB,MAAM,cAAc,+BAA+B,QAAQ,KAAK;AAChE,MAAI,cAAc,YAAY,CAE5B,QAAO,aADc,uBAAuB,aAAa,KAAK,EACL,OAAO;MAEhE,QAAO,aAAa,QAA+B,OAAO;;AAG9D,KAAI,cAAc,OAAO,CACvB,QAAO,gBAAgB,OAAgB;AAEzC,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"}
+{"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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "1.1.35",
+  "version": "1.1.37",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {