@langchain/core 1.1.28 → 1.1.30

package/dist/output_parsers/standard_schema.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard_schema.d.cts","names":[],"sources":["../../src/output_parsers/standard_schema.ts"],"mappings":";;;;cAIa,0BAAA,mBAEO,MAAA,gBAAsB,MAAA,uBAChC,gBAAA,CAAiB,SAAA;EAAA,OAClB,OAAA,CAAA;EAIP,YAAA;EAAA,iBAEiB,MAAA;EAEjB,WAAA,CAAY,MAAA,EAAQ,gBAAA,CAAiB,SAAA;EAAA,OAK9B,sBAAA,mBAEa,MAAA,gBAAsB,MAAA,cAAA,CACxC,MAAA,EAAQ,gBAAA,CAAiB,SAAA,IAAU,0BAAA,CAAA,SAAA;EAI/B,KAAA,CAAM,IAAA,WAAe,OAAA,CAAQ,SAAA;EAgBnC,qBAAA,CAAA;AAAA"}

package/dist/output_parsers/standard_schema.d.ts

@@ -0,0 +1,16 @@
+import { BaseOutputParser } from "./base.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/output_parsers/standard_schema.d.ts
+declare class StandardSchemaOutputParser<RunOutput extends Record<string, any> = Record<string, any>> extends BaseOutputParser<RunOutput> {
+  static lc_name(): string;
+  lc_namespace: string[];
+  private readonly schema;
+  constructor(schema: StandardSchemaV1<RunOutput>);
+  static fromSerializableSchema<RunOutput extends Record<string, any> = Record<string, any>>(schema: StandardSchemaV1<RunOutput>): StandardSchemaOutputParser<RunOutput>;
+  parse(text: string): Promise<RunOutput>;
+  getFormatInstructions(): string;
+}
+//#endregion
+export { StandardSchemaOutputParser };
+//# sourceMappingURL=standard_schema.d.ts.map

package/dist/output_parsers/standard_schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard_schema.d.ts","names":[],"sources":["../../src/output_parsers/standard_schema.ts"],"mappings":";;;;cAIa,0BAAA,mBAEO,MAAA,gBAAsB,MAAA,uBAChC,gBAAA,CAAiB,SAAA;EAAA,OAClB,OAAA,CAAA;EAIP,YAAA;EAAA,iBAEiB,MAAA;EAEjB,WAAA,CAAY,MAAA,EAAQ,gBAAA,CAAiB,SAAA;EAAA,OAK9B,sBAAA,mBAEa,MAAA,gBAAsB,MAAA,cAAA,CACxC,MAAA,EAAQ,gBAAA,CAAiB,SAAA,IAAU,0BAAA,CAAA,SAAA;EAI/B,KAAA,CAAM,IAAA,WAAe,OAAA,CAAQ,SAAA;EAgBnC,qBAAA,CAAA;AAAA"}

package/dist/output_parsers/standard_schema.js

@@ -0,0 +1,40 @@
+import { parseJsonMarkdown } from "../utils/json.js";
+import { BaseOutputParser, OutputParserException } from "./base.js";
+import "./json.js";
+
+//#region src/output_parsers/standard_schema.ts
+var StandardSchemaOutputParser = class extends BaseOutputParser {
+	static lc_name() {
+		return "StandardSchemaOutputParser";
+	}
+	lc_namespace = [
+		"langchain",
+		"output_parsers",
+		"standard_schema"
+	];
+	schema;
+	constructor(schema) {
+		super();
+		this.schema = schema;
+	}
+	static fromSerializableSchema(schema) {
+		return new this(schema);
+	}
+	async parse(text) {
+		try {
+			const json = parseJsonMarkdown(text, JSON.parse);
+			const result = await this.schema["~standard"].validate(json);
+			if (result.issues) throw new Error(`Validation failed: ${JSON.stringify(result.issues)}`);
+			return result.value;
+		} catch (e) {
+			throw new OutputParserException(`Failed to parse. Text: "${text}". Error: ${e}`, text);
+		}
+	}
+	getFormatInstructions() {
+		return "";
+	}
+};
+
+//#endregion
+export { StandardSchemaOutputParser };
+//# sourceMappingURL=standard_schema.js.map

package/dist/output_parsers/standard_schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard_schema.js","names":[],"sources":["../../src/output_parsers/standard_schema.ts"],"sourcesContent":["import { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport { BaseOutputParser, OutputParserException } from \"./base.js\";\nimport { parseJsonMarkdown } from \"./json.js\";\n\nexport class StandardSchemaOutputParser<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  RunOutput extends Record<string, any> = Record<string, any>,\n> extends BaseOutputParser<RunOutput> {\n  static lc_name() {\n    return \"StandardSchemaOutputParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"standard_schema\"];\n\n  private readonly schema: StandardSchemaV1<RunOutput>;\n\n  constructor(schema: StandardSchemaV1<RunOutput>) {\n    super();\n    this.schema = schema;\n  }\n\n  static fromSerializableSchema<\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    RunOutput extends Record<string, any> = Record<string, any>,\n  >(schema: StandardSchemaV1<RunOutput>) {\n    return new this(schema);\n  }\n\n  async parse(text: string): Promise<RunOutput> {\n    try {\n      const json = parseJsonMarkdown(text, JSON.parse);\n      const result = await this.schema[\"~standard\"].validate(json);\n      if (result.issues) {\n        throw new Error(`Validation failed: ${JSON.stringify(result.issues)}`);\n      }\n      return result.value as RunOutput;\n    } catch (e) {\n      throw new OutputParserException(\n        `Failed to parse. Text: \"${text}\". Error: ${e}`,\n        text\n      );\n    }\n  }\n\n  getFormatInstructions(): string {\n    return \"\";\n  }\n}\n"],"mappings":";;;;;AAIA,IAAa,6BAAb,cAGU,iBAA4B;CACpC,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAkB;CAEjE,AAAiB;CAEjB,YAAY,QAAqC;AAC/C,SAAO;AACP,OAAK,SAAS;;CAGhB,OAAO,uBAGL,QAAqC;AACrC,SAAO,IAAI,KAAK,OAAO;;CAGzB,MAAM,MAAM,MAAkC;AAC5C,MAAI;GACF,MAAM,OAAO,kBAAkB,MAAM,KAAK,MAAM;GAChD,MAAM,SAAS,MAAM,KAAK,OAAO,aAAa,SAAS,KAAK;AAC5D,OAAI,OAAO,OACT,OAAM,IAAI,MAAM,sBAAsB,KAAK,UAAU,OAAO,OAAO,GAAG;AAExE,UAAO,OAAO;WACP,GAAG;AACV,SAAM,IAAI,sBACR,2BAA2B,KAAK,YAAY,KAC5C,KACD;;;CAIL,wBAAgC;AAC9B,SAAO"}

package/dist/utils/json_schema.cjs

@@ -3,6 +3,7 @@ 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");
 
@@ -14,12 +15,13 @@ var json_schema_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	validatesOnlyStrings: () => validatesOnlyStrings
 });
 /**
-* 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.
 * @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);

package/dist/utils/json_schema.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"json_schema.cjs","names":["isZodSchemaV4","interopZodTransformInputSchema","isZodObjectV4","interopZodObjectStrict","isZodSchemaV3","zodToJsonSchema"],"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,aACd,QACA,QACY;AACZ,KAAIA,0BAAc,OAAO,EAAE;EACzB,MAAM,cAAcC,2CAA+B,QAAQ,KAAK;AAChE,MAAIC,0BAAc,YAAY,CAK5B,sCAJqBC,mCACnB,aACA,KACD,EACiC,OAAO;MAEzC,sCAAoB,QAAQ,OAAO;;AAGvC,KAAIC,0BAAc,OAAO,CACvB,QAAOC,wCAAgB,OAAO;AAEhC,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,kDAAuB,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 } 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\";\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(\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":";;;;;;;;;;;;;;;;;;;;;;AA8BA,SAAgB,aACd,QACA,QACY;AACZ,KAAIA,mDAAqB,OAAO,IAAI,CAACC,0BAAc,OAAO,CACxD,QAAO,OAAO,aAAa,WAAW,MAAM,EAC1C,QAAQ,YACT,CAAC;AAEJ,KAAIA,0BAAc,OAAO,EAAE;EACzB,MAAM,cAAcC,2CAA+B,QAAQ,KAAK;AAChE,MAAIC,0BAAc,YAAY,CAK5B,sCAJqBC,mCACnB,aACA,KACD,EACiC,OAAO;MAEzC,sCAAoB,QAAQ,OAAO;;AAGvC,KAAIC,0BAAc,OAAO,CACvB,QAAOC,wCAAgB,OAAO;AAEhC,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,kDAAuB,OAAiB;AAC9C,MAAI,SAAS,KACX,QAAO,qBAAqB,SAAS,KAAK;AAE5C,SAAO;;AAMT,QAAO"}

package/dist/utils/json_schema.d.cts

@@ -6,17 +6,18 @@ import { JsonSchema7NullableType } from "./zod-to-json-schema/parsers/nullable.c
 import { JsonSchema7ObjectType } from "./zod-to-json-schema/parsers/object.cjs";
 import { JsonSchema7Type } from "./zod-to-json-schema/parseTypes.cjs";
 import { toJSONSchema } from "zod/v4/core";
+import { StandardJSONSchemaV1 } from "@standard-schema/spec";
 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.
  * @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":[],"sources":["../../src/utils/json_schema.ts"],"mappings":";;;;;;;;;;;KAkBY,kBAAA,GAAqB,WAAA,CAC/B,UAAA,QAAkB,YAAA;;;;;;;iBASJ,YAAA,CACd,MAAA,EAAQ,cAAA,GAAiB,eAAA,EACzB,MAAA,GAAS,kBAAA,GACR,eAAA;;;;;;;;iBA0Ba,oBAAA,CAAqB,MAAA"}
+{"version":3,"file":"json_schema.d.cts","names":[],"sources":["../../src/utils/json_schema.ts"],"mappings":";;;;;;;;;;;;KAoBY,kBAAA,GAAqB,WAAA,CAC/B,UAAA,QAAkB,YAAA;;;;;;;iBASJ,YAAA,CACd,MAAA,EAAQ,oBAAA,GAAuB,cAAA,GAAiB,eAAA,EAChD,MAAA,GAAS,kBAAA,GACR,eAAA;;;;;;;;iBA+Ba,oBAAA,CAAqB,MAAA"}

package/dist/utils/json_schema.d.ts

@@ -8,16 +8,17 @@ 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.
  * @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":[],"sources":["../../src/utils/json_schema.ts"],"mappings":";;;;;;;;;;;;KAkBY,kBAAA,GAAqB,WAAA,CAC/B,UAAA,QAAkB,YAAA;;;;;;;iBASJ,YAAA,CACd,MAAA,EAAQ,cAAA,GAAiB,eAAA,EACzB,MAAA,GAAS,kBAAA,GACR,eAAA;AAbH;;;;;;;AAAA,iBAuCgB,oBAAA,CAAqB,MAAA"}
+{"version":3,"file":"json_schema.d.ts","names":[],"sources":["../../src/utils/json_schema.ts"],"mappings":";;;;;;;;;;;;;KAoBY,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,iBA4CgB,oBAAA,CAAqB,MAAA"}

package/dist/utils/json_schema.js

@@ -2,6 +2,7 @@ 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";
 
@@ -13,12 +14,13 @@ var json_schema_exports = /* @__PURE__ */ __exportAll({
 	validatesOnlyStrings: () => validatesOnlyStrings
 });
 /**
-* 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.
 * @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);

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 } 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,aACd,QACA,QACY;AACZ,KAAI,cAAc,OAAO,EAAE;EACzB,MAAM,cAAc,+BAA+B,QAAQ,KAAK;AAChE,MAAI,cAAc,YAAY,CAK5B,QAAO,aAJc,uBACnB,aACA,KACD,EACiC,OAAO;MAEzC,QAAO,aAAa,QAAQ,OAAO;;AAGvC,KAAI,cAAc,OAAO,CACvB,QAAO,gBAAgB,OAAO;AAEhC,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 } 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\";\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(\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":";;;;;;;;;;;;;;;;;;;;;AA8BA,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,CAK5B,QAAO,aAJc,uBACnB,aACA,KACD,EACiC,OAAO;MAEzC,QAAO,aAAa,QAAQ,OAAO;;AAGvC,KAAI,cAAc,OAAO,CACvB,QAAO,gBAAgB,OAAO;AAEhC,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/standard_schema.cjs

@@ -0,0 +1,43 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+
+//#region src/utils/standard_schema.ts
+var standard_schema_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	isSerializableSchema: () => isSerializableSchema,
+	isStandardJsonSchema: () => isStandardJsonSchema,
+	isStandardSchema: () => isStandardSchema
+});
+/**
+* Type guard for Standard Schema V1. Returns true if the value has a `~standard.validate`
+* interface, indicating it can validate unknown values at runtime (e.g. for parsing LLM output).
+*/
+function isStandardSchema(schema) {
+	return (typeof schema === "object" || typeof schema === "function") && schema !== null && "~standard" in schema && typeof schema["~standard"] === "object" && schema["~standard"] !== null && "validate" in schema["~standard"];
+}
+/**
+* Type guard for Standard JSON Schema V1. Returns true if the value has a `~standard.jsonSchema`
+* interface, indicating it can be converted to a JSON Schema object (e.g. for sending as a tool
+* definition to an LLM).
+*/
+function isStandardJsonSchema(schema) {
+	return (typeof schema === "object" || typeof schema === "function") && schema !== null && "~standard" in schema && typeof schema["~standard"] === "object" && schema["~standard"] !== null && "jsonSchema" in schema["~standard"];
+}
+/**
+* Type guard for Standard Schema V1. Returns true if the value has a `~standard.validate` interface,
+* indicating it can validate unknown values at runtime (e.g. for parsing LLM output).
+*/
+function isSerializableSchema(schema) {
+	return isStandardSchema(schema) && isStandardJsonSchema(schema);
+}
+
+//#endregion
+exports.isSerializableSchema = isSerializableSchema;
+exports.isStandardJsonSchema = isStandardJsonSchema;
+exports.isStandardSchema = isStandardSchema;
+Object.defineProperty(exports, 'standard_schema_exports', {
+  enumerable: true,
+  get: function () {
+    return standard_schema_exports;
+  }
+});
+//# sourceMappingURL=standard_schema.cjs.map

package/dist/utils/standard_schema.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard_schema.cjs","names":[],"sources":["../../src/utils/standard_schema.ts"],"sourcesContent":["import { StandardJSONSchemaV1, StandardSchemaV1 } from \"@standard-schema/spec\";\n\n/**\n * A schema that supports both runtime validation and JSON Schema generation. Any schema passed\n * to withStructuredOutput must satisfy both interfaces.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type SerializableSchema<Input = any, Output = Input> = StandardSchemaV1<\n  Input,\n  Output\n> &\n  StandardJSONSchemaV1<Input, Output>;\n\n/**\n * Type guard for Standard Schema V1. Returns true if the value has a `~standard.validate`\n * interface, indicating it can validate unknown values at runtime (e.g. for parsing LLM output).\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isStandardSchema<Input = any, Output = Input>(\n  schema: unknown\n): schema is StandardSchemaV1<Input, Output> {\n  return (\n    (typeof schema === \"object\" || typeof schema === \"function\") &&\n    schema !== null &&\n    \"~standard\" in schema &&\n    typeof schema[\"~standard\"] === \"object\" &&\n    schema[\"~standard\"] !== null &&\n    \"validate\" in schema[\"~standard\"]\n  );\n}\n\n/**\n * Type guard for Standard JSON Schema V1. Returns true if the value has a `~standard.jsonSchema`\n * interface, indicating it can be converted to a JSON Schema object (e.g. for sending as a tool\n * definition to an LLM).\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isStandardJsonSchema<Input = any, Output = Input>(\n  schema: unknown\n): schema is StandardJSONSchemaV1<Input, Output> {\n  return (\n    (typeof schema === \"object\" || typeof schema === \"function\") &&\n    schema !== null &&\n    \"~standard\" in schema &&\n    typeof schema[\"~standard\"] === \"object\" &&\n    schema[\"~standard\"] !== null &&\n    \"jsonSchema\" in schema[\"~standard\"]\n  );\n}\n\n/**\n * Type guard for Standard Schema V1. Returns true if the value has a `~standard.validate` interface,\n * indicating it can validate unknown values at runtime (e.g. for parsing LLM output).\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isSerializableSchema<Input = any, Output = Input>(\n  schema: unknown\n): schema is SerializableSchema<Input, Output> {\n  return isStandardSchema(schema) && isStandardJsonSchema(schema);\n}\n"],"mappings":";;;;;;;;;;;;;AAkBA,SAAgB,iBACd,QAC2C;AAC3C,SACG,OAAO,WAAW,YAAY,OAAO,WAAW,eACjD,WAAW,QACX,eAAe,UACf,OAAO,OAAO,iBAAiB,YAC/B,OAAO,iBAAiB,QACxB,cAAc,OAAO;;;;;;;AAUzB,SAAgB,qBACd,QAC+C;AAC/C,SACG,OAAO,WAAW,YAAY,OAAO,WAAW,eACjD,WAAW,QACX,eAAe,UACf,OAAO,OAAO,iBAAiB,YAC/B,OAAO,iBAAiB,QACxB,gBAAgB,OAAO;;;;;;AAS3B,SAAgB,qBACd,QAC6C;AAC7C,QAAO,iBAAiB,OAAO,IAAI,qBAAqB,OAAO"}

package/dist/utils/standard_schema.d.cts

@@ -0,0 +1,27 @@
+import { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/utils/standard_schema.d.ts
+/**
+ * A schema that supports both runtime validation and JSON Schema generation. Any schema passed
+ * to withStructuredOutput must satisfy both interfaces.
+ */
+type SerializableSchema<Input = any, Output = Input> = StandardSchemaV1<Input, Output> & StandardJSONSchemaV1<Input, Output>;
+/**
+ * Type guard for Standard Schema V1. Returns true if the value has a `~standard.validate`
+ * interface, indicating it can validate unknown values at runtime (e.g. for parsing LLM output).
+ */
+declare function isStandardSchema<Input = any, Output = Input>(schema: unknown): schema is StandardSchemaV1<Input, Output>;
+/**
+ * Type guard for Standard JSON Schema V1. Returns true if the value has a `~standard.jsonSchema`
+ * interface, indicating it can be converted to a JSON Schema object (e.g. for sending as a tool
+ * definition to an LLM).
+ */
+declare function isStandardJsonSchema<Input = any, Output = Input>(schema: unknown): schema is StandardJSONSchemaV1<Input, Output>;
+/**
+ * Type guard for Standard Schema V1. Returns true if the value has a `~standard.validate` interface,
+ * indicating it can validate unknown values at runtime (e.g. for parsing LLM output).
+ */
+declare function isSerializableSchema<Input = any, Output = Input>(schema: unknown): schema is SerializableSchema<Input, Output>;
+//#endregion
+export { SerializableSchema, isSerializableSchema, isStandardJsonSchema, isStandardSchema };
+//# sourceMappingURL=standard_schema.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"standard_schema.d.cts","names":[],"sources":["../../src/utils/standard_schema.ts"],"mappings":";;;;;AAOA;;KAAY,kBAAA,uBAAyC,KAAA,IAAS,gBAAA,CAC5D,KAAA,EACA,MAAA,IAEA,oBAAA,CAAqB,KAAA,EAAO,MAAA;;;;;iBAOd,gBAAA,uBAAuC,KAAA,CAAA,CACrD,MAAA,YACC,MAAA,IAAU,gBAAA,CAAiB,KAAA,EAAO,MAAA;;;;;;iBAiBrB,oBAAA,uBAA2C,KAAA,CAAA,CACzD,MAAA,YACC,MAAA,IAAU,oBAAA,CAAqB,KAAA,EAAO,MAAA;;;;;iBAgBzB,oBAAA,uBAA2C,KAAA,CAAA,CACzD,MAAA,YACC,MAAA,IAAU,kBAAA,CAAmB,KAAA,EAAO,MAAA"}

package/dist/utils/standard_schema.d.ts

@@ -0,0 +1,27 @@
+import { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/utils/standard_schema.d.ts
+/**
+ * A schema that supports both runtime validation and JSON Schema generation. Any schema passed
+ * to withStructuredOutput must satisfy both interfaces.
+ */
+type SerializableSchema<Input = any, Output = Input> = StandardSchemaV1<Input, Output> & StandardJSONSchemaV1<Input, Output>;
+/**
+ * Type guard for Standard Schema V1. Returns true if the value has a `~standard.validate`
+ * interface, indicating it can validate unknown values at runtime (e.g. for parsing LLM output).
+ */
+declare function isStandardSchema<Input = any, Output = Input>(schema: unknown): schema is StandardSchemaV1<Input, Output>;
+/**
+ * Type guard for Standard JSON Schema V1. Returns true if the value has a `~standard.jsonSchema`
+ * interface, indicating it can be converted to a JSON Schema object (e.g. for sending as a tool
+ * definition to an LLM).
+ */
+declare function isStandardJsonSchema<Input = any, Output = Input>(schema: unknown): schema is StandardJSONSchemaV1<Input, Output>;
+/**
+ * Type guard for Standard Schema V1. Returns true if the value has a `~standard.validate` interface,
+ * indicating it can validate unknown values at runtime (e.g. for parsing LLM output).
+ */
+declare function isSerializableSchema<Input = any, Output = Input>(schema: unknown): schema is SerializableSchema<Input, Output>;
+//#endregion
+export { SerializableSchema, isSerializableSchema, isStandardJsonSchema, isStandardSchema };
+//# sourceMappingURL=standard_schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"standard_schema.d.ts","names":[],"sources":["../../src/utils/standard_schema.ts"],"mappings":";;;;;AAOA;;KAAY,kBAAA,uBAAyC,KAAA,IAAS,gBAAA,CAC5D,KAAA,EACA,MAAA,IAEA,oBAAA,CAAqB,KAAA,EAAO,MAAA;;;;;iBAOd,gBAAA,uBAAuC,KAAA,CAAA,CACrD,MAAA,YACC,MAAA,IAAU,gBAAA,CAAiB,KAAA,EAAO,MAAA;;;;;;iBAiBrB,oBAAA,uBAA2C,KAAA,CAAA,CACzD,MAAA,YACC,MAAA,IAAU,oBAAA,CAAqB,KAAA,EAAO,MAAA;;;;;iBAgBzB,oBAAA,uBAA2C,KAAA,CAAA,CACzD,MAAA,YACC,MAAA,IAAU,kBAAA,CAAmB,KAAA,EAAO,MAAA"}

package/dist/utils/standard_schema.js

@@ -0,0 +1,34 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+
+//#region src/utils/standard_schema.ts
+var standard_schema_exports = /* @__PURE__ */ __exportAll({
+	isSerializableSchema: () => isSerializableSchema,
+	isStandardJsonSchema: () => isStandardJsonSchema,
+	isStandardSchema: () => isStandardSchema
+});
+/**
+* Type guard for Standard Schema V1. Returns true if the value has a `~standard.validate`
+* interface, indicating it can validate unknown values at runtime (e.g. for parsing LLM output).
+*/
+function isStandardSchema(schema) {
+	return (typeof schema === "object" || typeof schema === "function") && schema !== null && "~standard" in schema && typeof schema["~standard"] === "object" && schema["~standard"] !== null && "validate" in schema["~standard"];
+}
+/**
+* Type guard for Standard JSON Schema V1. Returns true if the value has a `~standard.jsonSchema`
+* interface, indicating it can be converted to a JSON Schema object (e.g. for sending as a tool
+* definition to an LLM).
+*/
+function isStandardJsonSchema(schema) {
+	return (typeof schema === "object" || typeof schema === "function") && schema !== null && "~standard" in schema && typeof schema["~standard"] === "object" && schema["~standard"] !== null && "jsonSchema" in schema["~standard"];
+}
+/**
+* Type guard for Standard Schema V1. Returns true if the value has a `~standard.validate` interface,
+* indicating it can validate unknown values at runtime (e.g. for parsing LLM output).
+*/
+function isSerializableSchema(schema) {
+	return isStandardSchema(schema) && isStandardJsonSchema(schema);
+}
+
+//#endregion
+export { isSerializableSchema, isStandardJsonSchema, isStandardSchema, standard_schema_exports };
+//# sourceMappingURL=standard_schema.js.map

package/dist/utils/standard_schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard_schema.js","names":[],"sources":["../../src/utils/standard_schema.ts"],"sourcesContent":["import { StandardJSONSchemaV1, StandardSchemaV1 } from \"@standard-schema/spec\";\n\n/**\n * A schema that supports both runtime validation and JSON Schema generation. Any schema passed\n * to withStructuredOutput must satisfy both interfaces.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type SerializableSchema<Input = any, Output = Input> = StandardSchemaV1<\n  Input,\n  Output\n> &\n  StandardJSONSchemaV1<Input, Output>;\n\n/**\n * Type guard for Standard Schema V1. Returns true if the value has a `~standard.validate`\n * interface, indicating it can validate unknown values at runtime (e.g. for parsing LLM output).\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isStandardSchema<Input = any, Output = Input>(\n  schema: unknown\n): schema is StandardSchemaV1<Input, Output> {\n  return (\n    (typeof schema === \"object\" || typeof schema === \"function\") &&\n    schema !== null &&\n    \"~standard\" in schema &&\n    typeof schema[\"~standard\"] === \"object\" &&\n    schema[\"~standard\"] !== null &&\n    \"validate\" in schema[\"~standard\"]\n  );\n}\n\n/**\n * Type guard for Standard JSON Schema V1. Returns true if the value has a `~standard.jsonSchema`\n * interface, indicating it can be converted to a JSON Schema object (e.g. for sending as a tool\n * definition to an LLM).\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isStandardJsonSchema<Input = any, Output = Input>(\n  schema: unknown\n): schema is StandardJSONSchemaV1<Input, Output> {\n  return (\n    (typeof schema === \"object\" || typeof schema === \"function\") &&\n    schema !== null &&\n    \"~standard\" in schema &&\n    typeof schema[\"~standard\"] === \"object\" &&\n    schema[\"~standard\"] !== null &&\n    \"jsonSchema\" in schema[\"~standard\"]\n  );\n}\n\n/**\n * Type guard for Standard Schema V1. Returns true if the value has a `~standard.validate` interface,\n * indicating it can validate unknown values at runtime (e.g. for parsing LLM output).\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isSerializableSchema<Input = any, Output = Input>(\n  schema: unknown\n): schema is SerializableSchema<Input, Output> {\n  return isStandardSchema(schema) && isStandardJsonSchema(schema);\n}\n"],"mappings":";;;;;;;;;;;;AAkBA,SAAgB,iBACd,QAC2C;AAC3C,SACG,OAAO,WAAW,YAAY,OAAO,WAAW,eACjD,WAAW,QACX,eAAe,UACf,OAAO,OAAO,iBAAiB,YAC/B,OAAO,iBAAiB,QACxB,cAAc,OAAO;;;;;;;AAUzB,SAAgB,qBACd,QAC+C;AAC/C,SACG,OAAO,WAAW,YAAY,OAAO,WAAW,eACjD,WAAW,QACX,eAAe,UACf,OAAO,OAAO,iBAAiB,YAC/B,OAAO,iBAAiB,QACxB,gBAAgB,OAAO;;;;;;AAS3B,SAAgB,qBACd,QAC6C;AAC7C,QAAO,iBAAiB,OAAO,IAAI,qBAAqB,OAAO"}

package/dist/utils/testing/fake_model_builder.cjs

@@ -0,0 +1,174 @@
+const require_base = require('../../messages/base.cjs');
+const require_ai = require('../../messages/ai.cjs');
+const require_base$1 = require('../../runnables/base.cjs');
+require('../../messages/index.cjs');
+const require_language_models_chat_models = require('../../language_models/chat_models.cjs');
+
+//#region src/utils/testing/fake_model_builder.ts
+function deriveContent(messages) {
+	return messages.map((m) => m.text).filter(Boolean).join("-");
+}
+let idCounter = 0;
+function nextToolCallId() {
+	idCounter += 1;
+	return `fake_tc_${idCounter}`;
+}
+/**
+* A fake chat model for testing, created via {@link fakeModel}.
+*
+* Queue responses with `.respond()` and `.respondWithTools()`, then
+* pass the instance directly wherever a chat model is expected.
+*
+* Each builder method queues a model response consumed in order per `invoke()`:
+*
+* `.respond(entry)` — enqueue a `BaseMessage`, `Error`, or factory function.
+*
+* `.respondWithTools(toolCalls[])` — enqueue an `AIMessage` with the given
+* tool calls. Content is derived from the input messages automatically.
+*
+* Both can be mixed freely in one chain. When all queued responses are
+* consumed, further invocations throw.
+*
+* Additional configuration:
+* - `.alwaysThrow(error)` — every call throws (overrides the queue)
+* - `.structuredResponse(value)` — value returned by `withStructuredOutput()`
+*
+* The model records all invocations in `.calls` / `.callCount`.
+*/
+var FakeBuiltModel = class FakeBuiltModel extends require_language_models_chat_models.BaseChatModel {
+	queue = [];
+	_alwaysThrowError;
+	_structuredResponseValue;
+	_tools = [];
+	_callIndex = 0;
+	_calls = [];
+	get calls() {
+		return this._calls;
+	}
+	get callCount() {
+		return this._calls.length;
+	}
+	constructor() {
+		super({});
+	}
+	_llmType() {
+		return "fake-model-builder";
+	}
+	_combineLLMOutput() {
+		return [];
+	}
+	respond(entry) {
+		if (typeof entry === "function") this.queue.push({
+			kind: "factory",
+			factory: entry
+		});
+		else if (require_base.BaseMessage.isInstance(entry)) this.queue.push({
+			kind: "message",
+			message: entry
+		});
+		else this.queue.push({
+			kind: "error",
+			error: entry
+		});
+		return this;
+	}
+	respondWithTools(toolCalls) {
+		this.queue.push({
+			kind: "toolCalls",
+			toolCalls: toolCalls.map((tc) => ({
+				name: tc.name,
+				args: tc.args,
+				id: tc.id ?? nextToolCallId(),
+				type: "tool_call"
+			}))
+		});
+		return this;
+	}
+	alwaysThrow(error) {
+		this._alwaysThrowError = error;
+		return this;
+	}
+	structuredResponse(value) {
+		this._structuredResponseValue = value;
+		return this;
+	}
+	bindTools(tools) {
+		const merged = [...this._tools, ...tools];
+		const next = new FakeBuiltModel();
+		next.queue = this.queue;
+		next._alwaysThrowError = this._alwaysThrowError;
+		next._structuredResponseValue = this._structuredResponseValue;
+		next._tools = merged;
+		next._calls = this._calls;
+		next._callIndex = this._callIndex;
+		return next.withConfig({});
+	}
+	withStructuredOutput(_params, _config) {
+		const { _structuredResponseValue } = this;
+		return require_base$1.RunnableLambda.from(async () => {
+			return _structuredResponseValue;
+		});
+	}
+	async _generate(messages, options, _runManager) {
+		this._calls.push({
+			messages: [...messages],
+			options
+		});
+		const currentCallIndex = this._callIndex;
+		this._callIndex += 1;
+		if (this._alwaysThrowError) throw this._alwaysThrowError;
+		const entry = this.queue[currentCallIndex];
+		if (!entry) throw new Error(`FakeModel: no response queued for invocation ${currentCallIndex} (${this.queue.length} total queued).`);
+		if (entry.kind === "error") throw entry.error;
+		if (entry.kind === "factory") {
+			const result = entry.factory(messages);
+			if (!require_base.BaseMessage.isInstance(result)) throw result;
+			return { generations: [{
+				text: "",
+				message: result
+			}] };
+		}
+		if (entry.kind === "message") return { generations: [{
+			text: "",
+			message: entry.message
+		}] };
+		const content = deriveContent(messages);
+		return {
+			generations: [{
+				text: content,
+				message: new require_ai.AIMessage({
+					content,
+					id: currentCallIndex.toString(),
+					tool_calls: entry.toolCalls.length > 0 ? entry.toolCalls.map((tc) => ({
+						...tc,
+						type: "tool_call"
+					})) : void 0
+				})
+			}],
+			llmOutput: {}
+		};
+	}
+};
+/**
+* Creates a fake chat model for testing.
+*
+* @example
+* ```typescript
+* const model = fakeModel()
+*   .respondWithTools([{ name: "search", args: { query: "weather" } }])
+*   .respond(new AIMessage("Sunny and warm."));
+*
+* const r1 = await model.invoke([new HumanMessage("What's the weather?")]);
+* // r1.tool_calls[0].name === "search"
+*
+* const r2 = await model.invoke([new HumanMessage("Thanks")]);
+* // r2.content === "Sunny and warm."
+* ```
+*/
+function fakeModel() {
+	return new FakeBuiltModel();
+}
+
+//#endregion
+exports.fakeModel = fakeModel;
+//# sourceMappingURL=fake_model_builder.cjs.map

package/dist/utils/testing/fake_model_builder.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake_model_builder.cjs","names":["BaseChatModel","BaseMessage","RunnableLambda","AIMessage"],"sources":["../../../src/utils/testing/fake_model_builder.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { CallbackManagerForLLMRun } from \"../../callbacks/manager.js\";\nimport {\n  BaseChatModel,\n  BaseChatModelCallOptions,\n} from \"../../language_models/chat_models.js\";\nimport {\n  BaseLanguageModelInput,\n  StructuredOutputMethodOptions,\n  StructuredOutputMethodParams,\n} from \"../../language_models/base.js\";\nimport { BaseMessage, AIMessage } from \"../../messages/index.js\";\nimport type { ToolCall } from \"../../messages/tool.js\";\nimport type { ChatResult } from \"../../outputs.js\";\nimport { Runnable, RunnableLambda } from \"../../runnables/base.js\";\nimport { StructuredTool } from \"../../tools/index.js\";\nimport type { InteropZodType } from \"../types/zod.js\";\nimport type { ToolSpec } from \"./chat_models.js\";\n\ntype ResponseFactory = (messages: BaseMessage[]) => BaseMessage | Error;\n\ntype QueueEntry =\n  | { kind: \"message\"; message: BaseMessage }\n  | { kind: \"toolCalls\"; toolCalls: ToolCall[] }\n  | { kind: \"error\"; error: Error }\n  | { kind: \"factory\"; factory: ResponseFactory };\n\ninterface FakeModelCall {\n  messages: BaseMessage[];\n  options: any;\n}\n\nfunction deriveContent(messages: BaseMessage[]): string {\n  return messages\n    .map((m) => m.text)\n    .filter(Boolean)\n    .join(\"-\");\n}\n\nlet idCounter = 0;\nfunction nextToolCallId(): string {\n  idCounter += 1;\n  return `fake_tc_${idCounter}`;\n}\n\n/**\n * A fake chat model for testing, created via {@link fakeModel}.\n *\n * Queue responses with `.respond()` and `.respondWithTools()`, then\n * pass the instance directly wherever a chat model is expected.\n *\n * Each builder method queues a model response consumed in order per `invoke()`:\n *\n * `.respond(entry)` — enqueue a `BaseMessage`, `Error`, or factory function.\n *\n * `.respondWithTools(toolCalls[])` — enqueue an `AIMessage` with the given\n * tool calls. Content is derived from the input messages automatically.\n *\n * Both can be mixed freely in one chain. When all queued responses are\n * consumed, further invocations throw.\n *\n * Additional configuration:\n * - `.alwaysThrow(error)` — every call throws (overrides the queue)\n * - `.structuredResponse(value)` — value returned by `withStructuredOutput()`\n *\n * The model records all invocations in `.calls` / `.callCount`.\n */\nclass FakeBuiltModel extends BaseChatModel {\n  private queue: QueueEntry[] = [];\n\n  private _alwaysThrowError: Error | undefined;\n\n  private _structuredResponseValue: any;\n\n  private _tools: (StructuredTool | ToolSpec)[] = [];\n\n  private _callIndex = 0;\n\n  private _calls: FakeModelCall[] = [];\n\n  get calls(): FakeModelCall[] {\n    return this._calls;\n  }\n\n  get callCount(): number {\n    return this._calls.length;\n  }\n\n  constructor() {\n    super({});\n  }\n\n  _llmType(): string {\n    return \"fake-model-builder\";\n  }\n\n  _combineLLMOutput() {\n    return [];\n  }\n\n  respond(entry: BaseMessage | Error | ResponseFactory): this {\n    if (typeof entry === \"function\") {\n      this.queue.push({ kind: \"factory\", factory: entry });\n    } else if (BaseMessage.isInstance(entry)) {\n      this.queue.push({ kind: \"message\", message: entry });\n    } else {\n      this.queue.push({ kind: \"error\", error: entry });\n    }\n    return this;\n  }\n\n  respondWithTools(\n    toolCalls: Array<{ name: string; args: Record<string, any>; id?: string }>\n  ): this {\n    this.queue.push({\n      kind: \"toolCalls\",\n      toolCalls: toolCalls.map((tc) => ({\n        name: tc.name,\n        args: tc.args,\n        id: tc.id ?? nextToolCallId(),\n        type: \"tool_call\" as const,\n      })),\n    });\n    return this;\n  }\n\n  alwaysThrow(error: Error): this {\n    this._alwaysThrowError = error;\n    return this;\n  }\n\n  structuredResponse(value: Record<string, any>): this {\n    this._structuredResponseValue = value;\n    return this;\n  }\n\n  bindTools(tools: (StructuredTool | ToolSpec)[]) {\n    const merged = [...this._tools, ...tools];\n    const next = new FakeBuiltModel();\n    next.queue = this.queue;\n    next._alwaysThrowError = this._alwaysThrowError;\n    next._structuredResponseValue = this._structuredResponseValue;\n    next._tools = merged;\n    next._calls = this._calls;\n    next._callIndex = this._callIndex;\n\n    return next.withConfig({} as BaseChatModelCallOptions);\n  }\n\n  withStructuredOutput<\n    RunOutput extends Record<string, any> = Record<string, any>,\n  >(\n    _params:\n      | StructuredOutputMethodParams<RunOutput, boolean>\n      | InteropZodType<RunOutput>\n      | Record<string, any>,\n    _config?: StructuredOutputMethodOptions<boolean>\n  ):\n    | Runnable<BaseLanguageModelInput, RunOutput>\n    | Runnable<\n        BaseLanguageModelInput,\n        { raw: BaseMessage; parsed: RunOutput }\n      > {\n    const { _structuredResponseValue } = this;\n    return RunnableLambda.from(async () => {\n      return _structuredResponseValue as RunOutput;\n    }) as Runnable;\n  }\n\n  async _generate(\n    messages: BaseMessage[],\n    options?: this[\"ParsedCallOptions\"],\n    _runManager?: CallbackManagerForLLMRun\n  ): Promise<ChatResult> {\n    this._calls.push({ messages: [...messages], options });\n\n    const currentCallIndex = this._callIndex;\n    this._callIndex += 1;\n\n    if (this._alwaysThrowError) {\n      throw this._alwaysThrowError;\n    }\n\n    const entry = this.queue[currentCallIndex];\n    if (!entry) {\n      throw new Error(\n        `FakeModel: no response queued for invocation ${currentCallIndex} (${this.queue.length} total queued).`\n      );\n    }\n\n    if (entry.kind === \"error\") {\n      throw entry.error;\n    }\n\n    if (entry.kind === \"factory\") {\n      const result = entry.factory(messages);\n      if (!BaseMessage.isInstance(result)) {\n        throw result;\n      }\n      return {\n        generations: [{ text: \"\", message: result }],\n      };\n    }\n\n    if (entry.kind === \"message\") {\n      return {\n        generations: [{ text: \"\", message: entry.message }],\n      };\n    }\n\n    const content = deriveContent(messages);\n    const message = new AIMessage({\n      content,\n      id: currentCallIndex.toString(),\n      tool_calls:\n        entry.toolCalls.length > 0\n          ? entry.toolCalls.map((tc) => ({\n              ...tc,\n              type: \"tool_call\" as const,\n            }))\n          : undefined,\n    });\n\n    return {\n      generations: [{ text: content, message }],\n      llmOutput: {},\n    };\n  }\n}\n\n/**\n * Creates a fake chat model for testing.\n *\n * @example\n * ```typescript\n * const model = fakeModel()\n *   .respondWithTools([{ name: \"search\", args: { query: \"weather\" } }])\n *   .respond(new AIMessage(\"Sunny and warm.\"));\n *\n * const r1 = await model.invoke([new HumanMessage(\"What's the weather?\")]);\n * // r1.tool_calls[0].name === \"search\"\n *\n * const r2 = await model.invoke([new HumanMessage(\"Thanks\")]);\n * // r2.content === \"Sunny and warm.\"\n * ```\n */\nexport function fakeModel(): FakeBuiltModel {\n  return new FakeBuiltModel();\n}\n"],"mappings":";;;;;;;AAgCA,SAAS,cAAc,UAAiC;AACtD,QAAO,SACJ,KAAK,MAAM,EAAE,KAAK,CAClB,OAAO,QAAQ,CACf,KAAK,IAAI;;AAGd,IAAI,YAAY;AAChB,SAAS,iBAAyB;AAChC,cAAa;AACb,QAAO,WAAW;;;;;;;;;;;;;;;;;;;;;;;;AAyBpB,IAAM,iBAAN,MAAM,uBAAuBA,kDAAc;CACzC,AAAQ,QAAsB,EAAE;CAEhC,AAAQ;CAER,AAAQ;CAER,AAAQ,SAAwC,EAAE;CAElD,AAAQ,aAAa;CAErB,AAAQ,SAA0B,EAAE;CAEpC,IAAI,QAAyB;AAC3B,SAAO,KAAK;;CAGd,IAAI,YAAoB;AACtB,SAAO,KAAK,OAAO;;CAGrB,cAAc;AACZ,QAAM,EAAE,CAAC;;CAGX,WAAmB;AACjB,SAAO;;CAGT,oBAAoB;AAClB,SAAO,EAAE;;CAGX,QAAQ,OAAoD;AAC1D,MAAI,OAAO,UAAU,WACnB,MAAK,MAAM,KAAK;GAAE,MAAM;GAAW,SAAS;GAAO,CAAC;WAC3CC,yBAAY,WAAW,MAAM,CACtC,MAAK,MAAM,KAAK;GAAE,MAAM;GAAW,SAAS;GAAO,CAAC;MAEpD,MAAK,MAAM,KAAK;GAAE,MAAM;GAAS,OAAO;GAAO,CAAC;AAElD,SAAO;;CAGT,iBACE,WACM;AACN,OAAK,MAAM,KAAK;GACd,MAAM;GACN,WAAW,UAAU,KAAK,QAAQ;IAChC,MAAM,GAAG;IACT,MAAM,GAAG;IACT,IAAI,GAAG,MAAM,gBAAgB;IAC7B,MAAM;IACP,EAAE;GACJ,CAAC;AACF,SAAO;;CAGT,YAAY,OAAoB;AAC9B,OAAK,oBAAoB;AACzB,SAAO;;CAGT,mBAAmB,OAAkC;AACnD,OAAK,2BAA2B;AAChC,SAAO;;CAGT,UAAU,OAAsC;EAC9C,MAAM,SAAS,CAAC,GAAG,KAAK,QAAQ,GAAG,MAAM;EACzC,MAAM,OAAO,IAAI,gBAAgB;AACjC,OAAK,QAAQ,KAAK;AAClB,OAAK,oBAAoB,KAAK;AAC9B,OAAK,2BAA2B,KAAK;AACrC,OAAK,SAAS;AACd,OAAK,SAAS,KAAK;AACnB,OAAK,aAAa,KAAK;AAEvB,SAAO,KAAK,WAAW,EAAE,CAA6B;;CAGxD,qBAGE,SAIA,SAMI;EACJ,MAAM,EAAE,6BAA6B;AACrC,SAAOC,8BAAe,KAAK,YAAY;AACrC,UAAO;IACP;;CAGJ,MAAM,UACJ,UACA,SACA,aACqB;AACrB,OAAK,OAAO,KAAK;GAAE,UAAU,CAAC,GAAG,SAAS;GAAE;GAAS,CAAC;EAEtD,MAAM,mBAAmB,KAAK;AAC9B,OAAK,cAAc;AAEnB,MAAI,KAAK,kBACP,OAAM,KAAK;EAGb,MAAM,QAAQ,KAAK,MAAM;AACzB,MAAI,CAAC,MACH,OAAM,IAAI,MACR,gDAAgD,iBAAiB,IAAI,KAAK,MAAM,OAAO,iBACxF;AAGH,MAAI,MAAM,SAAS,QACjB,OAAM,MAAM;AAGd,MAAI,MAAM,SAAS,WAAW;GAC5B,MAAM,SAAS,MAAM,QAAQ,SAAS;AACtC,OAAI,CAACD,yBAAY,WAAW,OAAO,CACjC,OAAM;AAER,UAAO,EACL,aAAa,CAAC;IAAE,MAAM;IAAI,SAAS;IAAQ,CAAC,EAC7C;;AAGH,MAAI,MAAM,SAAS,UACjB,QAAO,EACL,aAAa,CAAC;GAAE,MAAM;GAAI,SAAS,MAAM;GAAS,CAAC,EACpD;EAGH,MAAM,UAAU,cAAc,SAAS;AAavC,SAAO;GACL,aAAa,CAAC;IAAE,MAAM;IAAS,SAbjB,IAAIE,qBAAU;KAC5B;KACA,IAAI,iBAAiB,UAAU;KAC/B,YACE,MAAM,UAAU,SAAS,IACrB,MAAM,UAAU,KAAK,QAAQ;MAC3B,GAAG;MACH,MAAM;MACP,EAAE,GACH;KACP,CAAC;IAGwC,CAAC;GACzC,WAAW,EAAE;GACd;;;;;;;;;;;;;;;;;;;AAoBL,SAAgB,YAA4B;AAC1C,QAAO,IAAI,gBAAgB"}