@langchain/core 1.1.47 → 1.1.49-dev-1781044436312

package/dist/runnables/router.js.map

@@ -1 +1 @@
-{"version":3,"file":"router.js","names":[],"sources":["../../src/runnables/router.ts"],"sourcesContent":["import { Runnable, type RunnableBatchOptions } from \"./base.js\";\nimport { IterableReadableStream } from \"../utils/stream.js\";\nimport { ensureConfig, type RunnableConfig } from \"./config.js\";\n\nexport type RouterInput = {\n  key: string;\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  input: any;\n};\n\n/**\n * A runnable that routes to a set of runnables based on Input['key'].\n * Returns the output of the selected runnable.\n * @example\n * ```typescript\n * import { RouterRunnable, RunnableLambda } from \"@langchain/core/runnables\";\n *\n * const router = new RouterRunnable({\n *   runnables: {\n *     toUpperCase: RunnableLambda.from((text: string) => text.toUpperCase()),\n *     reverseText: RunnableLambda.from((text: string) =>\n *       text.split(\"\").reverse().join(\"\")\n *     ),\n *   },\n * });\n *\n * // Invoke the 'reverseText' runnable\n * const result1 = router.invoke({ key: \"reverseText\", input: \"Hello World\" });\n *\n * // \"dlroW olleH\"\n *\n * // Invoke the 'toUpperCase' runnable\n * const result2 = router.invoke({ key: \"toUpperCase\", input: \"Hello World\" });\n *\n * // \"HELLO WORLD\"\n * ```\n */\nexport class RouterRunnable<\n  RunInput extends RouterInput,\n  RunnableInput,\n  RunOutput,\n> extends Runnable<RunInput, RunOutput> {\n  static lc_name() {\n    return \"RouterRunnable\";\n  }\n\n  lc_namespace = [\"langchain_core\", \"runnables\"];\n\n  lc_serializable = true;\n\n  runnables: Record<string, Runnable<RunnableInput, RunOutput>>;\n\n  constructor(fields: {\n    runnables: Record<string, Runnable<RunnableInput, RunOutput>>;\n  }) {\n    super(fields);\n    this.runnables = fields.runnables;\n  }\n\n  async invoke(\n    input: RunInput,\n    options?: Partial<RunnableConfig>\n  ): Promise<RunOutput> {\n    const { key, input: actualInput } = input;\n    const runnable = this.runnables[key];\n    if (runnable === undefined) {\n      throw new Error(`No runnable associated with key \"${key}\".`);\n    }\n    return runnable.invoke(actualInput, ensureConfig(options));\n  }\n\n  async batch(\n    inputs: RunInput[],\n    options?: Partial<RunnableConfig> | Partial<RunnableConfig>[],\n    batchOptions?: RunnableBatchOptions & { returnExceptions?: false }\n  ): Promise<RunOutput[]>;\n\n  async batch(\n    inputs: RunInput[],\n    options?: Partial<RunnableConfig> | Partial<RunnableConfig>[],\n    batchOptions?: RunnableBatchOptions & { returnExceptions: true }\n  ): Promise<(RunOutput | Error)[]>;\n\n  async batch(\n    inputs: RunInput[],\n    options?: Partial<RunnableConfig> | Partial<RunnableConfig>[],\n    batchOptions?: RunnableBatchOptions\n  ): Promise<(RunOutput | Error)[]>;\n\n  async batch(\n    inputs: RunInput[],\n    options?: Partial<RunnableConfig> | Partial<RunnableConfig>[],\n    batchOptions?: RunnableBatchOptions\n  ): Promise<(RunOutput | Error)[]> {\n    const keys = inputs.map((input) => input.key);\n    const actualInputs = inputs.map((input) => input.input);\n    const missingKey = keys.find((key) => this.runnables[key] === undefined);\n    if (missingKey !== undefined) {\n      throw new Error(`One or more keys do not have a corresponding runnable.`);\n    }\n    const runnables = keys.map((key) => this.runnables[key]);\n    const optionsList = this._getOptionsList(options ?? {}, inputs.length);\n    const maxConcurrency =\n      optionsList[0]?.maxConcurrency ?? batchOptions?.maxConcurrency;\n    const batchSize =\n      maxConcurrency && maxConcurrency > 0 ? maxConcurrency : inputs.length;\n    const batchResults = [];\n    for (let i = 0; i < actualInputs.length; i += batchSize) {\n      const batchPromises = actualInputs\n        .slice(i, i + batchSize)\n        .map((actualInput, i) =>\n          runnables[i].invoke(actualInput, optionsList[i])\n        );\n      const batchResult = await Promise.all(batchPromises);\n      batchResults.push(batchResult);\n    }\n    return batchResults.flat();\n  }\n\n  async stream(\n    input: RunInput,\n    options?: Partial<RunnableConfig>\n  ): Promise<IterableReadableStream<RunOutput>> {\n    const { key, input: actualInput } = input;\n    const runnable = this.runnables[key];\n    if (runnable === undefined) {\n      throw new Error(`No runnable associated with key \"${key}\".`);\n    }\n    return runnable.stream(actualInput, options);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,IAAa,iBAAb,cAIU,SAA8B;CACtC,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe,CAAC,kBAAkB,YAAY;CAE9C,kBAAkB;CAElB;CAEA,YAAY,QAET;AACD,QAAM,OAAO;AACb,OAAK,YAAY,OAAO;;CAG1B,MAAM,OACJ,OACA,SACoB;EACpB,MAAM,EAAE,KAAK,OAAO,gBAAgB;EACpC,MAAM,WAAW,KAAK,UAAU;AAChC,MAAI,aAAa,KAAA,EACf,OAAM,IAAI,MAAM,oCAAoC,IAAI,IAAI;AAE9D,SAAO,SAAS,OAAO,aAAa,aAAa,QAAQ,CAAC;;CAqB5D,MAAM,MACJ,QACA,SACA,cACgC;EAChC,MAAM,OAAO,OAAO,KAAK,UAAU,MAAM,IAAI;EAC7C,MAAM,eAAe,OAAO,KAAK,UAAU,MAAM,MAAM;AAEvD,MADmB,KAAK,MAAM,QAAQ,KAAK,UAAU,SAAS,KAAA,EAAU,KACrD,KAAA,EACjB,OAAM,IAAI,MAAM,yDAAyD;EAE3E,MAAM,YAAY,KAAK,KAAK,QAAQ,KAAK,UAAU,KAAK;EACxD,MAAM,cAAc,KAAK,gBAAgB,WAAW,EAAE,EAAE,OAAO,OAAO;EACtE,MAAM,iBACJ,YAAY,IAAI,kBAAkB,cAAc;EAClD,MAAM,YACJ,kBAAkB,iBAAiB,IAAI,iBAAiB,OAAO;EACjE,MAAM,eAAe,EAAE;AACvB,OAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK,WAAW;GACvD,MAAM,gBAAgB,aACnB,MAAM,GAAG,IAAI,UAAU,CACvB,KAAK,aAAa,MACjB,UAAU,GAAG,OAAO,aAAa,YAAY,GAAG,CACjD;GACH,MAAM,cAAc,MAAM,QAAQ,IAAI,cAAc;AACpD,gBAAa,KAAK,YAAY;;AAEhC,SAAO,aAAa,MAAM;;CAG5B,MAAM,OACJ,OACA,SAC4C;EAC5C,MAAM,EAAE,KAAK,OAAO,gBAAgB;EACpC,MAAM,WAAW,KAAK,UAAU;AAChC,MAAI,aAAa,KAAA,EACf,OAAM,IAAI,MAAM,oCAAoC,IAAI,IAAI;AAE9D,SAAO,SAAS,OAAO,aAAa,QAAQ"}
+{"version":3,"file":"router.js","names":[],"sources":["../../src/runnables/router.ts"],"sourcesContent":["import { Runnable, type RunnableBatchOptions } from \"./base.js\";\nimport { IterableReadableStream } from \"../utils/stream.js\";\nimport { ensureConfig, type RunnableConfig } from \"./config.js\";\n\nexport type RouterInput = {\n  key: string;\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  input: any;\n};\n\n/**\n * A runnable that routes to a set of runnables based on Input['key'].\n * Returns the output of the selected runnable.\n * @example\n * ```typescript\n * import { RouterRunnable, RunnableLambda } from \"@langchain/core/runnables\";\n *\n * const router = new RouterRunnable({\n *   runnables: {\n *     toUpperCase: RunnableLambda.from((text: string) => text.toUpperCase()),\n *     reverseText: RunnableLambda.from((text: string) =>\n *       text.split(\"\").reverse().join(\"\")\n *     ),\n *   },\n * });\n *\n * // Invoke the 'reverseText' runnable\n * const result1 = router.invoke({ key: \"reverseText\", input: \"Hello World\" });\n *\n * // \"dlroW olleH\"\n *\n * // Invoke the 'toUpperCase' runnable\n * const result2 = router.invoke({ key: \"toUpperCase\", input: \"Hello World\" });\n *\n * // \"HELLO WORLD\"\n * ```\n */\nexport class RouterRunnable<\n  RunInput extends RouterInput,\n  RunnableInput,\n  RunOutput,\n> extends Runnable<RunInput, RunOutput> {\n  static lc_name() {\n    return \"RouterRunnable\";\n  }\n\n  lc_namespace = [\"langchain_core\", \"runnables\"];\n\n  lc_serializable = true;\n\n  runnables: Record<string, Runnable<RunnableInput, RunOutput>>;\n\n  constructor(fields: {\n    runnables: Record<string, Runnable<RunnableInput, RunOutput>>;\n  }) {\n    super(fields);\n    this.runnables = fields.runnables;\n  }\n\n  async invoke(\n    input: RunInput,\n    options?: Partial<RunnableConfig>\n  ): Promise<RunOutput> {\n    const { key, input: actualInput } = input;\n    const runnable = this.runnables[key];\n    if (runnable === undefined) {\n      throw new Error(`No runnable associated with key \"${key}\".`);\n    }\n    return runnable.invoke(actualInput, ensureConfig(options));\n  }\n\n  async batch(\n    inputs: RunInput[],\n    options?: Partial<RunnableConfig> | Partial<RunnableConfig>[],\n    batchOptions?: RunnableBatchOptions & { returnExceptions?: false }\n  ): Promise<RunOutput[]>;\n\n  async batch(\n    inputs: RunInput[],\n    options?: Partial<RunnableConfig> | Partial<RunnableConfig>[],\n    batchOptions?: RunnableBatchOptions & { returnExceptions: true }\n  ): Promise<(RunOutput | Error)[]>;\n\n  async batch(\n    inputs: RunInput[],\n    options?: Partial<RunnableConfig> | Partial<RunnableConfig>[],\n    batchOptions?: RunnableBatchOptions\n  ): Promise<(RunOutput | Error)[]>;\n\n  async batch(\n    inputs: RunInput[],\n    options?: Partial<RunnableConfig> | Partial<RunnableConfig>[],\n    batchOptions?: RunnableBatchOptions\n  ): Promise<(RunOutput | Error)[]> {\n    const keys = inputs.map((input) => input.key);\n    const actualInputs = inputs.map((input) => input.input);\n    const missingKey = keys.find((key) => this.runnables[key] === undefined);\n    if (missingKey !== undefined) {\n      throw new Error(`One or more keys do not have a corresponding runnable.`);\n    }\n    const runnables = keys.map((key) => this.runnables[key]);\n    const optionsList = this._getOptionsList(options ?? {}, inputs.length);\n    const maxConcurrency =\n      optionsList[0]?.maxConcurrency ?? batchOptions?.maxConcurrency;\n    const batchSize =\n      maxConcurrency && maxConcurrency > 0 ? maxConcurrency : inputs.length;\n    const batchResults = [];\n    for (let i = 0; i < actualInputs.length; i += batchSize) {\n      const batchPromises = actualInputs\n        .slice(i, i + batchSize)\n        .map((actualInput, i) =>\n          runnables[i].invoke(actualInput, optionsList[i])\n        );\n      const batchResult = await Promise.all(batchPromises);\n      batchResults.push(batchResult);\n    }\n    return batchResults.flat();\n  }\n\n  async stream(\n    input: RunInput,\n    options?: Partial<RunnableConfig>\n  ): Promise<IterableReadableStream<RunOutput>> {\n    const { key, input: actualInput } = input;\n    const runnable = this.runnables[key];\n    if (runnable === undefined) {\n      throw new Error(`No runnable associated with key \"${key}\".`);\n    }\n    return runnable.stream(actualInput, options);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,IAAa,iBAAb,cAIU,SAA8B;CACtC,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe,CAAC,kBAAkB,YAAY;CAE9C,kBAAkB;CAElB;CAEA,YAAY,QAET;AACD,QAAM,OAAO;AACb,OAAK,YAAY,OAAO;;CAG1B,MAAM,OACJ,OACA,SACoB;EACpB,MAAM,EAAE,KAAK,OAAO,gBAAgB;EACpC,MAAM,WAAW,KAAK,UAAU;AAChC,MAAI,aAAa,KAAA,EACf,OAAM,IAAI,MAAM,oCAAoC,IAAI,IAAI;AAE9D,SAAO,SAAS,OAAO,aAAa,aAAa,QAAQ,CAAC;;CAqB5D,MAAM,MACJ,QACA,SACA,cACgC;EAChC,MAAM,OAAO,OAAO,KAAK,UAAU,MAAM,IAAI;EAC7C,MAAM,eAAe,OAAO,KAAK,UAAU,MAAM,MAAM;AAEvD,MADmB,KAAK,MAAM,QAAQ,KAAK,UAAU,SAAS,KAAA,EAChD,KAAK,KAAA,EACjB,OAAM,IAAI,MAAM,yDAAyD;EAE3E,MAAM,YAAY,KAAK,KAAK,QAAQ,KAAK,UAAU,KAAK;EACxD,MAAM,cAAc,KAAK,gBAAgB,WAAW,EAAE,EAAE,OAAO,OAAO;EACtE,MAAM,iBACJ,YAAY,IAAI,kBAAkB,cAAc;EAClD,MAAM,YACJ,kBAAkB,iBAAiB,IAAI,iBAAiB,OAAO;EACjE,MAAM,eAAe,EAAE;AACvB,OAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK,WAAW;GACvD,MAAM,gBAAgB,aACnB,MAAM,GAAG,IAAI,UAAU,CACvB,KAAK,aAAa,MACjB,UAAU,GAAG,OAAO,aAAa,YAAY,GAAG,CACjD;GACH,MAAM,cAAc,MAAM,QAAQ,IAAI,cAAc;AACpD,gBAAa,KAAK,YAAY;;AAEhC,SAAO,aAAa,MAAM;;CAG5B,MAAM,OACJ,OACA,SAC4C;EAC5C,MAAM,EAAE,KAAK,OAAO,gBAAgB;EACpC,MAAM,WAAW,KAAK,UAAU;AAChC,MAAI,aAAa,KAAA,EACf,OAAM,IAAI,MAAM,oCAAoC,IAAI,IAAI;AAE9D,SAAO,SAAS,OAAO,aAAa,QAAQ"}

package/dist/runnables/utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"utils.cjs","names":[],"sources":["../../src/runnables/utils.ts"],"sourcesContent":["import { StreamEvent } from \"../tracers/event_stream.js\";\nimport type { RunnableInterface } from \"./types.js\";\n\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isRunnableInterface(thing: any): thing is RunnableInterface {\n  return thing ? thing.lc_runnable : false;\n}\n\n/**\n * Utility to filter the root event in the streamEvents implementation.\n * This is simply binding the arguments to the namespace to make save on\n * a bit of typing in the streamEvents implementation.\n *\n * TODO: Refactor and remove.\n */\nexport class _RootEventFilter {\n  includeNames?: string[];\n\n  includeTypes?: string[];\n\n  includeTags?: string[];\n\n  excludeNames?: string[];\n\n  excludeTypes?: string[];\n\n  excludeTags?: string[];\n\n  constructor(fields: {\n    includeNames?: string[];\n    includeTypes?: string[];\n    includeTags?: string[];\n    excludeNames?: string[];\n    excludeTypes?: string[];\n    excludeTags?: string[];\n  }) {\n    this.includeNames = fields.includeNames;\n    this.includeTypes = fields.includeTypes;\n    this.includeTags = fields.includeTags;\n    this.excludeNames = fields.excludeNames;\n    this.excludeTypes = fields.excludeTypes;\n    this.excludeTags = fields.excludeTags;\n  }\n\n  includeEvent(event: StreamEvent, rootType: string): boolean {\n    let include =\n      this.includeNames === undefined &&\n      this.includeTypes === undefined &&\n      this.includeTags === undefined;\n    const eventTags = event.tags ?? [];\n\n    if (this.includeNames !== undefined) {\n      include = include || this.includeNames.includes(event.name);\n    }\n    if (this.includeTypes !== undefined) {\n      include = include || this.includeTypes.includes(rootType);\n    }\n    if (this.includeTags !== undefined) {\n      include =\n        include || eventTags.some((tag) => this.includeTags?.includes(tag));\n    }\n\n    if (this.excludeNames !== undefined) {\n      include = include && !this.excludeNames.includes(event.name);\n    }\n    if (this.excludeTypes !== undefined) {\n      include = include && !this.excludeTypes.includes(rootType);\n    }\n    if (this.excludeTags !== undefined) {\n      include =\n        include && eventTags.every((tag) => !this.excludeTags?.includes(tag));\n    }\n\n    return include;\n  }\n}\n\nexport const toBase64Url = (str: string): string => {\n  // Use btoa for compatibility, assume ASCII\n  const encoded = btoa(str);\n  return encoded.replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=+$/, \"\");\n};\n"],"mappings":";AAIA,SAAgB,oBAAoB,OAAwC;AAC1E,QAAO,QAAQ,MAAM,cAAc;;;;;;;;;AAUrC,IAAa,mBAAb,MAA8B;CAC5B;CAEA;CAEA;CAEA;CAEA;CAEA;CAEA,YAAY,QAOT;AACD,OAAK,eAAe,OAAO;AAC3B,OAAK,eAAe,OAAO;AAC3B,OAAK,cAAc,OAAO;AAC1B,OAAK,eAAe,OAAO;AAC3B,OAAK,eAAe,OAAO;AAC3B,OAAK,cAAc,OAAO;;CAG5B,aAAa,OAAoB,UAA2B;EAC1D,IAAI,UACF,KAAK,iBAAiB,KAAA,KACtB,KAAK,iBAAiB,KAAA,KACtB,KAAK,gBAAgB,KAAA;EACvB,MAAM,YAAY,MAAM,QAAQ,EAAE;AAElC,MAAI,KAAK,iBAAiB,KAAA,EACxB,WAAU,WAAW,KAAK,aAAa,SAAS,MAAM,KAAK;AAE7D,MAAI,KAAK,iBAAiB,KAAA,EACxB,WAAU,WAAW,KAAK,aAAa,SAAS,SAAS;AAE3D,MAAI,KAAK,gBAAgB,KAAA,EACvB,WACE,WAAW,UAAU,MAAM,QAAQ,KAAK,aAAa,SAAS,IAAI,CAAC;AAGvE,MAAI,KAAK,iBAAiB,KAAA,EACxB,WAAU,WAAW,CAAC,KAAK,aAAa,SAAS,MAAM,KAAK;AAE9D,MAAI,KAAK,iBAAiB,KAAA,EACxB,WAAU,WAAW,CAAC,KAAK,aAAa,SAAS,SAAS;AAE5D,MAAI,KAAK,gBAAgB,KAAA,EACvB,WACE,WAAW,UAAU,OAAO,QAAQ,CAAC,KAAK,aAAa,SAAS,IAAI,CAAC;AAGzE,SAAO;;;AAIX,MAAa,eAAe,QAAwB;AAGlD,QADgB,KAAK,IAAI,CACV,QAAQ,OAAO,IAAI,CAAC,QAAQ,OAAO,IAAI,CAAC,QAAQ,OAAO,GAAG"}
+{"version":3,"file":"utils.cjs","names":[],"sources":["../../src/runnables/utils.ts"],"sourcesContent":["import { StreamEvent } from \"../tracers/event_stream.js\";\nimport type { RunnableInterface } from \"./types.js\";\n\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isRunnableInterface(thing: any): thing is RunnableInterface {\n  return thing ? thing.lc_runnable : false;\n}\n\n/**\n * Utility to filter the root event in the streamEvents implementation.\n * This is simply binding the arguments to the namespace to make save on\n * a bit of typing in the streamEvents implementation.\n *\n * TODO: Refactor and remove.\n */\nexport class _RootEventFilter {\n  includeNames?: string[];\n\n  includeTypes?: string[];\n\n  includeTags?: string[];\n\n  excludeNames?: string[];\n\n  excludeTypes?: string[];\n\n  excludeTags?: string[];\n\n  constructor(fields: {\n    includeNames?: string[];\n    includeTypes?: string[];\n    includeTags?: string[];\n    excludeNames?: string[];\n    excludeTypes?: string[];\n    excludeTags?: string[];\n  }) {\n    this.includeNames = fields.includeNames;\n    this.includeTypes = fields.includeTypes;\n    this.includeTags = fields.includeTags;\n    this.excludeNames = fields.excludeNames;\n    this.excludeTypes = fields.excludeTypes;\n    this.excludeTags = fields.excludeTags;\n  }\n\n  includeEvent(event: StreamEvent, rootType: string): boolean {\n    let include =\n      this.includeNames === undefined &&\n      this.includeTypes === undefined &&\n      this.includeTags === undefined;\n    const eventTags = event.tags ?? [];\n\n    if (this.includeNames !== undefined) {\n      include = include || this.includeNames.includes(event.name);\n    }\n    if (this.includeTypes !== undefined) {\n      include = include || this.includeTypes.includes(rootType);\n    }\n    if (this.includeTags !== undefined) {\n      include =\n        include || eventTags.some((tag) => this.includeTags?.includes(tag));\n    }\n\n    if (this.excludeNames !== undefined) {\n      include = include && !this.excludeNames.includes(event.name);\n    }\n    if (this.excludeTypes !== undefined) {\n      include = include && !this.excludeTypes.includes(rootType);\n    }\n    if (this.excludeTags !== undefined) {\n      include =\n        include && eventTags.every((tag) => !this.excludeTags?.includes(tag));\n    }\n\n    return include;\n  }\n}\n\nexport const toBase64Url = (str: string): string => {\n  // Use btoa for compatibility, assume ASCII\n  const encoded = btoa(str);\n  return encoded.replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=+$/, \"\");\n};\n"],"mappings":";AAIA,SAAgB,oBAAoB,OAAwC;AAC1E,QAAO,QAAQ,MAAM,cAAc;;;;;;;;;AAUrC,IAAa,mBAAb,MAA8B;CAC5B;CAEA;CAEA;CAEA;CAEA;CAEA;CAEA,YAAY,QAOT;AACD,OAAK,eAAe,OAAO;AAC3B,OAAK,eAAe,OAAO;AAC3B,OAAK,cAAc,OAAO;AAC1B,OAAK,eAAe,OAAO;AAC3B,OAAK,eAAe,OAAO;AAC3B,OAAK,cAAc,OAAO;;CAG5B,aAAa,OAAoB,UAA2B;EAC1D,IAAI,UACF,KAAK,iBAAiB,KAAA,KACtB,KAAK,iBAAiB,KAAA,KACtB,KAAK,gBAAgB,KAAA;EACvB,MAAM,YAAY,MAAM,QAAQ,EAAE;AAElC,MAAI,KAAK,iBAAiB,KAAA,EACxB,WAAU,WAAW,KAAK,aAAa,SAAS,MAAM,KAAK;AAE7D,MAAI,KAAK,iBAAiB,KAAA,EACxB,WAAU,WAAW,KAAK,aAAa,SAAS,SAAS;AAE3D,MAAI,KAAK,gBAAgB,KAAA,EACvB,WACE,WAAW,UAAU,MAAM,QAAQ,KAAK,aAAa,SAAS,IAAI,CAAC;AAGvE,MAAI,KAAK,iBAAiB,KAAA,EACxB,WAAU,WAAW,CAAC,KAAK,aAAa,SAAS,MAAM,KAAK;AAE9D,MAAI,KAAK,iBAAiB,KAAA,EACxB,WAAU,WAAW,CAAC,KAAK,aAAa,SAAS,SAAS;AAE5D,MAAI,KAAK,gBAAgB,KAAA,EACvB,WACE,WAAW,UAAU,OAAO,QAAQ,CAAC,KAAK,aAAa,SAAS,IAAI,CAAC;AAGzE,SAAO;;;AAIX,MAAa,eAAe,QAAwB;AAGlD,QADgB,KAAK,IACP,CAAC,QAAQ,OAAO,IAAI,CAAC,QAAQ,OAAO,IAAI,CAAC,QAAQ,OAAO,GAAG"}

package/dist/runnables/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","names":[],"sources":["../../src/runnables/utils.ts"],"sourcesContent":["import { StreamEvent } from \"../tracers/event_stream.js\";\nimport type { RunnableInterface } from \"./types.js\";\n\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isRunnableInterface(thing: any): thing is RunnableInterface {\n  return thing ? thing.lc_runnable : false;\n}\n\n/**\n * Utility to filter the root event in the streamEvents implementation.\n * This is simply binding the arguments to the namespace to make save on\n * a bit of typing in the streamEvents implementation.\n *\n * TODO: Refactor and remove.\n */\nexport class _RootEventFilter {\n  includeNames?: string[];\n\n  includeTypes?: string[];\n\n  includeTags?: string[];\n\n  excludeNames?: string[];\n\n  excludeTypes?: string[];\n\n  excludeTags?: string[];\n\n  constructor(fields: {\n    includeNames?: string[];\n    includeTypes?: string[];\n    includeTags?: string[];\n    excludeNames?: string[];\n    excludeTypes?: string[];\n    excludeTags?: string[];\n  }) {\n    this.includeNames = fields.includeNames;\n    this.includeTypes = fields.includeTypes;\n    this.includeTags = fields.includeTags;\n    this.excludeNames = fields.excludeNames;\n    this.excludeTypes = fields.excludeTypes;\n    this.excludeTags = fields.excludeTags;\n  }\n\n  includeEvent(event: StreamEvent, rootType: string): boolean {\n    let include =\n      this.includeNames === undefined &&\n      this.includeTypes === undefined &&\n      this.includeTags === undefined;\n    const eventTags = event.tags ?? [];\n\n    if (this.includeNames !== undefined) {\n      include = include || this.includeNames.includes(event.name);\n    }\n    if (this.includeTypes !== undefined) {\n      include = include || this.includeTypes.includes(rootType);\n    }\n    if (this.includeTags !== undefined) {\n      include =\n        include || eventTags.some((tag) => this.includeTags?.includes(tag));\n    }\n\n    if (this.excludeNames !== undefined) {\n      include = include && !this.excludeNames.includes(event.name);\n    }\n    if (this.excludeTypes !== undefined) {\n      include = include && !this.excludeTypes.includes(rootType);\n    }\n    if (this.excludeTags !== undefined) {\n      include =\n        include && eventTags.every((tag) => !this.excludeTags?.includes(tag));\n    }\n\n    return include;\n  }\n}\n\nexport const toBase64Url = (str: string): string => {\n  // Use btoa for compatibility, assume ASCII\n  const encoded = btoa(str);\n  return encoded.replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=+$/, \"\");\n};\n"],"mappings":";AAIA,SAAgB,oBAAoB,OAAwC;AAC1E,QAAO,QAAQ,MAAM,cAAc;;;;;;;;;AAUrC,IAAa,mBAAb,MAA8B;CAC5B;CAEA;CAEA;CAEA;CAEA;CAEA;CAEA,YAAY,QAOT;AACD,OAAK,eAAe,OAAO;AAC3B,OAAK,eAAe,OAAO;AAC3B,OAAK,cAAc,OAAO;AAC1B,OAAK,eAAe,OAAO;AAC3B,OAAK,eAAe,OAAO;AAC3B,OAAK,cAAc,OAAO;;CAG5B,aAAa,OAAoB,UAA2B;EAC1D,IAAI,UACF,KAAK,iBAAiB,KAAA,KACtB,KAAK,iBAAiB,KAAA,KACtB,KAAK,gBAAgB,KAAA;EACvB,MAAM,YAAY,MAAM,QAAQ,EAAE;AAElC,MAAI,KAAK,iBAAiB,KAAA,EACxB,WAAU,WAAW,KAAK,aAAa,SAAS,MAAM,KAAK;AAE7D,MAAI,KAAK,iBAAiB,KAAA,EACxB,WAAU,WAAW,KAAK,aAAa,SAAS,SAAS;AAE3D,MAAI,KAAK,gBAAgB,KAAA,EACvB,WACE,WAAW,UAAU,MAAM,QAAQ,KAAK,aAAa,SAAS,IAAI,CAAC;AAGvE,MAAI,KAAK,iBAAiB,KAAA,EACxB,WAAU,WAAW,CAAC,KAAK,aAAa,SAAS,MAAM,KAAK;AAE9D,MAAI,KAAK,iBAAiB,KAAA,EACxB,WAAU,WAAW,CAAC,KAAK,aAAa,SAAS,SAAS;AAE5D,MAAI,KAAK,gBAAgB,KAAA,EACvB,WACE,WAAW,UAAU,OAAO,QAAQ,CAAC,KAAK,aAAa,SAAS,IAAI,CAAC;AAGzE,SAAO;;;AAIX,MAAa,eAAe,QAAwB;AAGlD,QADgB,KAAK,IAAI,CACV,QAAQ,OAAO,IAAI,CAAC,QAAQ,OAAO,IAAI,CAAC,QAAQ,OAAO,GAAG"}
+{"version":3,"file":"utils.js","names":[],"sources":["../../src/runnables/utils.ts"],"sourcesContent":["import { StreamEvent } from \"../tracers/event_stream.js\";\nimport type { RunnableInterface } from \"./types.js\";\n\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isRunnableInterface(thing: any): thing is RunnableInterface {\n  return thing ? thing.lc_runnable : false;\n}\n\n/**\n * Utility to filter the root event in the streamEvents implementation.\n * This is simply binding the arguments to the namespace to make save on\n * a bit of typing in the streamEvents implementation.\n *\n * TODO: Refactor and remove.\n */\nexport class _RootEventFilter {\n  includeNames?: string[];\n\n  includeTypes?: string[];\n\n  includeTags?: string[];\n\n  excludeNames?: string[];\n\n  excludeTypes?: string[];\n\n  excludeTags?: string[];\n\n  constructor(fields: {\n    includeNames?: string[];\n    includeTypes?: string[];\n    includeTags?: string[];\n    excludeNames?: string[];\n    excludeTypes?: string[];\n    excludeTags?: string[];\n  }) {\n    this.includeNames = fields.includeNames;\n    this.includeTypes = fields.includeTypes;\n    this.includeTags = fields.includeTags;\n    this.excludeNames = fields.excludeNames;\n    this.excludeTypes = fields.excludeTypes;\n    this.excludeTags = fields.excludeTags;\n  }\n\n  includeEvent(event: StreamEvent, rootType: string): boolean {\n    let include =\n      this.includeNames === undefined &&\n      this.includeTypes === undefined &&\n      this.includeTags === undefined;\n    const eventTags = event.tags ?? [];\n\n    if (this.includeNames !== undefined) {\n      include = include || this.includeNames.includes(event.name);\n    }\n    if (this.includeTypes !== undefined) {\n      include = include || this.includeTypes.includes(rootType);\n    }\n    if (this.includeTags !== undefined) {\n      include =\n        include || eventTags.some((tag) => this.includeTags?.includes(tag));\n    }\n\n    if (this.excludeNames !== undefined) {\n      include = include && !this.excludeNames.includes(event.name);\n    }\n    if (this.excludeTypes !== undefined) {\n      include = include && !this.excludeTypes.includes(rootType);\n    }\n    if (this.excludeTags !== undefined) {\n      include =\n        include && eventTags.every((tag) => !this.excludeTags?.includes(tag));\n    }\n\n    return include;\n  }\n}\n\nexport const toBase64Url = (str: string): string => {\n  // Use btoa for compatibility, assume ASCII\n  const encoded = btoa(str);\n  return encoded.replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=+$/, \"\");\n};\n"],"mappings":";AAIA,SAAgB,oBAAoB,OAAwC;AAC1E,QAAO,QAAQ,MAAM,cAAc;;;;;;;;;AAUrC,IAAa,mBAAb,MAA8B;CAC5B;CAEA;CAEA;CAEA;CAEA;CAEA;CAEA,YAAY,QAOT;AACD,OAAK,eAAe,OAAO;AAC3B,OAAK,eAAe,OAAO;AAC3B,OAAK,cAAc,OAAO;AAC1B,OAAK,eAAe,OAAO;AAC3B,OAAK,eAAe,OAAO;AAC3B,OAAK,cAAc,OAAO;;CAG5B,aAAa,OAAoB,UAA2B;EAC1D,IAAI,UACF,KAAK,iBAAiB,KAAA,KACtB,KAAK,iBAAiB,KAAA,KACtB,KAAK,gBAAgB,KAAA;EACvB,MAAM,YAAY,MAAM,QAAQ,EAAE;AAElC,MAAI,KAAK,iBAAiB,KAAA,EACxB,WAAU,WAAW,KAAK,aAAa,SAAS,MAAM,KAAK;AAE7D,MAAI,KAAK,iBAAiB,KAAA,EACxB,WAAU,WAAW,KAAK,aAAa,SAAS,SAAS;AAE3D,MAAI,KAAK,gBAAgB,KAAA,EACvB,WACE,WAAW,UAAU,MAAM,QAAQ,KAAK,aAAa,SAAS,IAAI,CAAC;AAGvE,MAAI,KAAK,iBAAiB,KAAA,EACxB,WAAU,WAAW,CAAC,KAAK,aAAa,SAAS,MAAM,KAAK;AAE9D,MAAI,KAAK,iBAAiB,KAAA,EACxB,WAAU,WAAW,CAAC,KAAK,aAAa,SAAS,SAAS;AAE5D,MAAI,KAAK,gBAAgB,KAAA,EACvB,WACE,WAAW,UAAU,OAAO,QAAQ,CAAC,KAAK,aAAa,SAAS,IAAI,CAAC;AAGzE,SAAO;;;AAIX,MAAa,eAAe,QAAwB;AAGlD,QADgB,KAAK,IACP,CAAC,QAAQ,OAAO,IAAI,CAAC,QAAQ,OAAO,IAAI,CAAC,QAAQ,OAAO,GAAG"}

package/dist/singletons/async_local_storage/context.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"context.cjs","names":["getGlobalAsyncLocalStorageInstance","_CONTEXT_VARIABLES_KEY","RunTree"],"sources":["../../../src/singletons/async_local_storage/context.ts"],"sourcesContent":["import { isRunTree, RunTree } from \"langsmith/run_trees\";\nimport { BaseCallbackHandler } from \"../../callbacks/base.js\";\nimport {\n  _CONTEXT_VARIABLES_KEY,\n  getGlobalAsyncLocalStorageInstance,\n} from \"./globals.js\";\n\n/**\n * Set a context variable. Context variables are scoped to any\n * child runnables called by the current runnable, or globally if set outside\n * of any runnable.\n *\n * @remarks\n * This function is only supported in environments that support AsyncLocalStorage,\n * including Node.js, Deno, and Cloudflare Workers.\n *\n * @example\n * ```ts\n * import { RunnableLambda } from \"@langchain/core/runnables\";\n * import {\n *   getContextVariable,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const nested = RunnableLambda.from(() => {\n *   // \"bar\" because it was set by a parent\n *   console.log(getContextVariable(\"foo\"));\n *\n *   // Override to \"baz\", but only for child runnables\n *   setContextVariable(\"foo\", \"baz\");\n *\n *   // Now \"baz\", but only for child runnables\n *   return getContextVariable(\"foo\");\n * });\n *\n * const runnable = RunnableLambda.from(async () => {\n *   // Set a context variable named \"foo\"\n *   setContextVariable(\"foo\", \"bar\");\n *\n *   const res = await nested.invoke({});\n *\n *   // Still \"bar\" since child changes do not affect parents\n *   console.log(getContextVariable(\"foo\"));\n *\n *   return res;\n * });\n *\n * // undefined, because context variable has not been set yet\n * console.log(getContextVariable(\"foo\"));\n *\n * // Final return value is \"baz\"\n * const result = await runnable.invoke({});\n * ```\n *\n * @param name The name of the context variable.\n * @param value The value to set.\n */\nexport function setContextVariable<T>(name: PropertyKey, value: T): void {\n  // Avoid using global singleton due to circuluar dependency issues\n  const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n  if (asyncLocalStorageInstance === undefined) {\n    throw new Error(\n      `Internal error: Global shared async local storage instance has not been initialized.`\n    );\n  }\n  const runTree = asyncLocalStorageInstance.getStore();\n  const contextVars = { ...runTree?.[_CONTEXT_VARIABLES_KEY] };\n  contextVars[name] = value;\n  let newValue = {};\n  if (isRunTree(runTree)) {\n    newValue = new RunTree(runTree);\n  }\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  (newValue as any)[_CONTEXT_VARIABLES_KEY] = contextVars;\n  asyncLocalStorageInstance.enterWith(newValue);\n}\n\n/**\n * Get the value of a previously set context variable. Context variables\n * are scoped to any child runnables called by the current runnable,\n * or globally if set outside of any runnable.\n *\n * @remarks\n * This function is only supported in environments that support AsyncLocalStorage,\n * including Node.js, Deno, and Cloudflare Workers.\n *\n * @example\n * ```ts\n * import { RunnableLambda } from \"@langchain/core/runnables\";\n * import {\n *   getContextVariable,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const nested = RunnableLambda.from(() => {\n *   // \"bar\" because it was set by a parent\n *   console.log(getContextVariable(\"foo\"));\n *\n *   // Override to \"baz\", but only for child runnables\n *   setContextVariable(\"foo\", \"baz\");\n *\n *   // Now \"baz\", but only for child runnables\n *   return getContextVariable(\"foo\");\n * });\n *\n * const runnable = RunnableLambda.from(async () => {\n *   // Set a context variable named \"foo\"\n *   setContextVariable(\"foo\", \"bar\");\n *\n *   const res = await nested.invoke({});\n *\n *   // Still \"bar\" since child changes do not affect parents\n *   console.log(getContextVariable(\"foo\"));\n *\n *   return res;\n * });\n *\n * // undefined, because context variable has not been set yet\n * console.log(getContextVariable(\"foo\"));\n *\n * // Final return value is \"baz\"\n * const result = await runnable.invoke({});\n * ```\n *\n * @param name The name of the context variable.\n */\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport function getContextVariable<T = any>(name: PropertyKey): T | undefined {\n  // Avoid using global singleton due to circuluar dependency issues\n  const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n  if (asyncLocalStorageInstance === undefined) {\n    return undefined;\n  }\n  const runTree = asyncLocalStorageInstance.getStore();\n  return runTree?.[_CONTEXT_VARIABLES_KEY]?.[name];\n}\n\nconst LC_CONFIGURE_HOOKS_KEY = Symbol(\"lc:configure_hooks\");\n\nexport const _getConfigureHooks = () =>\n  getContextVariable<ConfigureHook[]>(LC_CONFIGURE_HOOKS_KEY) || [];\n\n/**\n * Register a callback configure hook to automatically add callback handlers to all runs.\n *\n * There are two ways to use this:\n *\n * 1. Using a context variable:\n *    - Set `contextVar` to specify the variable name\n *    - Use `setContextVariable()` to store your handler instance\n *\n * 2. Using an environment variable:\n *    - Set both `envVar` and `handlerClass`\n *    - The handler will be instantiated when the env var is set to \"true\".\n *\n * @example\n * ```typescript\n * // Method 1: Using context variable\n * import {\n *   registerConfigureHook,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const tracer = new MyCallbackHandler();\n * registerConfigureHook({\n *   contextVar: \"my_tracer\",\n * });\n * setContextVariable(\"my_tracer\", tracer);\n *\n * // ...run code here\n *\n * // Method 2: Using environment variable\n * registerConfigureHook({\n *   handlerClass: MyCallbackHandler,\n *   envVar: \"MY_TRACER_ENABLED\",\n * });\n * process.env.MY_TRACER_ENABLED = \"true\";\n *\n * // ...run code here\n * ```\n *\n * @param config Configuration object for the hook\n * @param config.contextVar Name of the context variable containing the handler instance\n * @param config.inheritable Whether child runs should inherit this handler\n * @param config.handlerClass Optional callback handler class (required if using envVar)\n * @param config.envVar Optional environment variable name to control handler activation\n */\nexport const registerConfigureHook = (config: ConfigureHook) => {\n  if (config.envVar && !config.handlerClass) {\n    throw new Error(\n      \"If envVar is set, handlerClass must also be set to a non-None value.\"\n    );\n  }\n  setContextVariable(LC_CONFIGURE_HOOKS_KEY, [..._getConfigureHooks(), config]);\n};\n\nexport type ConfigureHook = {\n  contextVar?: string;\n  inheritable?: boolean;\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  handlerClass?: new (...args: any[]) => BaseCallbackHandler;\n  envVar?: string;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,SAAgB,mBAAsB,MAAmB,OAAgB;CAEvE,MAAM,4BAA4BA,gBAAAA,oCAAoC;AACtE,KAAI,8BAA8B,KAAA,EAChC,OAAM,IAAI,MACR,uFACD;CAEH,MAAM,UAAU,0BAA0B,UAAU;CACpD,MAAM,cAAc,EAAE,GAAG,UAAUC,gBAAAA,yBAAyB;AAC5D,aAAY,QAAQ;CACpB,IAAI,WAAW,EAAE;AACjB,MAAA,GAAA,oBAAA,WAAc,QAAQ,CACpB,YAAW,IAAIC,oBAAAA,QAAQ,QAAQ;AAGhC,UAAiBD,gBAAAA,0BAA0B;AAC5C,2BAA0B,UAAU,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqD/C,SAAgB,mBAA4B,MAAkC;CAE5E,MAAM,4BAA4BD,gBAAAA,oCAAoC;AACtE,KAAI,8BAA8B,KAAA,EAChC;AAGF,QADgB,0BAA0B,UAAU,GACnCC,gBAAAA,0BAA0B;;AAG7C,MAAM,yBAAyB,OAAO,qBAAqB;AAE3D,MAAa,2BACX,mBAAoC,uBAAuB,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CnE,MAAa,yBAAyB,WAA0B;AAC9D,KAAI,OAAO,UAAU,CAAC,OAAO,aAC3B,OAAM,IAAI,MACR,uEACD;AAEH,oBAAmB,wBAAwB,CAAC,GAAG,oBAAoB,EAAE,OAAO,CAAC"}
+{"version":3,"file":"context.cjs","names":["getGlobalAsyncLocalStorageInstance","_CONTEXT_VARIABLES_KEY","RunTree"],"sources":["../../../src/singletons/async_local_storage/context.ts"],"sourcesContent":["import { isRunTree, RunTree } from \"langsmith/run_trees\";\nimport { BaseCallbackHandler } from \"../../callbacks/base.js\";\nimport {\n  _CONTEXT_VARIABLES_KEY,\n  getGlobalAsyncLocalStorageInstance,\n} from \"./globals.js\";\n\n/**\n * Set a context variable. Context variables are scoped to any\n * child runnables called by the current runnable, or globally if set outside\n * of any runnable.\n *\n * @remarks\n * This function is only supported in environments that support AsyncLocalStorage,\n * including Node.js, Deno, and Cloudflare Workers.\n *\n * @example\n * ```ts\n * import { RunnableLambda } from \"@langchain/core/runnables\";\n * import {\n *   getContextVariable,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const nested = RunnableLambda.from(() => {\n *   // \"bar\" because it was set by a parent\n *   console.log(getContextVariable(\"foo\"));\n *\n *   // Override to \"baz\", but only for child runnables\n *   setContextVariable(\"foo\", \"baz\");\n *\n *   // Now \"baz\", but only for child runnables\n *   return getContextVariable(\"foo\");\n * });\n *\n * const runnable = RunnableLambda.from(async () => {\n *   // Set a context variable named \"foo\"\n *   setContextVariable(\"foo\", \"bar\");\n *\n *   const res = await nested.invoke({});\n *\n *   // Still \"bar\" since child changes do not affect parents\n *   console.log(getContextVariable(\"foo\"));\n *\n *   return res;\n * });\n *\n * // undefined, because context variable has not been set yet\n * console.log(getContextVariable(\"foo\"));\n *\n * // Final return value is \"baz\"\n * const result = await runnable.invoke({});\n * ```\n *\n * @param name The name of the context variable.\n * @param value The value to set.\n */\nexport function setContextVariable<T>(name: PropertyKey, value: T): void {\n  // Avoid using global singleton due to circuluar dependency issues\n  const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n  if (asyncLocalStorageInstance === undefined) {\n    throw new Error(\n      `Internal error: Global shared async local storage instance has not been initialized.`\n    );\n  }\n  const runTree = asyncLocalStorageInstance.getStore();\n  const contextVars = { ...runTree?.[_CONTEXT_VARIABLES_KEY] };\n  contextVars[name] = value;\n  let newValue = {};\n  if (isRunTree(runTree)) {\n    newValue = new RunTree(runTree);\n  }\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  (newValue as any)[_CONTEXT_VARIABLES_KEY] = contextVars;\n  asyncLocalStorageInstance.enterWith(newValue);\n}\n\n/**\n * Get the value of a previously set context variable. Context variables\n * are scoped to any child runnables called by the current runnable,\n * or globally if set outside of any runnable.\n *\n * @remarks\n * This function is only supported in environments that support AsyncLocalStorage,\n * including Node.js, Deno, and Cloudflare Workers.\n *\n * @example\n * ```ts\n * import { RunnableLambda } from \"@langchain/core/runnables\";\n * import {\n *   getContextVariable,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const nested = RunnableLambda.from(() => {\n *   // \"bar\" because it was set by a parent\n *   console.log(getContextVariable(\"foo\"));\n *\n *   // Override to \"baz\", but only for child runnables\n *   setContextVariable(\"foo\", \"baz\");\n *\n *   // Now \"baz\", but only for child runnables\n *   return getContextVariable(\"foo\");\n * });\n *\n * const runnable = RunnableLambda.from(async () => {\n *   // Set a context variable named \"foo\"\n *   setContextVariable(\"foo\", \"bar\");\n *\n *   const res = await nested.invoke({});\n *\n *   // Still \"bar\" since child changes do not affect parents\n *   console.log(getContextVariable(\"foo\"));\n *\n *   return res;\n * });\n *\n * // undefined, because context variable has not been set yet\n * console.log(getContextVariable(\"foo\"));\n *\n * // Final return value is \"baz\"\n * const result = await runnable.invoke({});\n * ```\n *\n * @param name The name of the context variable.\n */\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport function getContextVariable<T = any>(name: PropertyKey): T | undefined {\n  // Avoid using global singleton due to circuluar dependency issues\n  const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n  if (asyncLocalStorageInstance === undefined) {\n    return undefined;\n  }\n  const runTree = asyncLocalStorageInstance.getStore();\n  return runTree?.[_CONTEXT_VARIABLES_KEY]?.[name];\n}\n\nconst LC_CONFIGURE_HOOKS_KEY = Symbol(\"lc:configure_hooks\");\n\nexport const _getConfigureHooks = () =>\n  getContextVariable<ConfigureHook[]>(LC_CONFIGURE_HOOKS_KEY) || [];\n\n/**\n * Register a callback configure hook to automatically add callback handlers to all runs.\n *\n * There are two ways to use this:\n *\n * 1. Using a context variable:\n *    - Set `contextVar` to specify the variable name\n *    - Use `setContextVariable()` to store your handler instance\n *\n * 2. Using an environment variable:\n *    - Set both `envVar` and `handlerClass`\n *    - The handler will be instantiated when the env var is set to \"true\".\n *\n * @example\n * ```typescript\n * // Method 1: Using context variable\n * import {\n *   registerConfigureHook,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const tracer = new MyCallbackHandler();\n * registerConfigureHook({\n *   contextVar: \"my_tracer\",\n * });\n * setContextVariable(\"my_tracer\", tracer);\n *\n * // ...run code here\n *\n * // Method 2: Using environment variable\n * registerConfigureHook({\n *   handlerClass: MyCallbackHandler,\n *   envVar: \"MY_TRACER_ENABLED\",\n * });\n * process.env.MY_TRACER_ENABLED = \"true\";\n *\n * // ...run code here\n * ```\n *\n * @param config Configuration object for the hook\n * @param config.contextVar Name of the context variable containing the handler instance\n * @param config.inheritable Whether child runs should inherit this handler\n * @param config.handlerClass Optional callback handler class (required if using envVar)\n * @param config.envVar Optional environment variable name to control handler activation\n */\nexport const registerConfigureHook = (config: ConfigureHook) => {\n  if (config.envVar && !config.handlerClass) {\n    throw new Error(\n      \"If envVar is set, handlerClass must also be set to a non-None value.\"\n    );\n  }\n  setContextVariable(LC_CONFIGURE_HOOKS_KEY, [..._getConfigureHooks(), config]);\n};\n\nexport type ConfigureHook = {\n  contextVar?: string;\n  inheritable?: boolean;\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  handlerClass?: new (...args: any[]) => BaseCallbackHandler;\n  envVar?: string;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,SAAgB,mBAAsB,MAAmB,OAAgB;CAEvE,MAAM,4BAA4BA,gBAAAA,oCAAoC;AACtE,KAAI,8BAA8B,KAAA,EAChC,OAAM,IAAI,MACR,uFACD;CAEH,MAAM,UAAU,0BAA0B,UAAU;CACpD,MAAM,cAAc,EAAE,GAAG,UAAUC,gBAAAA,yBAAyB;AAC5D,aAAY,QAAQ;CACpB,IAAI,WAAW,EAAE;AACjB,MAAA,GAAA,oBAAA,WAAc,QAAQ,CACpB,YAAW,IAAIC,oBAAAA,QAAQ,QAAQ;AAGhC,UAAiBD,gBAAAA,0BAA0B;AAC5C,2BAA0B,UAAU,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqD/C,SAAgB,mBAA4B,MAAkC;CAE5E,MAAM,4BAA4BD,gBAAAA,oCAAoC;AACtE,KAAI,8BAA8B,KAAA,EAChC;AAGF,QADgB,0BAA0B,UAC5B,GAAGC,gBAAAA,0BAA0B;;AAG7C,MAAM,yBAAyB,OAAO,qBAAqB;AAE3D,MAAa,2BACX,mBAAoC,uBAAuB,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CnE,MAAa,yBAAyB,WAA0B;AAC9D,KAAI,OAAO,UAAU,CAAC,OAAO,aAC3B,OAAM,IAAI,MACR,uEACD;AAEH,oBAAmB,wBAAwB,CAAC,GAAG,oBAAoB,EAAE,OAAO,CAAC"}

package/dist/singletons/async_local_storage/context.js.map

@@ -1 +1 @@
-{"version":3,"file":"context.js","names":[],"sources":["../../../src/singletons/async_local_storage/context.ts"],"sourcesContent":["import { isRunTree, RunTree } from \"langsmith/run_trees\";\nimport { BaseCallbackHandler } from \"../../callbacks/base.js\";\nimport {\n  _CONTEXT_VARIABLES_KEY,\n  getGlobalAsyncLocalStorageInstance,\n} from \"./globals.js\";\n\n/**\n * Set a context variable. Context variables are scoped to any\n * child runnables called by the current runnable, or globally if set outside\n * of any runnable.\n *\n * @remarks\n * This function is only supported in environments that support AsyncLocalStorage,\n * including Node.js, Deno, and Cloudflare Workers.\n *\n * @example\n * ```ts\n * import { RunnableLambda } from \"@langchain/core/runnables\";\n * import {\n *   getContextVariable,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const nested = RunnableLambda.from(() => {\n *   // \"bar\" because it was set by a parent\n *   console.log(getContextVariable(\"foo\"));\n *\n *   // Override to \"baz\", but only for child runnables\n *   setContextVariable(\"foo\", \"baz\");\n *\n *   // Now \"baz\", but only for child runnables\n *   return getContextVariable(\"foo\");\n * });\n *\n * const runnable = RunnableLambda.from(async () => {\n *   // Set a context variable named \"foo\"\n *   setContextVariable(\"foo\", \"bar\");\n *\n *   const res = await nested.invoke({});\n *\n *   // Still \"bar\" since child changes do not affect parents\n *   console.log(getContextVariable(\"foo\"));\n *\n *   return res;\n * });\n *\n * // undefined, because context variable has not been set yet\n * console.log(getContextVariable(\"foo\"));\n *\n * // Final return value is \"baz\"\n * const result = await runnable.invoke({});\n * ```\n *\n * @param name The name of the context variable.\n * @param value The value to set.\n */\nexport function setContextVariable<T>(name: PropertyKey, value: T): void {\n  // Avoid using global singleton due to circuluar dependency issues\n  const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n  if (asyncLocalStorageInstance === undefined) {\n    throw new Error(\n      `Internal error: Global shared async local storage instance has not been initialized.`\n    );\n  }\n  const runTree = asyncLocalStorageInstance.getStore();\n  const contextVars = { ...runTree?.[_CONTEXT_VARIABLES_KEY] };\n  contextVars[name] = value;\n  let newValue = {};\n  if (isRunTree(runTree)) {\n    newValue = new RunTree(runTree);\n  }\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  (newValue as any)[_CONTEXT_VARIABLES_KEY] = contextVars;\n  asyncLocalStorageInstance.enterWith(newValue);\n}\n\n/**\n * Get the value of a previously set context variable. Context variables\n * are scoped to any child runnables called by the current runnable,\n * or globally if set outside of any runnable.\n *\n * @remarks\n * This function is only supported in environments that support AsyncLocalStorage,\n * including Node.js, Deno, and Cloudflare Workers.\n *\n * @example\n * ```ts\n * import { RunnableLambda } from \"@langchain/core/runnables\";\n * import {\n *   getContextVariable,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const nested = RunnableLambda.from(() => {\n *   // \"bar\" because it was set by a parent\n *   console.log(getContextVariable(\"foo\"));\n *\n *   // Override to \"baz\", but only for child runnables\n *   setContextVariable(\"foo\", \"baz\");\n *\n *   // Now \"baz\", but only for child runnables\n *   return getContextVariable(\"foo\");\n * });\n *\n * const runnable = RunnableLambda.from(async () => {\n *   // Set a context variable named \"foo\"\n *   setContextVariable(\"foo\", \"bar\");\n *\n *   const res = await nested.invoke({});\n *\n *   // Still \"bar\" since child changes do not affect parents\n *   console.log(getContextVariable(\"foo\"));\n *\n *   return res;\n * });\n *\n * // undefined, because context variable has not been set yet\n * console.log(getContextVariable(\"foo\"));\n *\n * // Final return value is \"baz\"\n * const result = await runnable.invoke({});\n * ```\n *\n * @param name The name of the context variable.\n */\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport function getContextVariable<T = any>(name: PropertyKey): T | undefined {\n  // Avoid using global singleton due to circuluar dependency issues\n  const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n  if (asyncLocalStorageInstance === undefined) {\n    return undefined;\n  }\n  const runTree = asyncLocalStorageInstance.getStore();\n  return runTree?.[_CONTEXT_VARIABLES_KEY]?.[name];\n}\n\nconst LC_CONFIGURE_HOOKS_KEY = Symbol(\"lc:configure_hooks\");\n\nexport const _getConfigureHooks = () =>\n  getContextVariable<ConfigureHook[]>(LC_CONFIGURE_HOOKS_KEY) || [];\n\n/**\n * Register a callback configure hook to automatically add callback handlers to all runs.\n *\n * There are two ways to use this:\n *\n * 1. Using a context variable:\n *    - Set `contextVar` to specify the variable name\n *    - Use `setContextVariable()` to store your handler instance\n *\n * 2. Using an environment variable:\n *    - Set both `envVar` and `handlerClass`\n *    - The handler will be instantiated when the env var is set to \"true\".\n *\n * @example\n * ```typescript\n * // Method 1: Using context variable\n * import {\n *   registerConfigureHook,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const tracer = new MyCallbackHandler();\n * registerConfigureHook({\n *   contextVar: \"my_tracer\",\n * });\n * setContextVariable(\"my_tracer\", tracer);\n *\n * // ...run code here\n *\n * // Method 2: Using environment variable\n * registerConfigureHook({\n *   handlerClass: MyCallbackHandler,\n *   envVar: \"MY_TRACER_ENABLED\",\n * });\n * process.env.MY_TRACER_ENABLED = \"true\";\n *\n * // ...run code here\n * ```\n *\n * @param config Configuration object for the hook\n * @param config.contextVar Name of the context variable containing the handler instance\n * @param config.inheritable Whether child runs should inherit this handler\n * @param config.handlerClass Optional callback handler class (required if using envVar)\n * @param config.envVar Optional environment variable name to control handler activation\n */\nexport const registerConfigureHook = (config: ConfigureHook) => {\n  if (config.envVar && !config.handlerClass) {\n    throw new Error(\n      \"If envVar is set, handlerClass must also be set to a non-None value.\"\n    );\n  }\n  setContextVariable(LC_CONFIGURE_HOOKS_KEY, [..._getConfigureHooks(), config]);\n};\n\nexport type ConfigureHook = {\n  contextVar?: string;\n  inheritable?: boolean;\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  handlerClass?: new (...args: any[]) => BaseCallbackHandler;\n  envVar?: string;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,SAAgB,mBAAsB,MAAmB,OAAgB;CAEvE,MAAM,4BAA4B,oCAAoC;AACtE,KAAI,8BAA8B,KAAA,EAChC,OAAM,IAAI,MACR,uFACD;CAEH,MAAM,UAAU,0BAA0B,UAAU;CACpD,MAAM,cAAc,EAAE,GAAG,UAAU,yBAAyB;AAC5D,aAAY,QAAQ;CACpB,IAAI,WAAW,EAAE;AACjB,KAAI,UAAU,QAAQ,CACpB,YAAW,IAAI,QAAQ,QAAQ;AAGhC,UAAiB,0BAA0B;AAC5C,2BAA0B,UAAU,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqD/C,SAAgB,mBAA4B,MAAkC;CAE5E,MAAM,4BAA4B,oCAAoC;AACtE,KAAI,8BAA8B,KAAA,EAChC;AAGF,QADgB,0BAA0B,UAAU,GACnC,0BAA0B;;AAG7C,MAAM,yBAAyB,OAAO,qBAAqB;AAE3D,MAAa,2BACX,mBAAoC,uBAAuB,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CnE,MAAa,yBAAyB,WAA0B;AAC9D,KAAI,OAAO,UAAU,CAAC,OAAO,aAC3B,OAAM,IAAI,MACR,uEACD;AAEH,oBAAmB,wBAAwB,CAAC,GAAG,oBAAoB,EAAE,OAAO,CAAC"}
+{"version":3,"file":"context.js","names":[],"sources":["../../../src/singletons/async_local_storage/context.ts"],"sourcesContent":["import { isRunTree, RunTree } from \"langsmith/run_trees\";\nimport { BaseCallbackHandler } from \"../../callbacks/base.js\";\nimport {\n  _CONTEXT_VARIABLES_KEY,\n  getGlobalAsyncLocalStorageInstance,\n} from \"./globals.js\";\n\n/**\n * Set a context variable. Context variables are scoped to any\n * child runnables called by the current runnable, or globally if set outside\n * of any runnable.\n *\n * @remarks\n * This function is only supported in environments that support AsyncLocalStorage,\n * including Node.js, Deno, and Cloudflare Workers.\n *\n * @example\n * ```ts\n * import { RunnableLambda } from \"@langchain/core/runnables\";\n * import {\n *   getContextVariable,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const nested = RunnableLambda.from(() => {\n *   // \"bar\" because it was set by a parent\n *   console.log(getContextVariable(\"foo\"));\n *\n *   // Override to \"baz\", but only for child runnables\n *   setContextVariable(\"foo\", \"baz\");\n *\n *   // Now \"baz\", but only for child runnables\n *   return getContextVariable(\"foo\");\n * });\n *\n * const runnable = RunnableLambda.from(async () => {\n *   // Set a context variable named \"foo\"\n *   setContextVariable(\"foo\", \"bar\");\n *\n *   const res = await nested.invoke({});\n *\n *   // Still \"bar\" since child changes do not affect parents\n *   console.log(getContextVariable(\"foo\"));\n *\n *   return res;\n * });\n *\n * // undefined, because context variable has not been set yet\n * console.log(getContextVariable(\"foo\"));\n *\n * // Final return value is \"baz\"\n * const result = await runnable.invoke({});\n * ```\n *\n * @param name The name of the context variable.\n * @param value The value to set.\n */\nexport function setContextVariable<T>(name: PropertyKey, value: T): void {\n  // Avoid using global singleton due to circuluar dependency issues\n  const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n  if (asyncLocalStorageInstance === undefined) {\n    throw new Error(\n      `Internal error: Global shared async local storage instance has not been initialized.`\n    );\n  }\n  const runTree = asyncLocalStorageInstance.getStore();\n  const contextVars = { ...runTree?.[_CONTEXT_VARIABLES_KEY] };\n  contextVars[name] = value;\n  let newValue = {};\n  if (isRunTree(runTree)) {\n    newValue = new RunTree(runTree);\n  }\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  (newValue as any)[_CONTEXT_VARIABLES_KEY] = contextVars;\n  asyncLocalStorageInstance.enterWith(newValue);\n}\n\n/**\n * Get the value of a previously set context variable. Context variables\n * are scoped to any child runnables called by the current runnable,\n * or globally if set outside of any runnable.\n *\n * @remarks\n * This function is only supported in environments that support AsyncLocalStorage,\n * including Node.js, Deno, and Cloudflare Workers.\n *\n * @example\n * ```ts\n * import { RunnableLambda } from \"@langchain/core/runnables\";\n * import {\n *   getContextVariable,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const nested = RunnableLambda.from(() => {\n *   // \"bar\" because it was set by a parent\n *   console.log(getContextVariable(\"foo\"));\n *\n *   // Override to \"baz\", but only for child runnables\n *   setContextVariable(\"foo\", \"baz\");\n *\n *   // Now \"baz\", but only for child runnables\n *   return getContextVariable(\"foo\");\n * });\n *\n * const runnable = RunnableLambda.from(async () => {\n *   // Set a context variable named \"foo\"\n *   setContextVariable(\"foo\", \"bar\");\n *\n *   const res = await nested.invoke({});\n *\n *   // Still \"bar\" since child changes do not affect parents\n *   console.log(getContextVariable(\"foo\"));\n *\n *   return res;\n * });\n *\n * // undefined, because context variable has not been set yet\n * console.log(getContextVariable(\"foo\"));\n *\n * // Final return value is \"baz\"\n * const result = await runnable.invoke({});\n * ```\n *\n * @param name The name of the context variable.\n */\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport function getContextVariable<T = any>(name: PropertyKey): T | undefined {\n  // Avoid using global singleton due to circuluar dependency issues\n  const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n  if (asyncLocalStorageInstance === undefined) {\n    return undefined;\n  }\n  const runTree = asyncLocalStorageInstance.getStore();\n  return runTree?.[_CONTEXT_VARIABLES_KEY]?.[name];\n}\n\nconst LC_CONFIGURE_HOOKS_KEY = Symbol(\"lc:configure_hooks\");\n\nexport const _getConfigureHooks = () =>\n  getContextVariable<ConfigureHook[]>(LC_CONFIGURE_HOOKS_KEY) || [];\n\n/**\n * Register a callback configure hook to automatically add callback handlers to all runs.\n *\n * There are two ways to use this:\n *\n * 1. Using a context variable:\n *    - Set `contextVar` to specify the variable name\n *    - Use `setContextVariable()` to store your handler instance\n *\n * 2. Using an environment variable:\n *    - Set both `envVar` and `handlerClass`\n *    - The handler will be instantiated when the env var is set to \"true\".\n *\n * @example\n * ```typescript\n * // Method 1: Using context variable\n * import {\n *   registerConfigureHook,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const tracer = new MyCallbackHandler();\n * registerConfigureHook({\n *   contextVar: \"my_tracer\",\n * });\n * setContextVariable(\"my_tracer\", tracer);\n *\n * // ...run code here\n *\n * // Method 2: Using environment variable\n * registerConfigureHook({\n *   handlerClass: MyCallbackHandler,\n *   envVar: \"MY_TRACER_ENABLED\",\n * });\n * process.env.MY_TRACER_ENABLED = \"true\";\n *\n * // ...run code here\n * ```\n *\n * @param config Configuration object for the hook\n * @param config.contextVar Name of the context variable containing the handler instance\n * @param config.inheritable Whether child runs should inherit this handler\n * @param config.handlerClass Optional callback handler class (required if using envVar)\n * @param config.envVar Optional environment variable name to control handler activation\n */\nexport const registerConfigureHook = (config: ConfigureHook) => {\n  if (config.envVar && !config.handlerClass) {\n    throw new Error(\n      \"If envVar is set, handlerClass must also be set to a non-None value.\"\n    );\n  }\n  setContextVariable(LC_CONFIGURE_HOOKS_KEY, [..._getConfigureHooks(), config]);\n};\n\nexport type ConfigureHook = {\n  contextVar?: string;\n  inheritable?: boolean;\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  handlerClass?: new (...args: any[]) => BaseCallbackHandler;\n  envVar?: string;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,SAAgB,mBAAsB,MAAmB,OAAgB;CAEvE,MAAM,4BAA4B,oCAAoC;AACtE,KAAI,8BAA8B,KAAA,EAChC,OAAM,IAAI,MACR,uFACD;CAEH,MAAM,UAAU,0BAA0B,UAAU;CACpD,MAAM,cAAc,EAAE,GAAG,UAAU,yBAAyB;AAC5D,aAAY,QAAQ;CACpB,IAAI,WAAW,EAAE;AACjB,KAAI,UAAU,QAAQ,CACpB,YAAW,IAAI,QAAQ,QAAQ;AAGhC,UAAiB,0BAA0B;AAC5C,2BAA0B,UAAU,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqD/C,SAAgB,mBAA4B,MAAkC;CAE5E,MAAM,4BAA4B,oCAAoC;AACtE,KAAI,8BAA8B,KAAA,EAChC;AAGF,QADgB,0BAA0B,UAC5B,GAAG,0BAA0B;;AAG7C,MAAM,yBAAyB,OAAO,qBAAqB;AAE3D,MAAa,2BACX,mBAAoC,uBAAuB,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CnE,MAAa,yBAAyB,WAA0B;AAC9D,KAAI,OAAO,UAAU,CAAC,OAAO,aAC3B,OAAM,IAAI,MACR,uEACD;AAEH,oBAAmB,wBAAwB,CAAC,GAAG,oBAAoB,EAAE,OAAO,CAAC"}

package/dist/singletons/async_local_storage/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["getGlobalAsyncLocalStorageInstance","CallbackManager","RunTree","_CONTEXT_VARIABLES_KEY"],"sources":["../../../src/singletons/async_local_storage/index.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\nimport { RunTree } from \"langsmith\";\nimport {\n  AsyncLocalStorageInterface,\n  getGlobalAsyncLocalStorageInstance,\n  setGlobalAsyncLocalStorageInstance,\n  _CONTEXT_VARIABLES_KEY,\n} from \"./globals.js\";\nimport { CallbackManager } from \"../../callbacks/manager.js\";\nimport { LangChainTracer } from \"../../tracers/tracer_langchain.js\";\n\nexport class MockAsyncLocalStorage implements AsyncLocalStorageInterface {\n  getStore(): any {\n    return undefined;\n  }\n\n  run<T>(_store: any, callback: () => T): T {\n    return callback();\n  }\n\n  enterWith(_store: any) {\n    return undefined;\n  }\n}\n\nconst mockAsyncLocalStorage = new MockAsyncLocalStorage();\n\nconst LC_CHILD_KEY = Symbol.for(\"lc:child_config\");\n\nclass AsyncLocalStorageProvider {\n  getInstance(): AsyncLocalStorageInterface {\n    return getGlobalAsyncLocalStorageInstance() ?? mockAsyncLocalStorage;\n  }\n\n  getRunnableConfig() {\n    const storage = this.getInstance();\n    // this has the runnable config\n    // which means that we should also have an instance of a LangChainTracer\n    // with the run map prepopulated\n    return storage.getStore()?.extra?.[LC_CHILD_KEY];\n  }\n\n  runWithConfig<T>(\n    config: any,\n    callback: () => T,\n    avoidCreatingRootRunTree?: boolean\n  ): T {\n    const callbackManager = CallbackManager._configureSync(\n      config?.callbacks,\n      undefined,\n      config?.tags,\n      undefined,\n      config?.metadata\n    );\n    const storage = this.getInstance();\n    const previousValue = storage.getStore();\n    const parentRunId = callbackManager?.getParentRunId();\n\n    const langChainTracer = callbackManager?.handlers?.find(\n      (handler) => handler?.name === \"langchain_tracer\"\n    ) as LangChainTracer | undefined;\n\n    let runTree;\n    if (langChainTracer && parentRunId) {\n      runTree = langChainTracer.getRunTreeWithTracingConfig(parentRunId);\n    } else if (!avoidCreatingRootRunTree) {\n      runTree = new RunTree({\n        name: \"<runnable_lambda>\",\n        tracingEnabled: false,\n      });\n    }\n\n    if (runTree) {\n      runTree.extra = { ...runTree.extra, [LC_CHILD_KEY]: config };\n    }\n\n    if (\n      previousValue !== undefined &&\n      previousValue[_CONTEXT_VARIABLES_KEY] !== undefined\n    ) {\n      if (runTree === undefined) {\n        runTree = {};\n      }\n      (runTree as any)[_CONTEXT_VARIABLES_KEY] =\n        previousValue[_CONTEXT_VARIABLES_KEY];\n    }\n\n    return storage.run(runTree, callback);\n  }\n\n  initializeGlobalInstance(instance: AsyncLocalStorageInterface) {\n    if (getGlobalAsyncLocalStorageInstance() === undefined) {\n      setGlobalAsyncLocalStorageInstance(instance);\n    }\n  }\n}\n\nconst AsyncLocalStorageProviderSingleton = new AsyncLocalStorageProvider();\n\nexport { AsyncLocalStorageProviderSingleton, type AsyncLocalStorageInterface };\n"],"mappings":";;;;;AAWA,IAAa,wBAAb,MAAyE;CACvE,WAAgB;CAIhB,IAAO,QAAa,UAAsB;AACxC,SAAO,UAAU;;CAGnB,UAAU,QAAa;;AAKzB,MAAM,wBAAwB,IAAI,uBAAuB;AAEzD,MAAM,eAAe,OAAO,IAAI,kBAAkB;AAElD,IAAM,4BAAN,MAAgC;CAC9B,cAA0C;AACxC,SAAOA,gBAAAA,oCAAoC,IAAI;;CAGjD,oBAAoB;AAKlB,SAJgB,KAAK,aAAa,CAInB,UAAU,EAAE,QAAQ;;CAGrC,cACE,QACA,UACA,0BACG;EACH,MAAM,kBAAkBC,0BAAAA,gBAAgB,eACtC,QAAQ,WACR,KAAA,GACA,QAAQ,MACR,KAAA,GACA,QAAQ,SACT;EACD,MAAM,UAAU,KAAK,aAAa;EAClC,MAAM,gBAAgB,QAAQ,UAAU;EACxC,MAAM,cAAc,iBAAiB,gBAAgB;EAErD,MAAM,kBAAkB,iBAAiB,UAAU,MAChD,YAAY,SAAS,SAAS,mBAChC;EAED,IAAI;AACJ,MAAI,mBAAmB,YACrB,WAAU,gBAAgB,4BAA4B,YAAY;WACzD,CAAC,yBACV,WAAU,IAAIC,UAAAA,QAAQ;GACpB,MAAM;GACN,gBAAgB;GACjB,CAAC;AAGJ,MAAI,QACF,SAAQ,QAAQ;GAAE,GAAG,QAAQ;IAAQ,eAAe;GAAQ;AAG9D,MACE,kBAAkB,KAAA,KAClB,cAAcC,gBAAAA,4BAA4B,KAAA,GAC1C;AACA,OAAI,YAAY,KAAA,EACd,WAAU,EAAE;AAEb,WAAgBA,gBAAAA,0BACf,cAAcA,gBAAAA;;AAGlB,SAAO,QAAQ,IAAI,SAAS,SAAS;;CAGvC,yBAAyB,UAAsC;AAC7D,MAAIH,gBAAAA,oCAAoC,KAAK,KAAA,EAC3C,iBAAA,mCAAmC,SAAS;;;AAKlD,MAAM,qCAAqC,IAAI,2BAA2B"}
+{"version":3,"file":"index.cjs","names":["getGlobalAsyncLocalStorageInstance","CallbackManager","RunTree","_CONTEXT_VARIABLES_KEY"],"sources":["../../../src/singletons/async_local_storage/index.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\nimport { RunTree } from \"langsmith\";\nimport {\n  AsyncLocalStorageInterface,\n  getGlobalAsyncLocalStorageInstance,\n  setGlobalAsyncLocalStorageInstance,\n  _CONTEXT_VARIABLES_KEY,\n} from \"./globals.js\";\nimport { CallbackManager } from \"../../callbacks/manager.js\";\nimport { LangChainTracer } from \"../../tracers/tracer_langchain.js\";\n\nexport class MockAsyncLocalStorage implements AsyncLocalStorageInterface {\n  getStore(): any {\n    return undefined;\n  }\n\n  run<T>(_store: any, callback: () => T): T {\n    return callback();\n  }\n\n  enterWith(_store: any) {\n    return undefined;\n  }\n}\n\nconst mockAsyncLocalStorage = new MockAsyncLocalStorage();\n\nconst LC_CHILD_KEY = Symbol.for(\"lc:child_config\");\n\nclass AsyncLocalStorageProvider {\n  getInstance(): AsyncLocalStorageInterface {\n    return getGlobalAsyncLocalStorageInstance() ?? mockAsyncLocalStorage;\n  }\n\n  getRunnableConfig() {\n    const storage = this.getInstance();\n    // this has the runnable config\n    // which means that we should also have an instance of a LangChainTracer\n    // with the run map prepopulated\n    return storage.getStore()?.extra?.[LC_CHILD_KEY];\n  }\n\n  runWithConfig<T>(\n    config: any,\n    callback: () => T,\n    avoidCreatingRootRunTree?: boolean\n  ): T {\n    const callbackManager = CallbackManager._configureSync(\n      config?.callbacks,\n      undefined,\n      config?.tags,\n      undefined,\n      config?.metadata\n    );\n    const storage = this.getInstance();\n    const previousValue = storage.getStore();\n    const parentRunId = callbackManager?.getParentRunId();\n\n    const langChainTracer = callbackManager?.handlers?.find(\n      (handler) => handler?.name === \"langchain_tracer\"\n    ) as LangChainTracer | undefined;\n\n    let runTree;\n    if (langChainTracer && parentRunId) {\n      runTree = langChainTracer.getRunTreeWithTracingConfig(parentRunId);\n    } else if (!avoidCreatingRootRunTree) {\n      runTree = new RunTree({\n        name: \"<runnable_lambda>\",\n        tracingEnabled: false,\n      });\n    }\n\n    if (runTree) {\n      runTree.extra = { ...runTree.extra, [LC_CHILD_KEY]: config };\n    }\n\n    if (\n      previousValue !== undefined &&\n      previousValue[_CONTEXT_VARIABLES_KEY] !== undefined\n    ) {\n      if (runTree === undefined) {\n        runTree = {};\n      }\n      (runTree as any)[_CONTEXT_VARIABLES_KEY] =\n        previousValue[_CONTEXT_VARIABLES_KEY];\n    }\n\n    return storage.run(runTree, callback);\n  }\n\n  initializeGlobalInstance(instance: AsyncLocalStorageInterface) {\n    if (getGlobalAsyncLocalStorageInstance() === undefined) {\n      setGlobalAsyncLocalStorageInstance(instance);\n    }\n  }\n}\n\nconst AsyncLocalStorageProviderSingleton = new AsyncLocalStorageProvider();\n\nexport { AsyncLocalStorageProviderSingleton, type AsyncLocalStorageInterface };\n"],"mappings":";;;;;AAWA,IAAa,wBAAb,MAAyE;CACvE,WAAgB;CAIhB,IAAO,QAAa,UAAsB;AACxC,SAAO,UAAU;;CAGnB,UAAU,QAAa;;AAKzB,MAAM,wBAAwB,IAAI,uBAAuB;AAEzD,MAAM,eAAe,OAAO,IAAI,kBAAkB;AAElD,IAAM,4BAAN,MAAgC;CAC9B,cAA0C;AACxC,SAAOA,gBAAAA,oCAAoC,IAAI;;CAGjD,oBAAoB;AAKlB,SAJgB,KAAK,aAIP,CAAC,UAAU,EAAE,QAAQ;;CAGrC,cACE,QACA,UACA,0BACG;EACH,MAAM,kBAAkBC,0BAAAA,gBAAgB,eACtC,QAAQ,WACR,KAAA,GACA,QAAQ,MACR,KAAA,GACA,QAAQ,SACT;EACD,MAAM,UAAU,KAAK,aAAa;EAClC,MAAM,gBAAgB,QAAQ,UAAU;EACxC,MAAM,cAAc,iBAAiB,gBAAgB;EAErD,MAAM,kBAAkB,iBAAiB,UAAU,MAChD,YAAY,SAAS,SAAS,mBAChC;EAED,IAAI;AACJ,MAAI,mBAAmB,YACrB,WAAU,gBAAgB,4BAA4B,YAAY;WACzD,CAAC,yBACV,WAAU,IAAIC,UAAAA,QAAQ;GACpB,MAAM;GACN,gBAAgB;GACjB,CAAC;AAGJ,MAAI,QACF,SAAQ,QAAQ;GAAE,GAAG,QAAQ;IAAQ,eAAe;GAAQ;AAG9D,MACE,kBAAkB,KAAA,KAClB,cAAcC,gBAAAA,4BAA4B,KAAA,GAC1C;AACA,OAAI,YAAY,KAAA,EACd,WAAU,EAAE;AAEb,WAAgBA,gBAAAA,0BACf,cAAcA,gBAAAA;;AAGlB,SAAO,QAAQ,IAAI,SAAS,SAAS;;CAGvC,yBAAyB,UAAsC;AAC7D,MAAIH,gBAAAA,oCAAoC,KAAK,KAAA,EAC3C,iBAAA,mCAAmC,SAAS;;;AAKlD,MAAM,qCAAqC,IAAI,2BAA2B"}

package/dist/singletons/async_local_storage/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../src/singletons/async_local_storage/index.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\nimport { RunTree } from \"langsmith\";\nimport {\n  AsyncLocalStorageInterface,\n  getGlobalAsyncLocalStorageInstance,\n  setGlobalAsyncLocalStorageInstance,\n  _CONTEXT_VARIABLES_KEY,\n} from \"./globals.js\";\nimport { CallbackManager } from \"../../callbacks/manager.js\";\nimport { LangChainTracer } from \"../../tracers/tracer_langchain.js\";\n\nexport class MockAsyncLocalStorage implements AsyncLocalStorageInterface {\n  getStore(): any {\n    return undefined;\n  }\n\n  run<T>(_store: any, callback: () => T): T {\n    return callback();\n  }\n\n  enterWith(_store: any) {\n    return undefined;\n  }\n}\n\nconst mockAsyncLocalStorage = new MockAsyncLocalStorage();\n\nconst LC_CHILD_KEY = Symbol.for(\"lc:child_config\");\n\nclass AsyncLocalStorageProvider {\n  getInstance(): AsyncLocalStorageInterface {\n    return getGlobalAsyncLocalStorageInstance() ?? mockAsyncLocalStorage;\n  }\n\n  getRunnableConfig() {\n    const storage = this.getInstance();\n    // this has the runnable config\n    // which means that we should also have an instance of a LangChainTracer\n    // with the run map prepopulated\n    return storage.getStore()?.extra?.[LC_CHILD_KEY];\n  }\n\n  runWithConfig<T>(\n    config: any,\n    callback: () => T,\n    avoidCreatingRootRunTree?: boolean\n  ): T {\n    const callbackManager = CallbackManager._configureSync(\n      config?.callbacks,\n      undefined,\n      config?.tags,\n      undefined,\n      config?.metadata\n    );\n    const storage = this.getInstance();\n    const previousValue = storage.getStore();\n    const parentRunId = callbackManager?.getParentRunId();\n\n    const langChainTracer = callbackManager?.handlers?.find(\n      (handler) => handler?.name === \"langchain_tracer\"\n    ) as LangChainTracer | undefined;\n\n    let runTree;\n    if (langChainTracer && parentRunId) {\n      runTree = langChainTracer.getRunTreeWithTracingConfig(parentRunId);\n    } else if (!avoidCreatingRootRunTree) {\n      runTree = new RunTree({\n        name: \"<runnable_lambda>\",\n        tracingEnabled: false,\n      });\n    }\n\n    if (runTree) {\n      runTree.extra = { ...runTree.extra, [LC_CHILD_KEY]: config };\n    }\n\n    if (\n      previousValue !== undefined &&\n      previousValue[_CONTEXT_VARIABLES_KEY] !== undefined\n    ) {\n      if (runTree === undefined) {\n        runTree = {};\n      }\n      (runTree as any)[_CONTEXT_VARIABLES_KEY] =\n        previousValue[_CONTEXT_VARIABLES_KEY];\n    }\n\n    return storage.run(runTree, callback);\n  }\n\n  initializeGlobalInstance(instance: AsyncLocalStorageInterface) {\n    if (getGlobalAsyncLocalStorageInstance() === undefined) {\n      setGlobalAsyncLocalStorageInstance(instance);\n    }\n  }\n}\n\nconst AsyncLocalStorageProviderSingleton = new AsyncLocalStorageProvider();\n\nexport { AsyncLocalStorageProviderSingleton, type AsyncLocalStorageInterface };\n"],"mappings":";;;;AAWA,IAAa,wBAAb,MAAyE;CACvE,WAAgB;CAIhB,IAAO,QAAa,UAAsB;AACxC,SAAO,UAAU;;CAGnB,UAAU,QAAa;;AAKzB,MAAM,wBAAwB,IAAI,uBAAuB;AAEzD,MAAM,eAAe,OAAO,IAAI,kBAAkB;AAElD,IAAM,4BAAN,MAAgC;CAC9B,cAA0C;AACxC,SAAO,oCAAoC,IAAI;;CAGjD,oBAAoB;AAKlB,SAJgB,KAAK,aAAa,CAInB,UAAU,EAAE,QAAQ;;CAGrC,cACE,QACA,UACA,0BACG;EACH,MAAM,kBAAkB,gBAAgB,eACtC,QAAQ,WACR,KAAA,GACA,QAAQ,MACR,KAAA,GACA,QAAQ,SACT;EACD,MAAM,UAAU,KAAK,aAAa;EAClC,MAAM,gBAAgB,QAAQ,UAAU;EACxC,MAAM,cAAc,iBAAiB,gBAAgB;EAErD,MAAM,kBAAkB,iBAAiB,UAAU,MAChD,YAAY,SAAS,SAAS,mBAChC;EAED,IAAI;AACJ,MAAI,mBAAmB,YACrB,WAAU,gBAAgB,4BAA4B,YAAY;WACzD,CAAC,yBACV,WAAU,IAAI,QAAQ;GACpB,MAAM;GACN,gBAAgB;GACjB,CAAC;AAGJ,MAAI,QACF,SAAQ,QAAQ;GAAE,GAAG,QAAQ;IAAQ,eAAe;GAAQ;AAG9D,MACE,kBAAkB,KAAA,KAClB,cAAc,4BAA4B,KAAA,GAC1C;AACA,OAAI,YAAY,KAAA,EACd,WAAU,EAAE;AAEb,WAAgB,0BACf,cAAc;;AAGlB,SAAO,QAAQ,IAAI,SAAS,SAAS;;CAGvC,yBAAyB,UAAsC;AAC7D,MAAI,oCAAoC,KAAK,KAAA,EAC3C,oCAAmC,SAAS;;;AAKlD,MAAM,qCAAqC,IAAI,2BAA2B"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/singletons/async_local_storage/index.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\nimport { RunTree } from \"langsmith\";\nimport {\n  AsyncLocalStorageInterface,\n  getGlobalAsyncLocalStorageInstance,\n  setGlobalAsyncLocalStorageInstance,\n  _CONTEXT_VARIABLES_KEY,\n} from \"./globals.js\";\nimport { CallbackManager } from \"../../callbacks/manager.js\";\nimport { LangChainTracer } from \"../../tracers/tracer_langchain.js\";\n\nexport class MockAsyncLocalStorage implements AsyncLocalStorageInterface {\n  getStore(): any {\n    return undefined;\n  }\n\n  run<T>(_store: any, callback: () => T): T {\n    return callback();\n  }\n\n  enterWith(_store: any) {\n    return undefined;\n  }\n}\n\nconst mockAsyncLocalStorage = new MockAsyncLocalStorage();\n\nconst LC_CHILD_KEY = Symbol.for(\"lc:child_config\");\n\nclass AsyncLocalStorageProvider {\n  getInstance(): AsyncLocalStorageInterface {\n    return getGlobalAsyncLocalStorageInstance() ?? mockAsyncLocalStorage;\n  }\n\n  getRunnableConfig() {\n    const storage = this.getInstance();\n    // this has the runnable config\n    // which means that we should also have an instance of a LangChainTracer\n    // with the run map prepopulated\n    return storage.getStore()?.extra?.[LC_CHILD_KEY];\n  }\n\n  runWithConfig<T>(\n    config: any,\n    callback: () => T,\n    avoidCreatingRootRunTree?: boolean\n  ): T {\n    const callbackManager = CallbackManager._configureSync(\n      config?.callbacks,\n      undefined,\n      config?.tags,\n      undefined,\n      config?.metadata\n    );\n    const storage = this.getInstance();\n    const previousValue = storage.getStore();\n    const parentRunId = callbackManager?.getParentRunId();\n\n    const langChainTracer = callbackManager?.handlers?.find(\n      (handler) => handler?.name === \"langchain_tracer\"\n    ) as LangChainTracer | undefined;\n\n    let runTree;\n    if (langChainTracer && parentRunId) {\n      runTree = langChainTracer.getRunTreeWithTracingConfig(parentRunId);\n    } else if (!avoidCreatingRootRunTree) {\n      runTree = new RunTree({\n        name: \"<runnable_lambda>\",\n        tracingEnabled: false,\n      });\n    }\n\n    if (runTree) {\n      runTree.extra = { ...runTree.extra, [LC_CHILD_KEY]: config };\n    }\n\n    if (\n      previousValue !== undefined &&\n      previousValue[_CONTEXT_VARIABLES_KEY] !== undefined\n    ) {\n      if (runTree === undefined) {\n        runTree = {};\n      }\n      (runTree as any)[_CONTEXT_VARIABLES_KEY] =\n        previousValue[_CONTEXT_VARIABLES_KEY];\n    }\n\n    return storage.run(runTree, callback);\n  }\n\n  initializeGlobalInstance(instance: AsyncLocalStorageInterface) {\n    if (getGlobalAsyncLocalStorageInstance() === undefined) {\n      setGlobalAsyncLocalStorageInstance(instance);\n    }\n  }\n}\n\nconst AsyncLocalStorageProviderSingleton = new AsyncLocalStorageProvider();\n\nexport { AsyncLocalStorageProviderSingleton, type AsyncLocalStorageInterface };\n"],"mappings":";;;;AAWA,IAAa,wBAAb,MAAyE;CACvE,WAAgB;CAIhB,IAAO,QAAa,UAAsB;AACxC,SAAO,UAAU;;CAGnB,UAAU,QAAa;;AAKzB,MAAM,wBAAwB,IAAI,uBAAuB;AAEzD,MAAM,eAAe,OAAO,IAAI,kBAAkB;AAElD,IAAM,4BAAN,MAAgC;CAC9B,cAA0C;AACxC,SAAO,oCAAoC,IAAI;;CAGjD,oBAAoB;AAKlB,SAJgB,KAAK,aAIP,CAAC,UAAU,EAAE,QAAQ;;CAGrC,cACE,QACA,UACA,0BACG;EACH,MAAM,kBAAkB,gBAAgB,eACtC,QAAQ,WACR,KAAA,GACA,QAAQ,MACR,KAAA,GACA,QAAQ,SACT;EACD,MAAM,UAAU,KAAK,aAAa;EAClC,MAAM,gBAAgB,QAAQ,UAAU;EACxC,MAAM,cAAc,iBAAiB,gBAAgB;EAErD,MAAM,kBAAkB,iBAAiB,UAAU,MAChD,YAAY,SAAS,SAAS,mBAChC;EAED,IAAI;AACJ,MAAI,mBAAmB,YACrB,WAAU,gBAAgB,4BAA4B,YAAY;WACzD,CAAC,yBACV,WAAU,IAAI,QAAQ;GACpB,MAAM;GACN,gBAAgB;GACjB,CAAC;AAGJ,MAAI,QACF,SAAQ,QAAQ;GAAE,GAAG,QAAQ;IAAQ,eAAe;GAAQ;AAG9D,MACE,kBAAkB,KAAA,KAClB,cAAc,4BAA4B,KAAA,GAC1C;AACA,OAAI,YAAY,KAAA,EACd,WAAU,EAAE;AAEb,WAAgB,0BACf,cAAc;;AAGlB,SAAO,QAAQ,IAAI,SAAS,SAAS;;CAGvC,yBAAyB,UAAsC;AAC7D,MAAI,oCAAoC,KAAK,KAAA,EAC3C,oCAAmC,SAAS;;;AAKlD,MAAM,qCAAqC,IAAI,2BAA2B"}

package/dist/testing/fake_model_builder.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"fake_model_builder.cjs","names":["BaseChatModel","BaseMessage","RunnableLambda","AIMessage"],"sources":["../../src/testing/fake_model_builder.ts"],"sourcesContent":["/* oxlint-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 \"../utils/types/zod.js\";\nimport type { ToolSpec } from \"../utils/testing/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\ninterface FakeModelState {\n  callIndex: number;\n  calls: FakeModelCall[];\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 * Responses are consumed in first-in-first-out order — one per `invoke()` call.\n * When all queued responses are consumed, further invocations throw.\n */\nexport class 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 _state: FakeModelState = { callIndex: 0, calls: [] };\n\n  /**\n   * All invocations recorded by this model, in order.\n   * Each entry contains the `messages` array and `options` that were\n   * passed to `invoke()`.\n   */\n  get calls(): FakeModelCall[] {\n    return this._state.calls;\n  }\n\n  /**\n   * The number of times this model has been invoked.\n   */\n  get callCount(): number {\n    return this._state.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  /**\n   * Enqueue a response that the model will return on its next invocation.\n   * @param entry A {@link BaseMessage} to return, an `Error` to throw, or\n   *   a factory `(messages) => BaseMessage | Error` for dynamic responses.\n   * @returns `this`, for chaining.\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  /**\n   * Enqueue an {@link AIMessage} that carries the given tool calls.\n   * Content is derived from the input messages at invocation time.\n   * @param toolCalls Array of tool calls. Each entry needs `name` and\n   *   `args`; `id` is optional and auto-generated when omitted.\n   * @returns `this`, for chaining.\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  /**\n   * Make every invocation throw the given error, regardless of the queue.\n   * @param error The error to throw.\n   * @returns `this`, for chaining.\n   */\n  alwaysThrow(error: Error): this {\n    this._alwaysThrowError = error;\n    return this;\n  }\n\n  /**\n   * Set the value that {@link withStructuredOutput} will resolve to.\n   * @param value The structured object to return.\n   * @returns `this`, for chaining.\n   */\n  structuredResponse(value: Record<string, any>): this {\n    this._structuredResponseValue = value;\n    return this;\n  }\n\n  /**\n   * Bind tools to the model. Returns a new model that shares the same\n   * response queue and call history.\n   * @param tools The tools to bind, as {@link StructuredTool} instances or\n   *   plain {@link ToolSpec} objects.\n   * @returns A new RunnableBinding with the tools bound.\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._state = this._state;\n\n    return next.withConfig({} as BaseChatModelCallOptions);\n  }\n\n  /**\n   * Returns a {@link Runnable} that produces the {@link structuredResponse}\n   * value. The schema argument is accepted for compatibility but ignored.\n   * @param _params Schema or params (ignored).\n   * @param _config Options (ignored).\n   * @returns A Runnable that resolves to the structured response value.\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._state.calls.push({ messages: [...messages], options });\n\n    const currentCallIndex = this._state.callIndex;\n    this._state.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 new {@link FakeBuiltModel} for testing.\n *\n * Returns a chainable builder — queue responses, then pass the model\n * anywhere a chat model is expected. Responses are consumed in FIFO\n * order, one per `invoke()` call.\n *\n * ## API summary\n *\n * | Method | Description |\n * | --- | --- |\n * | `fakeModel()` | Creates a new fake chat model. Returns a chainable builder. |\n * | `.respond(message)` | Queue an `AIMessage` (or any `BaseMessage`) to return on the next invocation. |\n * | `.respond(error)` | Queue an `Error` to throw on the next invocation. |\n * | `.respond(factory)` | Queue a function `(messages) => BaseMessage \\| Error` for dynamic responses. |\n * | `.respondWithTools(toolCalls)` | Shorthand for `.respond()` with tool calls. Each entry needs `name` and `args`; `id` is optional. |\n * | `.alwaysThrow(error)` | Make every invocation throw this error, regardless of the queue. |\n * | `.structuredResponse(value)` | Set the value returned by `.withStructuredOutput()`. |\n * | `.bindTools(tools)` | Bind tools to the model. Returns a `RunnableBinding` that shares the response queue and call recording. |\n * | `.withStructuredOutput(schema)` | Returns a runnable that produces the `.structuredResponse()` value. |\n * | `.calls` | Array of `{ messages, options }` for every invocation (read-only). |\n * | `.callCount` | Number of times the model has been invoked. |\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":"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"}
+{"version":3,"file":"fake_model_builder.cjs","names":["BaseChatModel","BaseMessage","RunnableLambda","AIMessage"],"sources":["../../src/testing/fake_model_builder.ts"],"sourcesContent":["/* oxlint-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 \"../utils/types/zod.js\";\nimport type { ToolSpec } from \"../utils/testing/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\ninterface FakeModelState {\n  callIndex: number;\n  calls: FakeModelCall[];\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 * Responses are consumed in first-in-first-out order — one per `invoke()` call.\n * When all queued responses are consumed, further invocations throw.\n */\nexport class 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 _state: FakeModelState = { callIndex: 0, calls: [] };\n\n  /**\n   * All invocations recorded by this model, in order.\n   * Each entry contains the `messages` array and `options` that were\n   * passed to `invoke()`.\n   */\n  get calls(): FakeModelCall[] {\n    return this._state.calls;\n  }\n\n  /**\n   * The number of times this model has been invoked.\n   */\n  get callCount(): number {\n    return this._state.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  /**\n   * Enqueue a response that the model will return on its next invocation.\n   * @param entry A {@link BaseMessage} to return, an `Error` to throw, or\n   *   a factory `(messages) => BaseMessage | Error` for dynamic responses.\n   * @returns `this`, for chaining.\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  /**\n   * Enqueue an {@link AIMessage} that carries the given tool calls.\n   * Content is derived from the input messages at invocation time.\n   * @param toolCalls Array of tool calls. Each entry needs `name` and\n   *   `args`; `id` is optional and auto-generated when omitted.\n   * @returns `this`, for chaining.\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  /**\n   * Make every invocation throw the given error, regardless of the queue.\n   * @param error The error to throw.\n   * @returns `this`, for chaining.\n   */\n  alwaysThrow(error: Error): this {\n    this._alwaysThrowError = error;\n    return this;\n  }\n\n  /**\n   * Set the value that {@link withStructuredOutput} will resolve to.\n   * @param value The structured object to return.\n   * @returns `this`, for chaining.\n   */\n  structuredResponse(value: Record<string, any>): this {\n    this._structuredResponseValue = value;\n    return this;\n  }\n\n  /**\n   * Bind tools to the model. Returns a new model that shares the same\n   * response queue and call history.\n   * @param tools The tools to bind, as {@link StructuredTool} instances or\n   *   plain {@link ToolSpec} objects.\n   * @returns A new RunnableBinding with the tools bound.\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._state = this._state;\n\n    return next.withConfig({} as BaseChatModelCallOptions);\n  }\n\n  /**\n   * Returns a {@link Runnable} that produces the {@link structuredResponse}\n   * value. The schema argument is accepted for compatibility but ignored.\n   * @param _params Schema or params (ignored).\n   * @param _config Options (ignored).\n   * @returns A Runnable that resolves to the structured response value.\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._state.calls.push({ messages: [...messages], options });\n\n    const currentCallIndex = this._state.callIndex;\n    this._state.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 new {@link FakeBuiltModel} for testing.\n *\n * Returns a chainable builder — queue responses, then pass the model\n * anywhere a chat model is expected. Responses are consumed in FIFO\n * order, one per `invoke()` call.\n *\n * ## API summary\n *\n * | Method | Description |\n * | --- | --- |\n * | `fakeModel()` | Creates a new fake chat model. Returns a chainable builder. |\n * | `.respond(message)` | Queue an `AIMessage` (or any `BaseMessage`) to return on the next invocation. |\n * | `.respond(error)` | Queue an `Error` to throw on the next invocation. |\n * | `.respond(factory)` | Queue a function `(messages) => BaseMessage \\| Error` for dynamic responses. |\n * | `.respondWithTools(toolCalls)` | Shorthand for `.respond()` with tool calls. Each entry needs `name` and `args`; `id` is optional. |\n * | `.alwaysThrow(error)` | Make every invocation throw this error, regardless of the queue. |\n * | `.structuredResponse(value)` | Set the value returned by `.withStructuredOutput()`. |\n * | `.bindTools(tools)` | Bind tools to the model. Returns a `RunnableBinding` that shares the response queue and call recording. |\n * | `.withStructuredOutput(schema)` | Returns a runnable that produces the `.structuredResponse()` value. |\n * | `.calls` | Array of `{ messages, options }` for every invocation (read-only). |\n * | `.callCount` | Number of times the model has been invoked. |\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":"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"}

package/dist/testing/fake_model_builder.js.map

@@ -1 +1 @@
-{"version":3,"file":"fake_model_builder.js","names":[],"sources":["../../src/testing/fake_model_builder.ts"],"sourcesContent":["/* oxlint-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 \"../utils/types/zod.js\";\nimport type { ToolSpec } from \"../utils/testing/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\ninterface FakeModelState {\n  callIndex: number;\n  calls: FakeModelCall[];\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 * Responses are consumed in first-in-first-out order — one per `invoke()` call.\n * When all queued responses are consumed, further invocations throw.\n */\nexport class 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 _state: FakeModelState = { callIndex: 0, calls: [] };\n\n  /**\n   * All invocations recorded by this model, in order.\n   * Each entry contains the `messages` array and `options` that were\n   * passed to `invoke()`.\n   */\n  get calls(): FakeModelCall[] {\n    return this._state.calls;\n  }\n\n  /**\n   * The number of times this model has been invoked.\n   */\n  get callCount(): number {\n    return this._state.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  /**\n   * Enqueue a response that the model will return on its next invocation.\n   * @param entry A {@link BaseMessage} to return, an `Error` to throw, or\n   *   a factory `(messages) => BaseMessage | Error` for dynamic responses.\n   * @returns `this`, for chaining.\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  /**\n   * Enqueue an {@link AIMessage} that carries the given tool calls.\n   * Content is derived from the input messages at invocation time.\n   * @param toolCalls Array of tool calls. Each entry needs `name` and\n   *   `args`; `id` is optional and auto-generated when omitted.\n   * @returns `this`, for chaining.\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  /**\n   * Make every invocation throw the given error, regardless of the queue.\n   * @param error The error to throw.\n   * @returns `this`, for chaining.\n   */\n  alwaysThrow(error: Error): this {\n    this._alwaysThrowError = error;\n    return this;\n  }\n\n  /**\n   * Set the value that {@link withStructuredOutput} will resolve to.\n   * @param value The structured object to return.\n   * @returns `this`, for chaining.\n   */\n  structuredResponse(value: Record<string, any>): this {\n    this._structuredResponseValue = value;\n    return this;\n  }\n\n  /**\n   * Bind tools to the model. Returns a new model that shares the same\n   * response queue and call history.\n   * @param tools The tools to bind, as {@link StructuredTool} instances or\n   *   plain {@link ToolSpec} objects.\n   * @returns A new RunnableBinding with the tools bound.\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._state = this._state;\n\n    return next.withConfig({} as BaseChatModelCallOptions);\n  }\n\n  /**\n   * Returns a {@link Runnable} that produces the {@link structuredResponse}\n   * value. The schema argument is accepted for compatibility but ignored.\n   * @param _params Schema or params (ignored).\n   * @param _config Options (ignored).\n   * @returns A Runnable that resolves to the structured response value.\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._state.calls.push({ messages: [...messages], options });\n\n    const currentCallIndex = this._state.callIndex;\n    this._state.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 new {@link FakeBuiltModel} for testing.\n *\n * Returns a chainable builder — queue responses, then pass the model\n * anywhere a chat model is expected. Responses are consumed in FIFO\n * order, one per `invoke()` call.\n *\n * ## API summary\n *\n * | Method | Description |\n * | --- | --- |\n * | `fakeModel()` | Creates a new fake chat model. Returns a chainable builder. |\n * | `.respond(message)` | Queue an `AIMessage` (or any `BaseMessage`) to return on the next invocation. |\n * | `.respond(error)` | Queue an `Error` to throw on the next invocation. |\n * | `.respond(factory)` | Queue a function `(messages) => BaseMessage \\| Error` for dynamic responses. |\n * | `.respondWithTools(toolCalls)` | Shorthand for `.respond()` with tool calls. Each entry needs `name` and `args`; `id` is optional. |\n * | `.alwaysThrow(error)` | Make every invocation throw this error, regardless of the queue. |\n * | `.structuredResponse(value)` | Set the value returned by `.withStructuredOutput()`. |\n * | `.bindTools(tools)` | Bind tools to the model. Returns a `RunnableBinding` that shares the response queue and call recording. |\n * | `.withStructuredOutput(schema)` | Returns a runnable that produces the `.structuredResponse()` value. |\n * | `.calls` | Array of `{ messages, options }` for every invocation (read-only). |\n * | `.callCount` | Number of times the model has been invoked. |\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":"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"}
+{"version":3,"file":"fake_model_builder.js","names":[],"sources":["../../src/testing/fake_model_builder.ts"],"sourcesContent":["/* oxlint-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 \"../utils/types/zod.js\";\nimport type { ToolSpec } from \"../utils/testing/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\ninterface FakeModelState {\n  callIndex: number;\n  calls: FakeModelCall[];\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 * Responses are consumed in first-in-first-out order — one per `invoke()` call.\n * When all queued responses are consumed, further invocations throw.\n */\nexport class 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 _state: FakeModelState = { callIndex: 0, calls: [] };\n\n  /**\n   * All invocations recorded by this model, in order.\n   * Each entry contains the `messages` array and `options` that were\n   * passed to `invoke()`.\n   */\n  get calls(): FakeModelCall[] {\n    return this._state.calls;\n  }\n\n  /**\n   * The number of times this model has been invoked.\n   */\n  get callCount(): number {\n    return this._state.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  /**\n   * Enqueue a response that the model will return on its next invocation.\n   * @param entry A {@link BaseMessage} to return, an `Error` to throw, or\n   *   a factory `(messages) => BaseMessage | Error` for dynamic responses.\n   * @returns `this`, for chaining.\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  /**\n   * Enqueue an {@link AIMessage} that carries the given tool calls.\n   * Content is derived from the input messages at invocation time.\n   * @param toolCalls Array of tool calls. Each entry needs `name` and\n   *   `args`; `id` is optional and auto-generated when omitted.\n   * @returns `this`, for chaining.\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  /**\n   * Make every invocation throw the given error, regardless of the queue.\n   * @param error The error to throw.\n   * @returns `this`, for chaining.\n   */\n  alwaysThrow(error: Error): this {\n    this._alwaysThrowError = error;\n    return this;\n  }\n\n  /**\n   * Set the value that {@link withStructuredOutput} will resolve to.\n   * @param value The structured object to return.\n   * @returns `this`, for chaining.\n   */\n  structuredResponse(value: Record<string, any>): this {\n    this._structuredResponseValue = value;\n    return this;\n  }\n\n  /**\n   * Bind tools to the model. Returns a new model that shares the same\n   * response queue and call history.\n   * @param tools The tools to bind, as {@link StructuredTool} instances or\n   *   plain {@link ToolSpec} objects.\n   * @returns A new RunnableBinding with the tools bound.\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._state = this._state;\n\n    return next.withConfig({} as BaseChatModelCallOptions);\n  }\n\n  /**\n   * Returns a {@link Runnable} that produces the {@link structuredResponse}\n   * value. The schema argument is accepted for compatibility but ignored.\n   * @param _params Schema or params (ignored).\n   * @param _config Options (ignored).\n   * @returns A Runnable that resolves to the structured response value.\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._state.calls.push({ messages: [...messages], options });\n\n    const currentCallIndex = this._state.callIndex;\n    this._state.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 new {@link FakeBuiltModel} for testing.\n *\n * Returns a chainable builder — queue responses, then pass the model\n * anywhere a chat model is expected. Responses are consumed in FIFO\n * order, one per `invoke()` call.\n *\n * ## API summary\n *\n * | Method | Description |\n * | --- | --- |\n * | `fakeModel()` | Creates a new fake chat model. Returns a chainable builder. |\n * | `.respond(message)` | Queue an `AIMessage` (or any `BaseMessage`) to return on the next invocation. |\n * | `.respond(error)` | Queue an `Error` to throw on the next invocation. |\n * | `.respond(factory)` | Queue a function `(messages) => BaseMessage \\| Error` for dynamic responses. |\n * | `.respondWithTools(toolCalls)` | Shorthand for `.respond()` with tool calls. Each entry needs `name` and `args`; `id` is optional. |\n * | `.alwaysThrow(error)` | Make every invocation throw this error, regardless of the queue. |\n * | `.structuredResponse(value)` | Set the value returned by `.withStructuredOutput()`. |\n * | `.bindTools(tools)` | Bind tools to the model. Returns a `RunnableBinding` that shares the response queue and call recording. |\n * | `.withStructuredOutput(schema)` | Returns a runnable that produces the `.structuredResponse()` value. |\n * | `.calls` | Array of `{ messages, options }` for every invocation (read-only). |\n * | `.callCount` | Number of times the model has been invoked. |\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":"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"}

package/dist/testing/matchers.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"matchers.cjs","names":["BaseMessage","HumanMessage","AIMessage","SystemMessage","ToolMessage"],"sources":["../../src/testing/matchers.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\nimport { BaseMessage } from \"../messages/index.js\";\nimport { HumanMessage } from \"../messages/index.js\";\nimport { AIMessage } from \"../messages/index.js\";\nimport { SystemMessage } from \"../messages/index.js\";\nimport { ToolMessage } from \"../messages/index.js\";\n\n/**\n * The `this` context that Vitest and Jest provide to custom matchers\n * via `expect.extend`.\n *\n * Compatible with both frameworks:\n * - https://vitest.dev/guide/extending-matchers.html\n * - https://jestjs.io/docs/expect#expectextendmatchers\n */\ninterface ExpectExtendThis {\n  isNot?: boolean;\n  equals(a: unknown, b: unknown): boolean;\n  utils: {\n    matcherHint(name: string, received?: string, expected?: string): string;\n    printReceived(value: unknown): string;\n    printExpected(value: unknown): string;\n  };\n}\n\ninterface ExpectationResult {\n  pass: boolean;\n  message: () => string;\n  actual?: unknown;\n  expected?: unknown;\n}\n\nfunction getMessageTypeName(msg: unknown): string {\n  if (!BaseMessage.isInstance(msg)) return typeof msg;\n  return msg.constructor.name || msg.type;\n}\n\nfunction makeMessageTypeMatcher(\n  typeName: string,\n  isInstance: (obj: unknown) => boolean\n) {\n  return function (\n    this: ExpectExtendThis,\n    received: unknown,\n    expected?: string | Record<string, unknown>\n  ): ExpectationResult {\n    const { isNot, utils } = this;\n\n    const instancePass = isInstance(received);\n    if (!instancePass) {\n      return {\n        pass: false,\n        message: () =>\n          `${utils.matcherHint(`toBe${typeName}`, undefined, undefined)}\\n\\n` +\n          `Expected: ${isNot ? \"not \" : \"\"}${typeName}\\n` +\n          `Received: ${getMessageTypeName(received)}`,\n        actual: getMessageTypeName(received),\n        expected: typeName,\n      };\n    }\n\n    if (expected === undefined) {\n      return {\n        pass: true,\n        message: () =>\n          `${utils.matcherHint(`toBe${typeName}`, undefined, undefined)}\\n\\n` +\n          `Expected: not ${typeName}\\n` +\n          `Received: ${typeName}`,\n      };\n    }\n\n    const msg = received as BaseMessage;\n    if (typeof expected === \"string\") {\n      const contentPass = msg.content === expected;\n      return {\n        pass: contentPass,\n        message: () =>\n          `${utils.matcherHint(`toBe${typeName}`, undefined, undefined)}\\n\\n` +\n          `Expected: ${typeName} with content ${utils.printExpected(expected)}\\n` +\n          `Received: ${typeName} with content ${utils.printReceived(msg.content)}`,\n        actual: msg.content,\n        expected,\n      };\n    }\n\n    const fieldsPass = Object.entries(expected).every(([key, value]) =>\n      this.equals((msg as any)[key], value)\n    );\n    return {\n      pass: fieldsPass,\n      message: () => {\n        const receivedFields: Record<string, unknown> = {};\n        for (const key of Object.keys(expected)) {\n          receivedFields[key] = (msg as any)[key];\n        }\n        return (\n          `${utils.matcherHint(`toBe${typeName}`, undefined, undefined)}\\n\\n` +\n          `Expected: ${typeName} matching ${utils.printExpected(expected)}\\n` +\n          `Received: ${typeName} with ${utils.printReceived(receivedFields)}`\n        );\n      },\n      actual: (() => {\n        const receivedFields: Record<string, unknown> = {};\n        for (const key of Object.keys(expected)) {\n          receivedFields[key] = (msg as any)[key];\n        }\n        return receivedFields;\n      })(),\n      expected,\n    };\n  };\n}\n\nexport const toBeHumanMessage = makeMessageTypeMatcher(\n  \"HumanMessage\",\n  HumanMessage.isInstance\n);\n\nexport const toBeAIMessage = makeMessageTypeMatcher(\n  \"AIMessage\",\n  AIMessage.isInstance\n);\n\nexport const toBeSystemMessage = makeMessageTypeMatcher(\n  \"SystemMessage\",\n  SystemMessage.isInstance\n);\n\nexport const toBeToolMessage = makeMessageTypeMatcher(\n  \"ToolMessage\",\n  ToolMessage.isInstance\n);\n\nexport function toHaveToolCalls(\n  this: ExpectExtendThis,\n  received: unknown,\n  expected: Array<Record<string, unknown>>\n): ExpectationResult {\n  const { isNot, utils } = this;\n\n  if (!AIMessage.isInstance(received)) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveToolCalls\")}\\n\\n` +\n        `Expected: AIMessage\\n` +\n        `Received: ${getMessageTypeName(received)}`,\n    };\n  }\n\n  const actual = received.tool_calls ?? [];\n\n  if (actual.length !== expected.length) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveToolCalls\")}\\n\\n` +\n        `Expected ${isNot ? \"not \" : \"\"}${expected.length} tool call(s), received ${actual.length}`,\n      actual: actual.length,\n      expected: expected.length,\n    };\n  }\n\n  const unmatched = expected.filter(\n    (exp) =>\n      !actual.some((tc) =>\n        Object.entries(exp).every(([key, value]) =>\n          this.equals((tc as any)[key], value)\n        )\n      )\n  );\n\n  if (unmatched.length > 0) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveToolCalls\")}\\n\\n` +\n        `Could not find matching tool call(s) for:\\n` +\n        `${utils.printExpected(unmatched)}\\n` +\n        `Received tool calls: ${utils.printReceived(actual.map((tc) => ({ name: tc.name, id: tc.id, args: tc.args })))}`,\n      actual: actual.map((tc) => ({ name: tc.name, id: tc.id, args: tc.args })),\n      expected,\n    };\n  }\n\n  return {\n    pass: true,\n    message: () =>\n      `${utils.matcherHint(\"toHaveToolCalls\")}\\n\\n` +\n      `Expected AIMessage not to have matching tool calls`,\n  };\n}\n\nexport function toHaveToolCallCount(\n  this: ExpectExtendThis,\n  received: unknown,\n  expected: number\n): ExpectationResult {\n  const { isNot, utils } = this;\n\n  if (!AIMessage.isInstance(received)) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveToolCallCount\")}\\n\\n` +\n        `Expected: AIMessage\\n` +\n        `Received: ${getMessageTypeName(received)}`,\n    };\n  }\n\n  const actual = received.tool_calls?.length ?? 0;\n  const pass = actual === expected;\n\n  return {\n    pass,\n    message: () =>\n      `${utils.matcherHint(\"toHaveToolCallCount\")}\\n\\n` +\n      `Expected ${isNot ? \"not \" : \"\"}${expected} tool call(s)\\n` +\n      `Received: ${actual}`,\n    actual,\n    expected,\n  };\n}\n\nexport function toContainToolCall(\n  this: ExpectExtendThis,\n  received: unknown,\n  expected: Record<string, unknown>\n): ExpectationResult {\n  const { isNot, utils } = this;\n\n  if (!AIMessage.isInstance(received)) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toContainToolCall\")}\\n\\n` +\n        `Expected: AIMessage\\n` +\n        `Received: ${getMessageTypeName(received)}`,\n    };\n  }\n\n  const actual = received.tool_calls ?? [];\n  const found = actual.some((tc) =>\n    Object.entries(expected).every(([key, value]) =>\n      this.equals((tc as any)[key], value)\n    )\n  );\n\n  return {\n    pass: found,\n    message: () =>\n      `${utils.matcherHint(\"toContainToolCall\")}\\n\\n` +\n      `Expected AIMessage ${isNot ? \"not \" : \"\"}to contain a tool call matching ${utils.printExpected(expected)}\\n` +\n      `Received tool calls: ${utils.printReceived(actual.map((tc) => ({ name: tc.name, id: tc.id })))}`,\n    actual: actual.map((tc) => ({ name: tc.name, id: tc.id })),\n    expected,\n  };\n}\n\nexport function toHaveToolMessages(\n  this: ExpectExtendThis,\n  received: unknown,\n  expected: Array<Record<string, unknown>>\n): ExpectationResult {\n  const { isNot, utils } = this;\n\n  if (!Array.isArray(received)) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveToolMessages\")}\\n\\n` +\n        `Expected an array of messages\\n` +\n        `Received: ${typeof received}`,\n    };\n  }\n\n  const toolMessages = (received as BaseMessage[]).filter(\n    ToolMessage.isInstance\n  );\n\n  if (toolMessages.length !== expected.length) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveToolMessages\")}\\n\\n` +\n        `Expected ${isNot ? \"not \" : \"\"}${expected.length} tool message(s), found ${toolMessages.length}`,\n      actual: toolMessages.length,\n      expected: expected.length,\n    };\n  }\n\n  for (let i = 0; i < expected.length; i++) {\n    const match = Object.entries(expected[i]).every(([key, value]) =>\n      this.equals((toolMessages[i] as any)[key], value)\n    );\n    if (!match) {\n      return {\n        pass: false,\n        message: () => {\n          const receivedFields: Record<string, unknown> = {};\n          for (const key of Object.keys(expected[i])) {\n            receivedFields[key] = (toolMessages[i] as any)[key];\n          }\n          return (\n            `${utils.matcherHint(\"toHaveToolMessages\")}\\n\\n` +\n            `Tool message at index ${i} did not match:\\n` +\n            `Expected: ${utils.printExpected(expected[i])}\\n` +\n            `Received: ${utils.printReceived(receivedFields)}`\n          );\n        },\n        actual: toolMessages[i],\n        expected: expected[i],\n      };\n    }\n  }\n\n  return {\n    pass: true,\n    message: () =>\n      `${utils.matcherHint(\"toHaveToolMessages\")}\\n\\n` +\n      `Expected messages not to contain matching tool messages`,\n  };\n}\n\nexport function toHaveBeenInterrupted(\n  this: ExpectExtendThis,\n  received: unknown,\n  expectedValue?: unknown\n): ExpectationResult {\n  const { isNot, utils } = this;\n\n  const result = received as Record<string, any>;\n  const interrupts = result?.__interrupt__;\n  const hasInterrupt = Array.isArray(interrupts) && interrupts.length > 0;\n\n  if (!hasInterrupt) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveBeenInterrupted\")}\\n\\n` +\n        `Expected result ${isNot ? \"not \" : \"\"}to have been interrupted\\n` +\n        `Received __interrupt__: ${utils.printReceived(interrupts)}`,\n    };\n  }\n\n  if (expectedValue === undefined) {\n    return {\n      pass: true,\n      message: () =>\n        `${utils.matcherHint(\"toHaveBeenInterrupted\")}\\n\\n` +\n        `Expected result not to have been interrupted\\n` +\n        `Received ${interrupts.length} interrupt(s)`,\n    };\n  }\n\n  const actualValue = interrupts[0]?.value;\n  const valuePass = this.equals(actualValue, expectedValue);\n\n  return {\n    pass: valuePass,\n    message: () =>\n      `${utils.matcherHint(\"toHaveBeenInterrupted\")}\\n\\n` +\n      `Expected interrupt value: ${utils.printExpected(expectedValue)}\\n` +\n      `Received interrupt value: ${utils.printReceived(actualValue)}`,\n    actual: actualValue,\n    expected: expectedValue,\n  };\n}\n\nexport function toHaveStructuredResponse(\n  this: ExpectExtendThis,\n  received: unknown,\n  expected?: Record<string, unknown>\n): ExpectationResult {\n  const { isNot, utils } = this;\n\n  const result = received as Record<string, any>;\n  const structuredResponse = result?.structuredResponse;\n  const isDefined = structuredResponse !== undefined;\n\n  if (!isDefined) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveStructuredResponse\")}\\n\\n` +\n        `Expected result ${isNot ? \"not \" : \"\"}to have a structured response\\n` +\n        `Received structuredResponse: undefined`,\n    };\n  }\n\n  if (expected === undefined) {\n    return {\n      pass: true,\n      message: () =>\n        `${utils.matcherHint(\"toHaveStructuredResponse\")}\\n\\n` +\n        `Expected result not to have a structured response`,\n    };\n  }\n\n  const fieldsPass = Object.entries(expected).every(([key, value]) =>\n    this.equals(structuredResponse[key], value)\n  );\n\n  return {\n    pass: fieldsPass,\n    message: () =>\n      `${utils.matcherHint(\"toHaveStructuredResponse\")}\\n\\n` +\n      `Expected structured response: ${utils.printExpected(expected)}\\n` +\n      `Received structured response: ${utils.printReceived(structuredResponse)}`,\n    actual: structuredResponse,\n    expected,\n  };\n}\n\n/**\n * All matcher functions bundled for convenient use with `expect.extend()`.\n */\nexport const langchainMatchers = {\n  toBeHumanMessage,\n  toBeAIMessage,\n  toBeSystemMessage,\n  toBeToolMessage,\n  toHaveToolCalls,\n  toHaveToolCallCount,\n  toContainToolCall,\n  toHaveToolMessages,\n  toHaveBeenInterrupted,\n  toHaveStructuredResponse,\n};\n\nexport interface LangChainMatchers<R = unknown> {\n  toBeHumanMessage(expected?: string | { content?: string; id?: string }): R;\n  toBeAIMessage(expected?: string | { content?: string; name?: string }): R;\n  toBeSystemMessage(\n    expected?: string | { content?: string; additional_kwargs?: object }\n  ): R;\n  toBeToolMessage(\n    expected?:\n      | string\n      | {\n          content?: string;\n          name?: string;\n          status?: string;\n          tool_call_id?: string;\n        }\n  ): R;\n  toHaveToolCalls(\n    expected: Array<{\n      name?: string;\n      id?: string;\n      args?: Record<string, unknown>;\n    }>\n  ): R;\n  toHaveToolCallCount(expected: number): R;\n  toContainToolCall(expected: {\n    name?: string;\n    id?: string;\n    args?: Record<string, unknown>;\n  }): R;\n  toHaveToolMessages(\n    expected: Array<{\n      content?: string;\n      name?: string;\n      status?: string;\n      tool_call_id?: string;\n    }>\n  ): R;\n  toHaveBeenInterrupted(expectedValue?: unknown): R;\n  toHaveStructuredResponse(expected?: Record<string, unknown>): R;\n}\n\ndeclare module \"vitest\" {\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  interface Matchers<T = any> extends LangChainMatchers<T> {}\n}\n"],"mappings":"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"}
+{"version":3,"file":"matchers.cjs","names":["BaseMessage","HumanMessage","AIMessage","SystemMessage","ToolMessage","result"],"sources":["../../src/testing/matchers.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\nimport { BaseMessage } from \"../messages/index.js\";\nimport { HumanMessage } from \"../messages/index.js\";\nimport { AIMessage } from \"../messages/index.js\";\nimport { SystemMessage } from \"../messages/index.js\";\nimport { ToolMessage } from \"../messages/index.js\";\n\n/**\n * The `this` context that Vitest and Jest provide to custom matchers\n * via `expect.extend`.\n *\n * Compatible with both frameworks:\n * - https://vitest.dev/guide/extending-matchers.html\n * - https://jestjs.io/docs/expect#expectextendmatchers\n */\ninterface ExpectExtendThis {\n  isNot?: boolean;\n  equals(a: unknown, b: unknown): boolean;\n  utils: {\n    matcherHint(name: string, received?: string, expected?: string): string;\n    printReceived(value: unknown): string;\n    printExpected(value: unknown): string;\n  };\n}\n\ninterface ExpectationResult {\n  pass: boolean;\n  message: () => string;\n  actual?: unknown;\n  expected?: unknown;\n}\n\nfunction getMessageTypeName(msg: unknown): string {\n  if (!BaseMessage.isInstance(msg)) return typeof msg;\n  return msg.constructor.name || msg.type;\n}\n\nfunction makeMessageTypeMatcher(\n  typeName: string,\n  isInstance: (obj: unknown) => boolean\n) {\n  return function (\n    this: ExpectExtendThis,\n    received: unknown,\n    expected?: string | Record<string, unknown>\n  ): ExpectationResult {\n    const { isNot, utils } = this;\n\n    const instancePass = isInstance(received);\n    if (!instancePass) {\n      return {\n        pass: false,\n        message: () =>\n          `${utils.matcherHint(`toBe${typeName}`, undefined, undefined)}\\n\\n` +\n          `Expected: ${isNot ? \"not \" : \"\"}${typeName}\\n` +\n          `Received: ${getMessageTypeName(received)}`,\n        actual: getMessageTypeName(received),\n        expected: typeName,\n      };\n    }\n\n    if (expected === undefined) {\n      return {\n        pass: true,\n        message: () =>\n          `${utils.matcherHint(`toBe${typeName}`, undefined, undefined)}\\n\\n` +\n          `Expected: not ${typeName}\\n` +\n          `Received: ${typeName}`,\n      };\n    }\n\n    const msg = received as BaseMessage;\n    if (typeof expected === \"string\") {\n      const contentPass = msg.content === expected;\n      return {\n        pass: contentPass,\n        message: () =>\n          `${utils.matcherHint(`toBe${typeName}`, undefined, undefined)}\\n\\n` +\n          `Expected: ${typeName} with content ${utils.printExpected(expected)}\\n` +\n          `Received: ${typeName} with content ${utils.printReceived(msg.content)}`,\n        actual: msg.content,\n        expected,\n      };\n    }\n\n    const fieldsPass = Object.entries(expected).every(([key, value]) =>\n      this.equals((msg as any)[key], value)\n    );\n    return {\n      pass: fieldsPass,\n      message: () => {\n        const receivedFields: Record<string, unknown> = {};\n        for (const key of Object.keys(expected)) {\n          receivedFields[key] = (msg as any)[key];\n        }\n        return (\n          `${utils.matcherHint(`toBe${typeName}`, undefined, undefined)}\\n\\n` +\n          `Expected: ${typeName} matching ${utils.printExpected(expected)}\\n` +\n          `Received: ${typeName} with ${utils.printReceived(receivedFields)}`\n        );\n      },\n      actual: (() => {\n        const receivedFields: Record<string, unknown> = {};\n        for (const key of Object.keys(expected)) {\n          receivedFields[key] = (msg as any)[key];\n        }\n        return receivedFields;\n      })(),\n      expected,\n    };\n  };\n}\n\nexport const toBeHumanMessage = makeMessageTypeMatcher(\n  \"HumanMessage\",\n  HumanMessage.isInstance\n);\n\nexport const toBeAIMessage = makeMessageTypeMatcher(\n  \"AIMessage\",\n  AIMessage.isInstance\n);\n\nexport const toBeSystemMessage = makeMessageTypeMatcher(\n  \"SystemMessage\",\n  SystemMessage.isInstance\n);\n\nexport const toBeToolMessage = makeMessageTypeMatcher(\n  \"ToolMessage\",\n  ToolMessage.isInstance\n);\n\nexport function toHaveToolCalls(\n  this: ExpectExtendThis,\n  received: unknown,\n  expected: Array<Record<string, unknown>>\n): ExpectationResult {\n  const { isNot, utils } = this;\n\n  if (!AIMessage.isInstance(received)) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveToolCalls\")}\\n\\n` +\n        `Expected: AIMessage\\n` +\n        `Received: ${getMessageTypeName(received)}`,\n    };\n  }\n\n  const actual = received.tool_calls ?? [];\n\n  if (actual.length !== expected.length) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveToolCalls\")}\\n\\n` +\n        `Expected ${isNot ? \"not \" : \"\"}${expected.length} tool call(s), received ${actual.length}`,\n      actual: actual.length,\n      expected: expected.length,\n    };\n  }\n\n  const unmatched = expected.filter(\n    (exp) =>\n      !actual.some((tc) =>\n        Object.entries(exp).every(([key, value]) =>\n          this.equals((tc as any)[key], value)\n        )\n      )\n  );\n\n  if (unmatched.length > 0) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveToolCalls\")}\\n\\n` +\n        `Could not find matching tool call(s) for:\\n` +\n        `${utils.printExpected(unmatched)}\\n` +\n        `Received tool calls: ${utils.printReceived(actual.map((tc) => ({ name: tc.name, id: tc.id, args: tc.args })))}`,\n      actual: actual.map((tc) => ({ name: tc.name, id: tc.id, args: tc.args })),\n      expected,\n    };\n  }\n\n  return {\n    pass: true,\n    message: () =>\n      `${utils.matcherHint(\"toHaveToolCalls\")}\\n\\n` +\n      `Expected AIMessage not to have matching tool calls`,\n  };\n}\n\nexport function toHaveToolCallCount(\n  this: ExpectExtendThis,\n  received: unknown,\n  expected: number\n): ExpectationResult {\n  const { isNot, utils } = this;\n\n  if (!AIMessage.isInstance(received)) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveToolCallCount\")}\\n\\n` +\n        `Expected: AIMessage\\n` +\n        `Received: ${getMessageTypeName(received)}`,\n    };\n  }\n\n  const actual = received.tool_calls?.length ?? 0;\n  const pass = actual === expected;\n\n  return {\n    pass,\n    message: () =>\n      `${utils.matcherHint(\"toHaveToolCallCount\")}\\n\\n` +\n      `Expected ${isNot ? \"not \" : \"\"}${expected} tool call(s)\\n` +\n      `Received: ${actual}`,\n    actual,\n    expected,\n  };\n}\n\nexport function toContainToolCall(\n  this: ExpectExtendThis,\n  received: unknown,\n  expected: Record<string, unknown>\n): ExpectationResult {\n  const { isNot, utils } = this;\n\n  if (!AIMessage.isInstance(received)) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toContainToolCall\")}\\n\\n` +\n        `Expected: AIMessage\\n` +\n        `Received: ${getMessageTypeName(received)}`,\n    };\n  }\n\n  const actual = received.tool_calls ?? [];\n  const found = actual.some((tc) =>\n    Object.entries(expected).every(([key, value]) =>\n      this.equals((tc as any)[key], value)\n    )\n  );\n\n  return {\n    pass: found,\n    message: () =>\n      `${utils.matcherHint(\"toContainToolCall\")}\\n\\n` +\n      `Expected AIMessage ${isNot ? \"not \" : \"\"}to contain a tool call matching ${utils.printExpected(expected)}\\n` +\n      `Received tool calls: ${utils.printReceived(actual.map((tc) => ({ name: tc.name, id: tc.id })))}`,\n    actual: actual.map((tc) => ({ name: tc.name, id: tc.id })),\n    expected,\n  };\n}\n\nexport function toHaveToolMessages(\n  this: ExpectExtendThis,\n  received: unknown,\n  expected: Array<Record<string, unknown>>\n): ExpectationResult {\n  const { isNot, utils } = this;\n\n  if (!Array.isArray(received)) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveToolMessages\")}\\n\\n` +\n        `Expected an array of messages\\n` +\n        `Received: ${typeof received}`,\n    };\n  }\n\n  const toolMessages = (received as BaseMessage[]).filter(\n    ToolMessage.isInstance\n  );\n\n  if (toolMessages.length !== expected.length) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveToolMessages\")}\\n\\n` +\n        `Expected ${isNot ? \"not \" : \"\"}${expected.length} tool message(s), found ${toolMessages.length}`,\n      actual: toolMessages.length,\n      expected: expected.length,\n    };\n  }\n\n  for (let i = 0; i < expected.length; i++) {\n    const match = Object.entries(expected[i]).every(([key, value]) =>\n      this.equals((toolMessages[i] as any)[key], value)\n    );\n    if (!match) {\n      return {\n        pass: false,\n        message: () => {\n          const receivedFields: Record<string, unknown> = {};\n          for (const key of Object.keys(expected[i])) {\n            receivedFields[key] = (toolMessages[i] as any)[key];\n          }\n          return (\n            `${utils.matcherHint(\"toHaveToolMessages\")}\\n\\n` +\n            `Tool message at index ${i} did not match:\\n` +\n            `Expected: ${utils.printExpected(expected[i])}\\n` +\n            `Received: ${utils.printReceived(receivedFields)}`\n          );\n        },\n        actual: toolMessages[i],\n        expected: expected[i],\n      };\n    }\n  }\n\n  return {\n    pass: true,\n    message: () =>\n      `${utils.matcherHint(\"toHaveToolMessages\")}\\n\\n` +\n      `Expected messages not to contain matching tool messages`,\n  };\n}\n\nexport function toHaveBeenInterrupted(\n  this: ExpectExtendThis,\n  received: unknown,\n  expectedValue?: unknown\n): ExpectationResult {\n  const { isNot, utils } = this;\n\n  const result = received as Record<string, any>;\n  const interrupts = result?.__interrupt__;\n  const hasInterrupt = Array.isArray(interrupts) && interrupts.length > 0;\n\n  if (!hasInterrupt) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveBeenInterrupted\")}\\n\\n` +\n        `Expected result ${isNot ? \"not \" : \"\"}to have been interrupted\\n` +\n        `Received __interrupt__: ${utils.printReceived(interrupts)}`,\n    };\n  }\n\n  if (expectedValue === undefined) {\n    return {\n      pass: true,\n      message: () =>\n        `${utils.matcherHint(\"toHaveBeenInterrupted\")}\\n\\n` +\n        `Expected result not to have been interrupted\\n` +\n        `Received ${interrupts.length} interrupt(s)`,\n    };\n  }\n\n  const actualValue = interrupts[0]?.value;\n  const valuePass = this.equals(actualValue, expectedValue);\n\n  return {\n    pass: valuePass,\n    message: () =>\n      `${utils.matcherHint(\"toHaveBeenInterrupted\")}\\n\\n` +\n      `Expected interrupt value: ${utils.printExpected(expectedValue)}\\n` +\n      `Received interrupt value: ${utils.printReceived(actualValue)}`,\n    actual: actualValue,\n    expected: expectedValue,\n  };\n}\n\nexport function toHaveStructuredResponse(\n  this: ExpectExtendThis,\n  received: unknown,\n  expected?: Record<string, unknown>\n): ExpectationResult {\n  const { isNot, utils } = this;\n\n  const result = received as Record<string, any>;\n  const structuredResponse = result?.structuredResponse;\n  const isDefined = structuredResponse !== undefined;\n\n  if (!isDefined) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveStructuredResponse\")}\\n\\n` +\n        `Expected result ${isNot ? \"not \" : \"\"}to have a structured response\\n` +\n        `Received structuredResponse: undefined`,\n    };\n  }\n\n  if (expected === undefined) {\n    return {\n      pass: true,\n      message: () =>\n        `${utils.matcherHint(\"toHaveStructuredResponse\")}\\n\\n` +\n        `Expected result not to have a structured response`,\n    };\n  }\n\n  const fieldsPass = Object.entries(expected).every(([key, value]) =>\n    this.equals(structuredResponse[key], value)\n  );\n\n  return {\n    pass: fieldsPass,\n    message: () =>\n      `${utils.matcherHint(\"toHaveStructuredResponse\")}\\n\\n` +\n      `Expected structured response: ${utils.printExpected(expected)}\\n` +\n      `Received structured response: ${utils.printReceived(structuredResponse)}`,\n    actual: structuredResponse,\n    expected,\n  };\n}\n\n/**\n * All matcher functions bundled for convenient use with `expect.extend()`.\n */\nexport const langchainMatchers = {\n  toBeHumanMessage,\n  toBeAIMessage,\n  toBeSystemMessage,\n  toBeToolMessage,\n  toHaveToolCalls,\n  toHaveToolCallCount,\n  toContainToolCall,\n  toHaveToolMessages,\n  toHaveBeenInterrupted,\n  toHaveStructuredResponse,\n};\n\nexport interface LangChainMatchers<R = unknown> {\n  toBeHumanMessage(expected?: string | { content?: string; id?: string }): R;\n  toBeAIMessage(expected?: string | { content?: string; name?: string }): R;\n  toBeSystemMessage(\n    expected?: string | { content?: string; additional_kwargs?: object }\n  ): R;\n  toBeToolMessage(\n    expected?:\n      | string\n      | {\n          content?: string;\n          name?: string;\n          status?: string;\n          tool_call_id?: string;\n        }\n  ): R;\n  toHaveToolCalls(\n    expected: Array<{\n      name?: string;\n      id?: string;\n      args?: Record<string, unknown>;\n    }>\n  ): R;\n  toHaveToolCallCount(expected: number): R;\n  toContainToolCall(expected: {\n    name?: string;\n    id?: string;\n    args?: Record<string, unknown>;\n  }): R;\n  toHaveToolMessages(\n    expected: Array<{\n      content?: string;\n      name?: string;\n      status?: string;\n      tool_call_id?: string;\n    }>\n  ): R;\n  toHaveBeenInterrupted(expectedValue?: unknown): R;\n  toHaveStructuredResponse(expected?: Record<string, unknown>): R;\n}\n\ndeclare module \"vitest\" {\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  interface Matchers<T = any> extends LangChainMatchers<T> {}\n}\n"],"mappings":"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"}

package/dist/testing/matchers.js.map

@@ -1 +1 @@
-{"version":3,"file":"matchers.js","names":[],"sources":["../../src/testing/matchers.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\nimport { BaseMessage } from \"../messages/index.js\";\nimport { HumanMessage } from \"../messages/index.js\";\nimport { AIMessage } from \"../messages/index.js\";\nimport { SystemMessage } from \"../messages/index.js\";\nimport { ToolMessage } from \"../messages/index.js\";\n\n/**\n * The `this` context that Vitest and Jest provide to custom matchers\n * via `expect.extend`.\n *\n * Compatible with both frameworks:\n * - https://vitest.dev/guide/extending-matchers.html\n * - https://jestjs.io/docs/expect#expectextendmatchers\n */\ninterface ExpectExtendThis {\n  isNot?: boolean;\n  equals(a: unknown, b: unknown): boolean;\n  utils: {\n    matcherHint(name: string, received?: string, expected?: string): string;\n    printReceived(value: unknown): string;\n    printExpected(value: unknown): string;\n  };\n}\n\ninterface ExpectationResult {\n  pass: boolean;\n  message: () => string;\n  actual?: unknown;\n  expected?: unknown;\n}\n\nfunction getMessageTypeName(msg: unknown): string {\n  if (!BaseMessage.isInstance(msg)) return typeof msg;\n  return msg.constructor.name || msg.type;\n}\n\nfunction makeMessageTypeMatcher(\n  typeName: string,\n  isInstance: (obj: unknown) => boolean\n) {\n  return function (\n    this: ExpectExtendThis,\n    received: unknown,\n    expected?: string | Record<string, unknown>\n  ): ExpectationResult {\n    const { isNot, utils } = this;\n\n    const instancePass = isInstance(received);\n    if (!instancePass) {\n      return {\n        pass: false,\n        message: () =>\n          `${utils.matcherHint(`toBe${typeName}`, undefined, undefined)}\\n\\n` +\n          `Expected: ${isNot ? \"not \" : \"\"}${typeName}\\n` +\n          `Received: ${getMessageTypeName(received)}`,\n        actual: getMessageTypeName(received),\n        expected: typeName,\n      };\n    }\n\n    if (expected === undefined) {\n      return {\n        pass: true,\n        message: () =>\n          `${utils.matcherHint(`toBe${typeName}`, undefined, undefined)}\\n\\n` +\n          `Expected: not ${typeName}\\n` +\n          `Received: ${typeName}`,\n      };\n    }\n\n    const msg = received as BaseMessage;\n    if (typeof expected === \"string\") {\n      const contentPass = msg.content === expected;\n      return {\n        pass: contentPass,\n        message: () =>\n          `${utils.matcherHint(`toBe${typeName}`, undefined, undefined)}\\n\\n` +\n          `Expected: ${typeName} with content ${utils.printExpected(expected)}\\n` +\n          `Received: ${typeName} with content ${utils.printReceived(msg.content)}`,\n        actual: msg.content,\n        expected,\n      };\n    }\n\n    const fieldsPass = Object.entries(expected).every(([key, value]) =>\n      this.equals((msg as any)[key], value)\n    );\n    return {\n      pass: fieldsPass,\n      message: () => {\n        const receivedFields: Record<string, unknown> = {};\n        for (const key of Object.keys(expected)) {\n          receivedFields[key] = (msg as any)[key];\n        }\n        return (\n          `${utils.matcherHint(`toBe${typeName}`, undefined, undefined)}\\n\\n` +\n          `Expected: ${typeName} matching ${utils.printExpected(expected)}\\n` +\n          `Received: ${typeName} with ${utils.printReceived(receivedFields)}`\n        );\n      },\n      actual: (() => {\n        const receivedFields: Record<string, unknown> = {};\n        for (const key of Object.keys(expected)) {\n          receivedFields[key] = (msg as any)[key];\n        }\n        return receivedFields;\n      })(),\n      expected,\n    };\n  };\n}\n\nexport const toBeHumanMessage = makeMessageTypeMatcher(\n  \"HumanMessage\",\n  HumanMessage.isInstance\n);\n\nexport const toBeAIMessage = makeMessageTypeMatcher(\n  \"AIMessage\",\n  AIMessage.isInstance\n);\n\nexport const toBeSystemMessage = makeMessageTypeMatcher(\n  \"SystemMessage\",\n  SystemMessage.isInstance\n);\n\nexport const toBeToolMessage = makeMessageTypeMatcher(\n  \"ToolMessage\",\n  ToolMessage.isInstance\n);\n\nexport function toHaveToolCalls(\n  this: ExpectExtendThis,\n  received: unknown,\n  expected: Array<Record<string, unknown>>\n): ExpectationResult {\n  const { isNot, utils } = this;\n\n  if (!AIMessage.isInstance(received)) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveToolCalls\")}\\n\\n` +\n        `Expected: AIMessage\\n` +\n        `Received: ${getMessageTypeName(received)}`,\n    };\n  }\n\n  const actual = received.tool_calls ?? [];\n\n  if (actual.length !== expected.length) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveToolCalls\")}\\n\\n` +\n        `Expected ${isNot ? \"not \" : \"\"}${expected.length} tool call(s), received ${actual.length}`,\n      actual: actual.length,\n      expected: expected.length,\n    };\n  }\n\n  const unmatched = expected.filter(\n    (exp) =>\n      !actual.some((tc) =>\n        Object.entries(exp).every(([key, value]) =>\n          this.equals((tc as any)[key], value)\n        )\n      )\n  );\n\n  if (unmatched.length > 0) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveToolCalls\")}\\n\\n` +\n        `Could not find matching tool call(s) for:\\n` +\n        `${utils.printExpected(unmatched)}\\n` +\n        `Received tool calls: ${utils.printReceived(actual.map((tc) => ({ name: tc.name, id: tc.id, args: tc.args })))}`,\n      actual: actual.map((tc) => ({ name: tc.name, id: tc.id, args: tc.args })),\n      expected,\n    };\n  }\n\n  return {\n    pass: true,\n    message: () =>\n      `${utils.matcherHint(\"toHaveToolCalls\")}\\n\\n` +\n      `Expected AIMessage not to have matching tool calls`,\n  };\n}\n\nexport function toHaveToolCallCount(\n  this: ExpectExtendThis,\n  received: unknown,\n  expected: number\n): ExpectationResult {\n  const { isNot, utils } = this;\n\n  if (!AIMessage.isInstance(received)) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveToolCallCount\")}\\n\\n` +\n        `Expected: AIMessage\\n` +\n        `Received: ${getMessageTypeName(received)}`,\n    };\n  }\n\n  const actual = received.tool_calls?.length ?? 0;\n  const pass = actual === expected;\n\n  return {\n    pass,\n    message: () =>\n      `${utils.matcherHint(\"toHaveToolCallCount\")}\\n\\n` +\n      `Expected ${isNot ? \"not \" : \"\"}${expected} tool call(s)\\n` +\n      `Received: ${actual}`,\n    actual,\n    expected,\n  };\n}\n\nexport function toContainToolCall(\n  this: ExpectExtendThis,\n  received: unknown,\n  expected: Record<string, unknown>\n): ExpectationResult {\n  const { isNot, utils } = this;\n\n  if (!AIMessage.isInstance(received)) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toContainToolCall\")}\\n\\n` +\n        `Expected: AIMessage\\n` +\n        `Received: ${getMessageTypeName(received)}`,\n    };\n  }\n\n  const actual = received.tool_calls ?? [];\n  const found = actual.some((tc) =>\n    Object.entries(expected).every(([key, value]) =>\n      this.equals((tc as any)[key], value)\n    )\n  );\n\n  return {\n    pass: found,\n    message: () =>\n      `${utils.matcherHint(\"toContainToolCall\")}\\n\\n` +\n      `Expected AIMessage ${isNot ? \"not \" : \"\"}to contain a tool call matching ${utils.printExpected(expected)}\\n` +\n      `Received tool calls: ${utils.printReceived(actual.map((tc) => ({ name: tc.name, id: tc.id })))}`,\n    actual: actual.map((tc) => ({ name: tc.name, id: tc.id })),\n    expected,\n  };\n}\n\nexport function toHaveToolMessages(\n  this: ExpectExtendThis,\n  received: unknown,\n  expected: Array<Record<string, unknown>>\n): ExpectationResult {\n  const { isNot, utils } = this;\n\n  if (!Array.isArray(received)) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveToolMessages\")}\\n\\n` +\n        `Expected an array of messages\\n` +\n        `Received: ${typeof received}`,\n    };\n  }\n\n  const toolMessages = (received as BaseMessage[]).filter(\n    ToolMessage.isInstance\n  );\n\n  if (toolMessages.length !== expected.length) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveToolMessages\")}\\n\\n` +\n        `Expected ${isNot ? \"not \" : \"\"}${expected.length} tool message(s), found ${toolMessages.length}`,\n      actual: toolMessages.length,\n      expected: expected.length,\n    };\n  }\n\n  for (let i = 0; i < expected.length; i++) {\n    const match = Object.entries(expected[i]).every(([key, value]) =>\n      this.equals((toolMessages[i] as any)[key], value)\n    );\n    if (!match) {\n      return {\n        pass: false,\n        message: () => {\n          const receivedFields: Record<string, unknown> = {};\n          for (const key of Object.keys(expected[i])) {\n            receivedFields[key] = (toolMessages[i] as any)[key];\n          }\n          return (\n            `${utils.matcherHint(\"toHaveToolMessages\")}\\n\\n` +\n            `Tool message at index ${i} did not match:\\n` +\n            `Expected: ${utils.printExpected(expected[i])}\\n` +\n            `Received: ${utils.printReceived(receivedFields)}`\n          );\n        },\n        actual: toolMessages[i],\n        expected: expected[i],\n      };\n    }\n  }\n\n  return {\n    pass: true,\n    message: () =>\n      `${utils.matcherHint(\"toHaveToolMessages\")}\\n\\n` +\n      `Expected messages not to contain matching tool messages`,\n  };\n}\n\nexport function toHaveBeenInterrupted(\n  this: ExpectExtendThis,\n  received: unknown,\n  expectedValue?: unknown\n): ExpectationResult {\n  const { isNot, utils } = this;\n\n  const result = received as Record<string, any>;\n  const interrupts = result?.__interrupt__;\n  const hasInterrupt = Array.isArray(interrupts) && interrupts.length > 0;\n\n  if (!hasInterrupt) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveBeenInterrupted\")}\\n\\n` +\n        `Expected result ${isNot ? \"not \" : \"\"}to have been interrupted\\n` +\n        `Received __interrupt__: ${utils.printReceived(interrupts)}`,\n    };\n  }\n\n  if (expectedValue === undefined) {\n    return {\n      pass: true,\n      message: () =>\n        `${utils.matcherHint(\"toHaveBeenInterrupted\")}\\n\\n` +\n        `Expected result not to have been interrupted\\n` +\n        `Received ${interrupts.length} interrupt(s)`,\n    };\n  }\n\n  const actualValue = interrupts[0]?.value;\n  const valuePass = this.equals(actualValue, expectedValue);\n\n  return {\n    pass: valuePass,\n    message: () =>\n      `${utils.matcherHint(\"toHaveBeenInterrupted\")}\\n\\n` +\n      `Expected interrupt value: ${utils.printExpected(expectedValue)}\\n` +\n      `Received interrupt value: ${utils.printReceived(actualValue)}`,\n    actual: actualValue,\n    expected: expectedValue,\n  };\n}\n\nexport function toHaveStructuredResponse(\n  this: ExpectExtendThis,\n  received: unknown,\n  expected?: Record<string, unknown>\n): ExpectationResult {\n  const { isNot, utils } = this;\n\n  const result = received as Record<string, any>;\n  const structuredResponse = result?.structuredResponse;\n  const isDefined = structuredResponse !== undefined;\n\n  if (!isDefined) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveStructuredResponse\")}\\n\\n` +\n        `Expected result ${isNot ? \"not \" : \"\"}to have a structured response\\n` +\n        `Received structuredResponse: undefined`,\n    };\n  }\n\n  if (expected === undefined) {\n    return {\n      pass: true,\n      message: () =>\n        `${utils.matcherHint(\"toHaveStructuredResponse\")}\\n\\n` +\n        `Expected result not to have a structured response`,\n    };\n  }\n\n  const fieldsPass = Object.entries(expected).every(([key, value]) =>\n    this.equals(structuredResponse[key], value)\n  );\n\n  return {\n    pass: fieldsPass,\n    message: () =>\n      `${utils.matcherHint(\"toHaveStructuredResponse\")}\\n\\n` +\n      `Expected structured response: ${utils.printExpected(expected)}\\n` +\n      `Received structured response: ${utils.printReceived(structuredResponse)}`,\n    actual: structuredResponse,\n    expected,\n  };\n}\n\n/**\n * All matcher functions bundled for convenient use with `expect.extend()`.\n */\nexport const langchainMatchers = {\n  toBeHumanMessage,\n  toBeAIMessage,\n  toBeSystemMessage,\n  toBeToolMessage,\n  toHaveToolCalls,\n  toHaveToolCallCount,\n  toContainToolCall,\n  toHaveToolMessages,\n  toHaveBeenInterrupted,\n  toHaveStructuredResponse,\n};\n\nexport interface LangChainMatchers<R = unknown> {\n  toBeHumanMessage(expected?: string | { content?: string; id?: string }): R;\n  toBeAIMessage(expected?: string | { content?: string; name?: string }): R;\n  toBeSystemMessage(\n    expected?: string | { content?: string; additional_kwargs?: object }\n  ): R;\n  toBeToolMessage(\n    expected?:\n      | string\n      | {\n          content?: string;\n          name?: string;\n          status?: string;\n          tool_call_id?: string;\n        }\n  ): R;\n  toHaveToolCalls(\n    expected: Array<{\n      name?: string;\n      id?: string;\n      args?: Record<string, unknown>;\n    }>\n  ): R;\n  toHaveToolCallCount(expected: number): R;\n  toContainToolCall(expected: {\n    name?: string;\n    id?: string;\n    args?: Record<string, unknown>;\n  }): R;\n  toHaveToolMessages(\n    expected: Array<{\n      content?: string;\n      name?: string;\n      status?: string;\n      tool_call_id?: string;\n    }>\n  ): R;\n  toHaveBeenInterrupted(expectedValue?: unknown): R;\n  toHaveStructuredResponse(expected?: Record<string, unknown>): R;\n}\n\ndeclare module \"vitest\" {\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  interface Matchers<T = any> extends LangChainMatchers<T> {}\n}\n"],"mappings":"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"}
+{"version":3,"file":"matchers.js","names":["result"],"sources":["../../src/testing/matchers.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\nimport { BaseMessage } from \"../messages/index.js\";\nimport { HumanMessage } from \"../messages/index.js\";\nimport { AIMessage } from \"../messages/index.js\";\nimport { SystemMessage } from \"../messages/index.js\";\nimport { ToolMessage } from \"../messages/index.js\";\n\n/**\n * The `this` context that Vitest and Jest provide to custom matchers\n * via `expect.extend`.\n *\n * Compatible with both frameworks:\n * - https://vitest.dev/guide/extending-matchers.html\n * - https://jestjs.io/docs/expect#expectextendmatchers\n */\ninterface ExpectExtendThis {\n  isNot?: boolean;\n  equals(a: unknown, b: unknown): boolean;\n  utils: {\n    matcherHint(name: string, received?: string, expected?: string): string;\n    printReceived(value: unknown): string;\n    printExpected(value: unknown): string;\n  };\n}\n\ninterface ExpectationResult {\n  pass: boolean;\n  message: () => string;\n  actual?: unknown;\n  expected?: unknown;\n}\n\nfunction getMessageTypeName(msg: unknown): string {\n  if (!BaseMessage.isInstance(msg)) return typeof msg;\n  return msg.constructor.name || msg.type;\n}\n\nfunction makeMessageTypeMatcher(\n  typeName: string,\n  isInstance: (obj: unknown) => boolean\n) {\n  return function (\n    this: ExpectExtendThis,\n    received: unknown,\n    expected?: string | Record<string, unknown>\n  ): ExpectationResult {\n    const { isNot, utils } = this;\n\n    const instancePass = isInstance(received);\n    if (!instancePass) {\n      return {\n        pass: false,\n        message: () =>\n          `${utils.matcherHint(`toBe${typeName}`, undefined, undefined)}\\n\\n` +\n          `Expected: ${isNot ? \"not \" : \"\"}${typeName}\\n` +\n          `Received: ${getMessageTypeName(received)}`,\n        actual: getMessageTypeName(received),\n        expected: typeName,\n      };\n    }\n\n    if (expected === undefined) {\n      return {\n        pass: true,\n        message: () =>\n          `${utils.matcherHint(`toBe${typeName}`, undefined, undefined)}\\n\\n` +\n          `Expected: not ${typeName}\\n` +\n          `Received: ${typeName}`,\n      };\n    }\n\n    const msg = received as BaseMessage;\n    if (typeof expected === \"string\") {\n      const contentPass = msg.content === expected;\n      return {\n        pass: contentPass,\n        message: () =>\n          `${utils.matcherHint(`toBe${typeName}`, undefined, undefined)}\\n\\n` +\n          `Expected: ${typeName} with content ${utils.printExpected(expected)}\\n` +\n          `Received: ${typeName} with content ${utils.printReceived(msg.content)}`,\n        actual: msg.content,\n        expected,\n      };\n    }\n\n    const fieldsPass = Object.entries(expected).every(([key, value]) =>\n      this.equals((msg as any)[key], value)\n    );\n    return {\n      pass: fieldsPass,\n      message: () => {\n        const receivedFields: Record<string, unknown> = {};\n        for (const key of Object.keys(expected)) {\n          receivedFields[key] = (msg as any)[key];\n        }\n        return (\n          `${utils.matcherHint(`toBe${typeName}`, undefined, undefined)}\\n\\n` +\n          `Expected: ${typeName} matching ${utils.printExpected(expected)}\\n` +\n          `Received: ${typeName} with ${utils.printReceived(receivedFields)}`\n        );\n      },\n      actual: (() => {\n        const receivedFields: Record<string, unknown> = {};\n        for (const key of Object.keys(expected)) {\n          receivedFields[key] = (msg as any)[key];\n        }\n        return receivedFields;\n      })(),\n      expected,\n    };\n  };\n}\n\nexport const toBeHumanMessage = makeMessageTypeMatcher(\n  \"HumanMessage\",\n  HumanMessage.isInstance\n);\n\nexport const toBeAIMessage = makeMessageTypeMatcher(\n  \"AIMessage\",\n  AIMessage.isInstance\n);\n\nexport const toBeSystemMessage = makeMessageTypeMatcher(\n  \"SystemMessage\",\n  SystemMessage.isInstance\n);\n\nexport const toBeToolMessage = makeMessageTypeMatcher(\n  \"ToolMessage\",\n  ToolMessage.isInstance\n);\n\nexport function toHaveToolCalls(\n  this: ExpectExtendThis,\n  received: unknown,\n  expected: Array<Record<string, unknown>>\n): ExpectationResult {\n  const { isNot, utils } = this;\n\n  if (!AIMessage.isInstance(received)) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveToolCalls\")}\\n\\n` +\n        `Expected: AIMessage\\n` +\n        `Received: ${getMessageTypeName(received)}`,\n    };\n  }\n\n  const actual = received.tool_calls ?? [];\n\n  if (actual.length !== expected.length) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveToolCalls\")}\\n\\n` +\n        `Expected ${isNot ? \"not \" : \"\"}${expected.length} tool call(s), received ${actual.length}`,\n      actual: actual.length,\n      expected: expected.length,\n    };\n  }\n\n  const unmatched = expected.filter(\n    (exp) =>\n      !actual.some((tc) =>\n        Object.entries(exp).every(([key, value]) =>\n          this.equals((tc as any)[key], value)\n        )\n      )\n  );\n\n  if (unmatched.length > 0) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveToolCalls\")}\\n\\n` +\n        `Could not find matching tool call(s) for:\\n` +\n        `${utils.printExpected(unmatched)}\\n` +\n        `Received tool calls: ${utils.printReceived(actual.map((tc) => ({ name: tc.name, id: tc.id, args: tc.args })))}`,\n      actual: actual.map((tc) => ({ name: tc.name, id: tc.id, args: tc.args })),\n      expected,\n    };\n  }\n\n  return {\n    pass: true,\n    message: () =>\n      `${utils.matcherHint(\"toHaveToolCalls\")}\\n\\n` +\n      `Expected AIMessage not to have matching tool calls`,\n  };\n}\n\nexport function toHaveToolCallCount(\n  this: ExpectExtendThis,\n  received: unknown,\n  expected: number\n): ExpectationResult {\n  const { isNot, utils } = this;\n\n  if (!AIMessage.isInstance(received)) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveToolCallCount\")}\\n\\n` +\n        `Expected: AIMessage\\n` +\n        `Received: ${getMessageTypeName(received)}`,\n    };\n  }\n\n  const actual = received.tool_calls?.length ?? 0;\n  const pass = actual === expected;\n\n  return {\n    pass,\n    message: () =>\n      `${utils.matcherHint(\"toHaveToolCallCount\")}\\n\\n` +\n      `Expected ${isNot ? \"not \" : \"\"}${expected} tool call(s)\\n` +\n      `Received: ${actual}`,\n    actual,\n    expected,\n  };\n}\n\nexport function toContainToolCall(\n  this: ExpectExtendThis,\n  received: unknown,\n  expected: Record<string, unknown>\n): ExpectationResult {\n  const { isNot, utils } = this;\n\n  if (!AIMessage.isInstance(received)) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toContainToolCall\")}\\n\\n` +\n        `Expected: AIMessage\\n` +\n        `Received: ${getMessageTypeName(received)}`,\n    };\n  }\n\n  const actual = received.tool_calls ?? [];\n  const found = actual.some((tc) =>\n    Object.entries(expected).every(([key, value]) =>\n      this.equals((tc as any)[key], value)\n    )\n  );\n\n  return {\n    pass: found,\n    message: () =>\n      `${utils.matcherHint(\"toContainToolCall\")}\\n\\n` +\n      `Expected AIMessage ${isNot ? \"not \" : \"\"}to contain a tool call matching ${utils.printExpected(expected)}\\n` +\n      `Received tool calls: ${utils.printReceived(actual.map((tc) => ({ name: tc.name, id: tc.id })))}`,\n    actual: actual.map((tc) => ({ name: tc.name, id: tc.id })),\n    expected,\n  };\n}\n\nexport function toHaveToolMessages(\n  this: ExpectExtendThis,\n  received: unknown,\n  expected: Array<Record<string, unknown>>\n): ExpectationResult {\n  const { isNot, utils } = this;\n\n  if (!Array.isArray(received)) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveToolMessages\")}\\n\\n` +\n        `Expected an array of messages\\n` +\n        `Received: ${typeof received}`,\n    };\n  }\n\n  const toolMessages = (received as BaseMessage[]).filter(\n    ToolMessage.isInstance\n  );\n\n  if (toolMessages.length !== expected.length) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveToolMessages\")}\\n\\n` +\n        `Expected ${isNot ? \"not \" : \"\"}${expected.length} tool message(s), found ${toolMessages.length}`,\n      actual: toolMessages.length,\n      expected: expected.length,\n    };\n  }\n\n  for (let i = 0; i < expected.length; i++) {\n    const match = Object.entries(expected[i]).every(([key, value]) =>\n      this.equals((toolMessages[i] as any)[key], value)\n    );\n    if (!match) {\n      return {\n        pass: false,\n        message: () => {\n          const receivedFields: Record<string, unknown> = {};\n          for (const key of Object.keys(expected[i])) {\n            receivedFields[key] = (toolMessages[i] as any)[key];\n          }\n          return (\n            `${utils.matcherHint(\"toHaveToolMessages\")}\\n\\n` +\n            `Tool message at index ${i} did not match:\\n` +\n            `Expected: ${utils.printExpected(expected[i])}\\n` +\n            `Received: ${utils.printReceived(receivedFields)}`\n          );\n        },\n        actual: toolMessages[i],\n        expected: expected[i],\n      };\n    }\n  }\n\n  return {\n    pass: true,\n    message: () =>\n      `${utils.matcherHint(\"toHaveToolMessages\")}\\n\\n` +\n      `Expected messages not to contain matching tool messages`,\n  };\n}\n\nexport function toHaveBeenInterrupted(\n  this: ExpectExtendThis,\n  received: unknown,\n  expectedValue?: unknown\n): ExpectationResult {\n  const { isNot, utils } = this;\n\n  const result = received as Record<string, any>;\n  const interrupts = result?.__interrupt__;\n  const hasInterrupt = Array.isArray(interrupts) && interrupts.length > 0;\n\n  if (!hasInterrupt) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveBeenInterrupted\")}\\n\\n` +\n        `Expected result ${isNot ? \"not \" : \"\"}to have been interrupted\\n` +\n        `Received __interrupt__: ${utils.printReceived(interrupts)}`,\n    };\n  }\n\n  if (expectedValue === undefined) {\n    return {\n      pass: true,\n      message: () =>\n        `${utils.matcherHint(\"toHaveBeenInterrupted\")}\\n\\n` +\n        `Expected result not to have been interrupted\\n` +\n        `Received ${interrupts.length} interrupt(s)`,\n    };\n  }\n\n  const actualValue = interrupts[0]?.value;\n  const valuePass = this.equals(actualValue, expectedValue);\n\n  return {\n    pass: valuePass,\n    message: () =>\n      `${utils.matcherHint(\"toHaveBeenInterrupted\")}\\n\\n` +\n      `Expected interrupt value: ${utils.printExpected(expectedValue)}\\n` +\n      `Received interrupt value: ${utils.printReceived(actualValue)}`,\n    actual: actualValue,\n    expected: expectedValue,\n  };\n}\n\nexport function toHaveStructuredResponse(\n  this: ExpectExtendThis,\n  received: unknown,\n  expected?: Record<string, unknown>\n): ExpectationResult {\n  const { isNot, utils } = this;\n\n  const result = received as Record<string, any>;\n  const structuredResponse = result?.structuredResponse;\n  const isDefined = structuredResponse !== undefined;\n\n  if (!isDefined) {\n    return {\n      pass: false,\n      message: () =>\n        `${utils.matcherHint(\"toHaveStructuredResponse\")}\\n\\n` +\n        `Expected result ${isNot ? \"not \" : \"\"}to have a structured response\\n` +\n        `Received structuredResponse: undefined`,\n    };\n  }\n\n  if (expected === undefined) {\n    return {\n      pass: true,\n      message: () =>\n        `${utils.matcherHint(\"toHaveStructuredResponse\")}\\n\\n` +\n        `Expected result not to have a structured response`,\n    };\n  }\n\n  const fieldsPass = Object.entries(expected).every(([key, value]) =>\n    this.equals(structuredResponse[key], value)\n  );\n\n  return {\n    pass: fieldsPass,\n    message: () =>\n      `${utils.matcherHint(\"toHaveStructuredResponse\")}\\n\\n` +\n      `Expected structured response: ${utils.printExpected(expected)}\\n` +\n      `Received structured response: ${utils.printReceived(structuredResponse)}`,\n    actual: structuredResponse,\n    expected,\n  };\n}\n\n/**\n * All matcher functions bundled for convenient use with `expect.extend()`.\n */\nexport const langchainMatchers = {\n  toBeHumanMessage,\n  toBeAIMessage,\n  toBeSystemMessage,\n  toBeToolMessage,\n  toHaveToolCalls,\n  toHaveToolCallCount,\n  toContainToolCall,\n  toHaveToolMessages,\n  toHaveBeenInterrupted,\n  toHaveStructuredResponse,\n};\n\nexport interface LangChainMatchers<R = unknown> {\n  toBeHumanMessage(expected?: string | { content?: string; id?: string }): R;\n  toBeAIMessage(expected?: string | { content?: string; name?: string }): R;\n  toBeSystemMessage(\n    expected?: string | { content?: string; additional_kwargs?: object }\n  ): R;\n  toBeToolMessage(\n    expected?:\n      | string\n      | {\n          content?: string;\n          name?: string;\n          status?: string;\n          tool_call_id?: string;\n        }\n  ): R;\n  toHaveToolCalls(\n    expected: Array<{\n      name?: string;\n      id?: string;\n      args?: Record<string, unknown>;\n    }>\n  ): R;\n  toHaveToolCallCount(expected: number): R;\n  toContainToolCall(expected: {\n    name?: string;\n    id?: string;\n    args?: Record<string, unknown>;\n  }): R;\n  toHaveToolMessages(\n    expected: Array<{\n      content?: string;\n      name?: string;\n      status?: string;\n      tool_call_id?: string;\n    }>\n  ): R;\n  toHaveBeenInterrupted(expectedValue?: unknown): R;\n  toHaveStructuredResponse(expected?: Record<string, unknown>): R;\n}\n\ndeclare module \"vitest\" {\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  interface Matchers<T = any> extends LangChainMatchers<T> {}\n}\n"],"mappings":"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"}