@langchain/core 1.2.4 → 1.2.6

package/dist/runnables/types.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.cts","names":[],"sources":["../../src/runnables/types.ts"],"mappings":";;;;;;KAKY,oBAAA;4EAEV,cAAA;EACA,gBAAA;AAAA;AAAA,KAGU,gBAAA;EACV,IAAA;EACA,MAAA,EAAQ,cAAA;AAAA;;;;;;;UASO,iBAAA,sDAKK,cAAA,GAAiB,cAAA,UAC7B,qBAAA;EACR,eAAA;EAEA,MAAA,CAAO,KAAA,EAAO,QAAA,EAAU,OAAA,GAAU,OAAA,CAAQ,WAAA,IAAe,OAAA,CAAQ,SAAA;EAEjE,KAAA,CACE,MAAA,EAAQ,QAAA,IACR,OAAA,GAAU,OAAA,CAAQ,WAAA,IAAe,OAAA,CAAQ,WAAA,KACzC,YAAA,GAAe,oBAAA;IAAyB,gBAAA;EAAA,IACvC,OAAA,CAAQ,SAAA;EAEX,KAAA,CACE,MAAA,EAAQ,QAAA,IACR,OAAA,GAAU,OAAA,CAAQ,WAAA,IAAe,OAAA,CAAQ,WAAA,KACzC,YAAA,GAAe,oBAAA;IAAyB,gBAAA;EAAA,IACvC,OAAA,EAAS,SAAA,GAAY,KAAA;EAExB,KAAA,CACE,MAAA,EAAQ,QAAA,IACR,OAAA,GAAU,OAAA,CAAQ,WAAA,IAAe,OAAA,CAAQ,WAAA,KACzC,YAAA,GAAe,oBAAA,GACd,OAAA,EAAS,SAAA,GAAY,KAAA;EAExB,MAAA,CACE,KAAA,EAAO,QAAA,EACP,OAAA,GAAU,OAAA,CAAQ,WAAA,IACjB,OAAA,CAAQ,+BAAA,CAAgC,SAAA;EAE3C,SAAA,CACE,SAAA,EAAW,cAAA,CAAe,QAAA,GAC1B,OAAA,EAAS,OAAA,CAAQ,WAAA,IAChB,cAAA,CAAe,SAAA;EAElB,OAAA,CAAQ,MAAA;AAAA;AAAA,UAGO,IAAA;EACf,MAAA;EACA,MAAA;EACA,IAAA;EACA,WAAA;AAAA;AAAA,UAGe,IAAA;EACf,EAAA;EACA,IAAA;EACA,IAAA,EAAM,gBAAA,GAAmB,iBAAA;EAEzB,QAAA,GAAW,MAAA;AAAA;AAAA,UAGI,cAAA,+BAEe,MAAA,gBAAsB,MAAA,uBAC5C,kBAAA;EAvCL;;;;EA4CH,YAAA,GAAe,qBAAA;EAxCoB;;;EA6CnC,cAAA;EA3CG;EA8CH,cAAA;EA1CoB;;;EA+CpB,OAAA;EA9CG;;;;;EAqDH,MAAA,GAAS,WAAA;AAAA"}
+{"version":3,"file":"types.d.cts","names":[],"sources":["../../src/runnables/types.ts"],"mappings":";;;;;KAKY;;EAEV;EACA;;KAGU;EACV;EACA,QAAQ;;;;;;;;UASO,kBAEf,gBAEA,iBACA,oBAAoB,iBAAiB,wBAC7B;EACR;EAEA,OAAO,OAAO,UAAU,UAAU,QAAQ,eAAe,QAAQ;EAEjE,MACE,QAAQ,YACR,UAAU,QAAQ,eAAe,QAAQ,gBACzC,eAAe;IAAyB;MACvC,QAAQ;EAEX,MACE,QAAQ,YACR,UAAU,QAAQ,eAAe,QAAQ,gBACzC,eAAe;IAAyB;MACvC,SAAS,YAAY;EAExB,MACE,QAAQ,YACR,UAAU,QAAQ,eAAe,QAAQ,gBACzC,eAAe,uBACd,SAAS,YAAY;EAExB,OACE,OAAO,UACP,UAAU,QAAQ,eACjB,QAAQ,gCAAgC;EAE3C,UACE,WAAW,eAAe,WAC1B,SAAS,QAAQ,eAChB,eAAe;EAElB,QAAQ;;UAGO;EACf;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA,MAAM,mBAAmB;EAEzB,WAAW;;UAGI,eAEf,8BAA8B,sBAAsB,6BAC5C;;;;;EAKR,eAAe;;;;EAKf;;EAGA;;;;EAKA;;;;;;EAOA,SAAS"}

package/dist/runnables/types.d.ts

@@ -2,10 +2,10 @@ import { SerializableInterface } from "../load/serializable.js";
 import { InteropZodType } from "../utils/types/zod.js";
 import { BaseCallbackConfig } from "../callbacks/manager.js";
 import { IterableReadableStreamInterface } from "../types/_internal.js";
-
 //#region src/runnables/types.d.ts
 type RunnableBatchOptions = {
-  /** @deprecated Pass in via the standard runnable config object instead */maxConcurrency?: number;
+  /** @deprecated Pass in via the standard runnable config object instead */
+  maxConcurrency?: number;
   returnExceptions?: boolean;
 };
 type RunnableIOSchema = {

package/dist/runnables/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/runnables/types.ts"],"mappings":";;;;;;KAKY,oBAAA;4EAEV,cAAA;EACA,gBAAA;AAAA;AAAA,KAGU,gBAAA;EACV,IAAA;EACA,MAAA,EAAQ,cAAA;AAAA;;;;;;;UASO,iBAAA,sDAKK,cAAA,GAAiB,cAAA,UAC7B,qBAAA;EACR,eAAA;EAEA,MAAA,CAAO,KAAA,EAAO,QAAA,EAAU,OAAA,GAAU,OAAA,CAAQ,WAAA,IAAe,OAAA,CAAQ,SAAA;EAEjE,KAAA,CACE,MAAA,EAAQ,QAAA,IACR,OAAA,GAAU,OAAA,CAAQ,WAAA,IAAe,OAAA,CAAQ,WAAA,KACzC,YAAA,GAAe,oBAAA;IAAyB,gBAAA;EAAA,IACvC,OAAA,CAAQ,SAAA;EAEX,KAAA,CACE,MAAA,EAAQ,QAAA,IACR,OAAA,GAAU,OAAA,CAAQ,WAAA,IAAe,OAAA,CAAQ,WAAA,KACzC,YAAA,GAAe,oBAAA;IAAyB,gBAAA;EAAA,IACvC,OAAA,EAAS,SAAA,GAAY,KAAA;EAExB,KAAA,CACE,MAAA,EAAQ,QAAA,IACR,OAAA,GAAU,OAAA,CAAQ,WAAA,IAAe,OAAA,CAAQ,WAAA,KACzC,YAAA,GAAe,oBAAA,GACd,OAAA,EAAS,SAAA,GAAY,KAAA;EAExB,MAAA,CACE,KAAA,EAAO,QAAA,EACP,OAAA,GAAU,OAAA,CAAQ,WAAA,IACjB,OAAA,CAAQ,+BAAA,CAAgC,SAAA;EAE3C,SAAA,CACE,SAAA,EAAW,cAAA,CAAe,QAAA,GAC1B,OAAA,EAAS,OAAA,CAAQ,WAAA,IAChB,cAAA,CAAe,SAAA;EAElB,OAAA,CAAQ,MAAA;AAAA;AAAA,UAGO,IAAA;EACf,MAAA;EACA,MAAA;EACA,IAAA;EACA,WAAA;AAAA;AAAA,UAGe,IAAA;EACf,EAAA;EACA,IAAA;EACA,IAAA,EAAM,gBAAA,GAAmB,iBAAA;EAEzB,QAAA,GAAW,MAAA;AAAA;AAAA,UAGI,cAAA,+BAEe,MAAA,gBAAsB,MAAA,uBAC5C,kBAAA;EAvCL;;;;EA4CH,YAAA,GAAe,qBAAA;EAxCoB;;;EA6CnC,cAAA;EA3CG;EA8CH,cAAA;EA1CoB;;;EA+CpB,OAAA;EA9CG;;;;;EAqDH,MAAA,GAAS,WAAA;AAAA"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/runnables/types.ts"],"mappings":";;;;;KAKY;;EAEV;EACA;;KAGU;EACV;EACA,QAAQ;;;;;;;;UASO,kBAEf,gBAEA,iBACA,oBAAoB,iBAAiB,wBAC7B;EACR;EAEA,OAAO,OAAO,UAAU,UAAU,QAAQ,eAAe,QAAQ;EAEjE,MACE,QAAQ,YACR,UAAU,QAAQ,eAAe,QAAQ,gBACzC,eAAe;IAAyB;MACvC,QAAQ;EAEX,MACE,QAAQ,YACR,UAAU,QAAQ,eAAe,QAAQ,gBACzC,eAAe;IAAyB;MACvC,SAAS,YAAY;EAExB,MACE,QAAQ,YACR,UAAU,QAAQ,eAAe,QAAQ,gBACzC,eAAe,uBACd,SAAS,YAAY;EAExB,OACE,OAAO,UACP,UAAU,QAAQ,eACjB,QAAQ,gCAAgC;EAE3C,UACE,WAAW,eAAe,WAC1B,SAAS,QAAQ,eAChB,eAAe;EAElB,QAAQ;;UAGO;EACf;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA,MAAM,mBAAmB;EAEzB,WAAW;;UAGI,eAEf,8BAA8B,sBAAsB,6BAC5C;;;;;EAKR,eAAe;;;;EAKf;;EAGA;;;;EAKA;;;;;;EAOA,SAAS"}

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,IACP,CAAC,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;CAC1E,OAAO,QAAQ,MAAM,cAAc;AACrC;;;;;;;;AASA,IAAa,mBAAb,MAA8B;CAC5B;CAEA;CAEA;CAEA;CAEA;CAEA;CAEA,YAAY,QAOT;EACD,KAAK,eAAe,OAAO;EAC3B,KAAK,eAAe,OAAO;EAC3B,KAAK,cAAc,OAAO;EAC1B,KAAK,eAAe,OAAO;EAC3B,KAAK,eAAe,OAAO;EAC3B,KAAK,cAAc,OAAO;CAC5B;CAEA,aAAa,OAAoB,UAA2B;EAC1D,IAAI,UACF,KAAK,iBAAiB,KAAA,KACtB,KAAK,iBAAiB,KAAA,KACtB,KAAK,gBAAgB,KAAA;EACvB,MAAM,YAAY,MAAM,QAAQ,CAAC;EAEjC,IAAI,KAAK,iBAAiB,KAAA,GACxB,UAAU,WAAW,KAAK,aAAa,SAAS,MAAM,IAAI;EAE5D,IAAI,KAAK,iBAAiB,KAAA,GACxB,UAAU,WAAW,KAAK,aAAa,SAAS,QAAQ;EAE1D,IAAI,KAAK,gBAAgB,KAAA,GACvB,UACE,WAAW,UAAU,MAAM,QAAQ,KAAK,aAAa,SAAS,GAAG,CAAC;EAGtE,IAAI,KAAK,iBAAiB,KAAA,GACxB,UAAU,WAAW,CAAC,KAAK,aAAa,SAAS,MAAM,IAAI;EAE7D,IAAI,KAAK,iBAAiB,KAAA,GACxB,UAAU,WAAW,CAAC,KAAK,aAAa,SAAS,QAAQ;EAE3D,IAAI,KAAK,gBAAgB,KAAA,GACvB,UACE,WAAW,UAAU,OAAO,QAAQ,CAAC,KAAK,aAAa,SAAS,GAAG,CAAC;EAGxE,OAAO;CACT;AACF;AAEA,MAAa,eAAe,QAAwB;CAGlD,OADgB,KAAK,GACR,CAAC,CAAC,QAAQ,OAAO,GAAG,CAAC,CAAC,QAAQ,OAAO,GAAG,CAAC,CAAC,QAAQ,OAAO,EAAE;AAC1E"}

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,IACP,CAAC,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;CAC1E,OAAO,QAAQ,MAAM,cAAc;AACrC;;;;;;;;AASA,IAAa,mBAAb,MAA8B;CAC5B;CAEA;CAEA;CAEA;CAEA;CAEA;CAEA,YAAY,QAOT;EACD,KAAK,eAAe,OAAO;EAC3B,KAAK,eAAe,OAAO;EAC3B,KAAK,cAAc,OAAO;EAC1B,KAAK,eAAe,OAAO;EAC3B,KAAK,eAAe,OAAO;EAC3B,KAAK,cAAc,OAAO;CAC5B;CAEA,aAAa,OAAoB,UAA2B;EAC1D,IAAI,UACF,KAAK,iBAAiB,KAAA,KACtB,KAAK,iBAAiB,KAAA,KACtB,KAAK,gBAAgB,KAAA;EACvB,MAAM,YAAY,MAAM,QAAQ,CAAC;EAEjC,IAAI,KAAK,iBAAiB,KAAA,GACxB,UAAU,WAAW,KAAK,aAAa,SAAS,MAAM,IAAI;EAE5D,IAAI,KAAK,iBAAiB,KAAA,GACxB,UAAU,WAAW,KAAK,aAAa,SAAS,QAAQ;EAE1D,IAAI,KAAK,gBAAgB,KAAA,GACvB,UACE,WAAW,UAAU,MAAM,QAAQ,KAAK,aAAa,SAAS,GAAG,CAAC;EAGtE,IAAI,KAAK,iBAAiB,KAAA,GACxB,UAAU,WAAW,CAAC,KAAK,aAAa,SAAS,MAAM,IAAI;EAE7D,IAAI,KAAK,iBAAiB,KAAA,GACxB,UAAU,WAAW,CAAC,KAAK,aAAa,SAAS,QAAQ;EAE3D,IAAI,KAAK,gBAAgB,KAAA,GACvB,UACE,WAAW,UAAU,OAAO,QAAQ,CAAC,KAAK,aAAa,SAAS,GAAG,CAAC;EAGxE,OAAO;CACT;AACF;AAEA,MAAa,eAAe,QAAwB;CAGlD,OADgB,KAAK,GACR,CAAC,CAAC,QAAQ,OAAO,GAAG,CAAC,CAAC,QAAQ,OAAO,GAAG,CAAC,CAAC,QAAQ,OAAO,EAAE;AAC1E"}

package/dist/runnables/wrappers.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"wrappers.cjs","names":["IterableReadableStream"],"sources":["../../src/runnables/wrappers.ts"],"sourcesContent":["import { IterableReadableStream } from \"../utils/stream.js\";\n\nexport function convertToHttpEventStream(stream: AsyncGenerator) {\n  const encoder = new TextEncoder();\n  const finalStream = new ReadableStream<Uint8Array>({\n    async start(controller) {\n      for await (const chunk of stream) {\n        controller.enqueue(\n          encoder.encode(`event: data\\ndata: ${JSON.stringify(chunk)}\\n\\n`)\n        );\n      }\n      controller.enqueue(encoder.encode(\"event: end\\n\\n\"));\n      controller.close();\n    },\n  });\n  return IterableReadableStream.fromReadableStream(finalStream);\n}\n"],"mappings":";;AAEA,SAAgB,yBAAyB,QAAwB;CAC/D,MAAM,UAAU,IAAI,aAAa;CACjC,MAAM,cAAc,IAAI,eAA2B,EACjD,MAAM,MAAM,YAAY;AACtB,aAAW,MAAM,SAAS,OACxB,YAAW,QACT,QAAQ,OAAO,sBAAsB,KAAK,UAAU,MAAM,CAAC,MAAM,CAClE;AAEH,aAAW,QAAQ,QAAQ,OAAO,iBAAiB,CAAC;AACpD,aAAW,OAAO;IAErB,CAAC;AACF,QAAOA,qBAAAA,uBAAuB,mBAAmB,YAAY"}
+{"version":3,"file":"wrappers.cjs","names":["IterableReadableStream"],"sources":["../../src/runnables/wrappers.ts"],"sourcesContent":["import { IterableReadableStream } from \"../utils/stream.js\";\n\nexport function convertToHttpEventStream(stream: AsyncGenerator) {\n  const encoder = new TextEncoder();\n  const finalStream = new ReadableStream<Uint8Array>({\n    async start(controller) {\n      for await (const chunk of stream) {\n        controller.enqueue(\n          encoder.encode(`event: data\\ndata: ${JSON.stringify(chunk)}\\n\\n`)\n        );\n      }\n      controller.enqueue(encoder.encode(\"event: end\\n\\n\"));\n      controller.close();\n    },\n  });\n  return IterableReadableStream.fromReadableStream(finalStream);\n}\n"],"mappings":";;AAEA,SAAgB,yBAAyB,QAAwB;CAC/D,MAAM,UAAU,IAAI,YAAY;CAChC,MAAM,cAAc,IAAI,eAA2B,EACjD,MAAM,MAAM,YAAY;EACtB,WAAW,MAAM,SAAS,QACxB,WAAW,QACT,QAAQ,OAAO,sBAAsB,KAAK,UAAU,KAAK,EAAE,KAAK,CAClE;EAEF,WAAW,QAAQ,QAAQ,OAAO,gBAAgB,CAAC;EACnD,WAAW,MAAM;CACnB,EACF,CAAC;CACD,OAAOA,qBAAAA,uBAAuB,mBAAmB,WAAW;AAC9D"}

package/dist/runnables/wrappers.js.map

@@ -1 +1 @@
-{"version":3,"file":"wrappers.js","names":[],"sources":["../../src/runnables/wrappers.ts"],"sourcesContent":["import { IterableReadableStream } from \"../utils/stream.js\";\n\nexport function convertToHttpEventStream(stream: AsyncGenerator) {\n  const encoder = new TextEncoder();\n  const finalStream = new ReadableStream<Uint8Array>({\n    async start(controller) {\n      for await (const chunk of stream) {\n        controller.enqueue(\n          encoder.encode(`event: data\\ndata: ${JSON.stringify(chunk)}\\n\\n`)\n        );\n      }\n      controller.enqueue(encoder.encode(\"event: end\\n\\n\"));\n      controller.close();\n    },\n  });\n  return IterableReadableStream.fromReadableStream(finalStream);\n}\n"],"mappings":";;AAEA,SAAgB,yBAAyB,QAAwB;CAC/D,MAAM,UAAU,IAAI,aAAa;CACjC,MAAM,cAAc,IAAI,eAA2B,EACjD,MAAM,MAAM,YAAY;AACtB,aAAW,MAAM,SAAS,OACxB,YAAW,QACT,QAAQ,OAAO,sBAAsB,KAAK,UAAU,MAAM,CAAC,MAAM,CAClE;AAEH,aAAW,QAAQ,QAAQ,OAAO,iBAAiB,CAAC;AACpD,aAAW,OAAO;IAErB,CAAC;AACF,QAAO,uBAAuB,mBAAmB,YAAY"}
+{"version":3,"file":"wrappers.js","names":[],"sources":["../../src/runnables/wrappers.ts"],"sourcesContent":["import { IterableReadableStream } from \"../utils/stream.js\";\n\nexport function convertToHttpEventStream(stream: AsyncGenerator) {\n  const encoder = new TextEncoder();\n  const finalStream = new ReadableStream<Uint8Array>({\n    async start(controller) {\n      for await (const chunk of stream) {\n        controller.enqueue(\n          encoder.encode(`event: data\\ndata: ${JSON.stringify(chunk)}\\n\\n`)\n        );\n      }\n      controller.enqueue(encoder.encode(\"event: end\\n\\n\"));\n      controller.close();\n    },\n  });\n  return IterableReadableStream.fromReadableStream(finalStream);\n}\n"],"mappings":";;AAEA,SAAgB,yBAAyB,QAAwB;CAC/D,MAAM,UAAU,IAAI,YAAY;CAChC,MAAM,cAAc,IAAI,eAA2B,EACjD,MAAM,MAAM,YAAY;EACtB,WAAW,MAAM,SAAS,QACxB,WAAW,QACT,QAAQ,OAAO,sBAAsB,KAAK,UAAU,KAAK,EAAE,KAAK,CAClE;EAEF,WAAW,QAAQ,QAAQ,OAAO,gBAAgB,CAAC;EACnD,WAAW,MAAM;CACnB,EACF,CAAC;CACD,OAAO,uBAAuB,mBAAmB,WAAW;AAC9D"}

package/dist/singletons/async_local_storage/context.cjs

@@ -1,4 +1,3 @@
-require("../../_virtual/_rolldown/runtime.cjs");
 const require_globals = require("./globals.cjs");
 let langsmith_run_trees = require("langsmith/run_trees");
 //#region src/singletons/async_local_storage/context.ts

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,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"}
+{"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,mCAAmC;CACrE,IAAI,8BAA8B,KAAA,GAChC,MAAM,IAAI,MACR,sFACF;CAEF,MAAM,UAAU,0BAA0B,SAAS;CACnD,MAAM,cAAc,EAAE,GAAG,UAAUC,gBAAAA,wBAAwB;CAC3D,YAAY,QAAQ;CACpB,IAAI,WAAW,CAAC;CAChB,KAAA,GAAA,oBAAA,UAAA,CAAc,OAAO,GACnB,WAAW,IAAIC,oBAAAA,QAAQ,OAAO;CAGhC,SAAkBD,gBAAAA,0BAA0B;CAC5C,0BAA0B,UAAU,QAAQ;AAC9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,SAAgB,mBAA4B,MAAkC;CAE5E,MAAM,4BAA4BD,gBAAAA,mCAAmC;CACrE,IAAI,8BAA8B,KAAA,GAChC;CAGF,OADgB,0BAA0B,SAC7B,CAAC,GAAGC,gBAAAA,uBAAuB,GAAG;AAC7C;AAEA,MAAM,yBAAyB,OAAO,oBAAoB;AAE1D,MAAa,2BACX,mBAAoC,sBAAsB,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+ClE,MAAa,yBAAyB,WAA0B;CAC9D,IAAI,OAAO,UAAU,CAAC,OAAO,cAC3B,MAAM,IAAI,MACR,sEACF;CAEF,mBAAmB,wBAAwB,CAAC,GAAG,mBAAmB,GAAG,MAAM,CAAC;AAC9E"}

package/dist/singletons/async_local_storage/context.d.cts

@@ -1,5 +1,4 @@
 import { BaseCallbackHandler } from "../../callbacks/base.cjs";
-
 //#region src/singletons/async_local_storage/context.d.ts
 /**
  * Set a context variable. Context variables are scoped to any

package/dist/singletons/async_local_storage/context.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.cts","names":[],"sources":["../../../src/singletons/async_local_storage/context.ts"],"mappings":";;;;;AAyDA;;;;;;;;;;;AAsEA;;;;;;;;;;AA4DA;;;;;AASA;;;;;;;;;;;;;;;;;;;;;;iBA3IgB,kBAAA,GAAA,CAAsB,IAAA,EAAM,WAAA,EAAa,KAAA,EAAO,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsEhD,kBAAA,SAAA,CAA4B,IAAA,EAAM,WAAA,GAAc,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4DnD,qBAAA,GAAqB,MAAA,EAAY,aAAA;AAAA,KASlC,aAAA;EACV,UAAA;EACA,WAAA;EAEA,YAAA,WAAuB,IAAA,YAAgB,mBAAA;EACvC,MAAA;AAAA"}
+{"version":3,"file":"context.d.cts","names":[],"sources":["../../../src/singletons/async_local_storage/context.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyDgB,mBAAmB,GAAG,MAAM,aAAa,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsEhD,mBAAmB,SAAS,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4DnD,wBAAqB,QAAY;KASlC;EACV;EACA;EAEA,uBAAuB,gBAAgB;EACvC"}

package/dist/singletons/async_local_storage/context.d.ts

@@ -1,5 +1,4 @@
 import { BaseCallbackHandler } from "../../callbacks/base.js";
-
 //#region src/singletons/async_local_storage/context.d.ts
 /**
  * Set a context variable. Context variables are scoped to any

package/dist/singletons/async_local_storage/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","names":[],"sources":["../../../src/singletons/async_local_storage/context.ts"],"mappings":";;;;;AAyDA;;;;;;;;;;;AAsEA;;;;;;;;;;AA4DA;;;;;AASA;;;;;;;;;;;;;;;;;;;;;;iBA3IgB,kBAAA,GAAA,CAAsB,IAAA,EAAM,WAAA,EAAa,KAAA,EAAO,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsEhD,kBAAA,SAAA,CAA4B,IAAA,EAAM,WAAA,GAAc,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4DnD,qBAAA,GAAqB,MAAA,EAAY,aAAA;AAAA,KASlC,aAAA;EACV,UAAA;EACA,WAAA;EAEA,YAAA,WAAuB,IAAA,YAAgB,mBAAA;EACvC,MAAA;AAAA"}
+{"version":3,"file":"context.d.ts","names":[],"sources":["../../../src/singletons/async_local_storage/context.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyDgB,mBAAmB,GAAG,MAAM,aAAa,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsEhD,mBAAmB,SAAS,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4DnD,wBAAqB,QAAY;KASlC;EACV;EACA;EAEA,uBAAuB,gBAAgB;EACvC"}

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,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"}
+{"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,mCAAmC;CACrE,IAAI,8BAA8B,KAAA,GAChC,MAAM,IAAI,MACR,sFACF;CAEF,MAAM,UAAU,0BAA0B,SAAS;CACnD,MAAM,cAAc,EAAE,GAAG,UAAU,wBAAwB;CAC3D,YAAY,QAAQ;CACpB,IAAI,WAAW,CAAC;CAChB,IAAI,UAAU,OAAO,GACnB,WAAW,IAAI,QAAQ,OAAO;CAGhC,SAAkB,0BAA0B;CAC5C,0BAA0B,UAAU,QAAQ;AAC9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,SAAgB,mBAA4B,MAAkC;CAE5E,MAAM,4BAA4B,mCAAmC;CACrE,IAAI,8BAA8B,KAAA,GAChC;CAGF,OADgB,0BAA0B,SAC7B,CAAC,GAAG,uBAAuB,GAAG;AAC7C;AAEA,MAAM,yBAAyB,OAAO,oBAAoB;AAE1D,MAAa,2BACX,mBAAoC,sBAAsB,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+ClE,MAAa,yBAAyB,WAA0B;CAC9D,IAAI,OAAO,UAAU,CAAC,OAAO,cAC3B,MAAM,IAAI,MACR,sEACF;CAEF,mBAAmB,wBAAwB,CAAC,GAAG,mBAAmB,GAAG,MAAM,CAAC;AAC9E"}

package/dist/singletons/async_local_storage/globals.cjs

@@ -8,6 +8,7 @@ const getGlobalAsyncLocalStorageInstance = () => {
 	return globalThis[TRACING_ALS_KEY];
 };
 //#endregion
+exports.TRACING_ALS_KEY = TRACING_ALS_KEY;
 exports._CONTEXT_VARIABLES_KEY = _CONTEXT_VARIABLES_KEY;
 exports.getGlobalAsyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance;
 exports.setGlobalAsyncLocalStorageInstance = setGlobalAsyncLocalStorageInstance;

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

@@ -1 +1 @@
-{"version":3,"file":"globals.cjs","names":[],"sources":["../../../src/singletons/async_local_storage/globals.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\nexport interface AsyncLocalStorageInterface {\n  getStore: () => any | undefined;\n\n  run: <T>(store: any, callback: () => T) => T;\n\n  enterWith: (store: any) => void;\n}\n\nexport const TRACING_ALS_KEY = Symbol.for(\"ls:tracing_async_local_storage\");\n\nexport const _CONTEXT_VARIABLES_KEY = Symbol.for(\"lc:context_variables\");\n\nexport const setGlobalAsyncLocalStorageInstance = (\n  instance: AsyncLocalStorageInterface\n) => {\n  (globalThis as any)[TRACING_ALS_KEY] = instance;\n};\n\nexport const getGlobalAsyncLocalStorageInstance = ():\n  | AsyncLocalStorageInterface\n  | undefined => {\n  return (globalThis as any)[TRACING_ALS_KEY];\n};\n"],"mappings":";AASA,MAAa,kBAAkB,OAAO,IAAI,iCAAiC;AAE3E,MAAa,yBAAyB,OAAO,IAAI,uBAAuB;AAExE,MAAa,sCACX,aACG;AACF,YAAmB,mBAAmB;;AAGzC,MAAa,2CAEI;AACf,QAAQ,WAAmB"}
+{"version":3,"file":"globals.cjs","names":[],"sources":["../../../src/singletons/async_local_storage/globals.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\nexport interface AsyncLocalStorageInterface {\n  getStore: () => any | undefined;\n\n  run: <T>(store: any, callback: () => T) => T;\n\n  enterWith: (store: any) => void;\n}\n\nexport const TRACING_ALS_KEY = Symbol.for(\"ls:tracing_async_local_storage\");\n\nexport const _CONTEXT_VARIABLES_KEY = Symbol.for(\"lc:context_variables\");\n\nexport const setGlobalAsyncLocalStorageInstance = (\n  instance: AsyncLocalStorageInterface\n) => {\n  (globalThis as any)[TRACING_ALS_KEY] = instance;\n};\n\nexport const getGlobalAsyncLocalStorageInstance = ():\n  | AsyncLocalStorageInterface\n  | undefined => {\n  return (globalThis as any)[TRACING_ALS_KEY];\n};\n"],"mappings":";AASA,MAAa,kBAAkB,OAAO,IAAI,gCAAgC;AAE1E,MAAa,yBAAyB,OAAO,IAAI,sBAAsB;AAEvE,MAAa,sCACX,aACG;CACH,WAAoB,mBAAmB;AACzC;AAEA,MAAa,2CAEI;CACf,OAAQ,WAAmB;AAC7B"}

package/dist/singletons/async_local_storage/globals.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"globals.d.cts","names":[],"sources":["../../../src/singletons/async_local_storage/globals.ts"],"mappings":";UACiB,0BAAA;EACf,QAAA;EAEA,GAAA,MAAS,KAAA,OAAY,QAAA,QAAgB,CAAA,KAAM,CAAA;EAE3C,SAAA,GAAY,KAAA;AAAA;AAAA,cAKD,sBAAA"}
+{"version":3,"file":"globals.d.cts","names":[],"sources":["../../../src/singletons/async_local_storage/globals.ts"],"mappings":";UACiB;EACf;EAEA,MAAM,GAAG,YAAY,gBAAgB,MAAM;EAE3C,YAAY;;cAKD"}

package/dist/singletons/async_local_storage/globals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"globals.d.ts","names":[],"sources":["../../../src/singletons/async_local_storage/globals.ts"],"mappings":";UACiB,0BAAA;EACf,QAAA;EAEA,GAAA,MAAS,KAAA,OAAY,QAAA,QAAgB,CAAA,KAAM,CAAA;EAE3C,SAAA,GAAY,KAAA;AAAA;AAAA,cAKD,sBAAA"}
+{"version":3,"file":"globals.d.ts","names":[],"sources":["../../../src/singletons/async_local_storage/globals.ts"],"mappings":";UACiB;EACf;EAEA,MAAM,GAAG,YAAY,gBAAgB,MAAM;EAE3C,YAAY;;cAKD"}

package/dist/singletons/async_local_storage/globals.js

@@ -8,6 +8,6 @@ const getGlobalAsyncLocalStorageInstance = () => {
 	return globalThis[TRACING_ALS_KEY];
 };
 //#endregion
-export { _CONTEXT_VARIABLES_KEY, getGlobalAsyncLocalStorageInstance, setGlobalAsyncLocalStorageInstance };
+export { TRACING_ALS_KEY, _CONTEXT_VARIABLES_KEY, getGlobalAsyncLocalStorageInstance, setGlobalAsyncLocalStorageInstance };
 
 //# sourceMappingURL=globals.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"globals.js","names":[],"sources":["../../../src/singletons/async_local_storage/globals.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\nexport interface AsyncLocalStorageInterface {\n  getStore: () => any | undefined;\n\n  run: <T>(store: any, callback: () => T) => T;\n\n  enterWith: (store: any) => void;\n}\n\nexport const TRACING_ALS_KEY = Symbol.for(\"ls:tracing_async_local_storage\");\n\nexport const _CONTEXT_VARIABLES_KEY = Symbol.for(\"lc:context_variables\");\n\nexport const setGlobalAsyncLocalStorageInstance = (\n  instance: AsyncLocalStorageInterface\n) => {\n  (globalThis as any)[TRACING_ALS_KEY] = instance;\n};\n\nexport const getGlobalAsyncLocalStorageInstance = ():\n  | AsyncLocalStorageInterface\n  | undefined => {\n  return (globalThis as any)[TRACING_ALS_KEY];\n};\n"],"mappings":";AASA,MAAa,kBAAkB,OAAO,IAAI,iCAAiC;AAE3E,MAAa,yBAAyB,OAAO,IAAI,uBAAuB;AAExE,MAAa,sCACX,aACG;AACF,YAAmB,mBAAmB;;AAGzC,MAAa,2CAEI;AACf,QAAQ,WAAmB"}
+{"version":3,"file":"globals.js","names":[],"sources":["../../../src/singletons/async_local_storage/globals.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\nexport interface AsyncLocalStorageInterface {\n  getStore: () => any | undefined;\n\n  run: <T>(store: any, callback: () => T) => T;\n\n  enterWith: (store: any) => void;\n}\n\nexport const TRACING_ALS_KEY = Symbol.for(\"ls:tracing_async_local_storage\");\n\nexport const _CONTEXT_VARIABLES_KEY = Symbol.for(\"lc:context_variables\");\n\nexport const setGlobalAsyncLocalStorageInstance = (\n  instance: AsyncLocalStorageInterface\n) => {\n  (globalThis as any)[TRACING_ALS_KEY] = instance;\n};\n\nexport const getGlobalAsyncLocalStorageInstance = ():\n  | AsyncLocalStorageInterface\n  | undefined => {\n  return (globalThis as any)[TRACING_ALS_KEY];\n};\n"],"mappings":";AASA,MAAa,kBAAkB,OAAO,IAAI,gCAAgC;AAE1E,MAAa,yBAAyB,OAAO,IAAI,sBAAsB;AAEvE,MAAa,sCACX,aACG;CACH,WAAoB,mBAAmB;AACzC;AAEA,MAAa,2CAEI;CACf,OAAQ,WAAmB;AAC7B"}

package/dist/singletons/async_local_storage/index.cjs

@@ -1,4 +1,3 @@
-require("../../_virtual/_rolldown/runtime.cjs");
 const require_globals = require("./globals.cjs");
 const require_callbacks_manager = require("../../callbacks/manager.cjs");
 let langsmith = require("langsmith");

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,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"}
+{"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,CAEhB;CAEA,IAAO,QAAa,UAAsB;EACxC,OAAO,SAAS;CAClB;CAEA,UAAU,QAAa,CAEvB;AACF;AAEA,MAAM,wBAAwB,IAAI,sBAAsB;AAExD,MAAM,eAAe,OAAO,IAAI,iBAAiB;AAEjD,IAAM,4BAAN,MAAgC;CAC9B,cAA0C;EACxC,OAAOA,gBAAAA,mCAAmC,KAAK;CACjD;CAEA,oBAAoB;EAKlB,OAJgB,KAAK,YAIR,CAAC,CAAC,SAAS,CAAC,EAAE,QAAQ;CACrC;CAEA,cACE,QACA,UACA,0BACG;EACH,MAAM,kBAAkBC,0BAAAA,gBAAgB,eACtC,QAAQ,WACR,KAAA,GACA,QAAQ,MACR,KAAA,GACA,QAAQ,QACV;EACA,MAAM,UAAU,KAAK,YAAY;EACjC,MAAM,gBAAgB,QAAQ,SAAS;EACvC,MAAM,cAAc,iBAAiB,eAAe;EAEpD,MAAM,kBAAkB,iBAAiB,UAAU,MAChD,YAAY,SAAS,SAAS,kBACjC;EAEA,IAAI;EACJ,IAAI,mBAAmB,aACrB,UAAU,gBAAgB,4BAA4B,WAAW;OAC5D,IAAI,CAAC,0BACV,UAAU,IAAIC,UAAAA,QAAQ;GACpB,MAAM;GACN,gBAAgB;EAClB,CAAC;EAGH,IAAI,SACF,QAAQ,QAAQ;GAAE,GAAG,QAAQ;IAAQ,eAAe;EAAO;EAG7D,IACE,kBAAkB,KAAA,KAClB,cAAcC,gBAAAA,4BAA4B,KAAA,GAC1C;GACA,IAAI,YAAY,KAAA,GACd,UAAU,CAAC;GAEb,QAAiBA,gBAAAA,0BACf,cAAcA,gBAAAA;EAClB;EAEA,OAAO,QAAQ,IAAI,SAAS,QAAQ;CACtC;CAEA,yBAAyB,UAAsC;EAC7D,IAAIH,gBAAAA,mCAAmC,MAAM,KAAA,GAC3C,gBAAA,mCAAmC,QAAQ;CAE/C;AACF;AAEA,MAAM,qCAAqC,IAAI,0BAA0B"}

package/dist/singletons/async_local_storage/index.d.cts

@@ -1,5 +1,4 @@
 import { AsyncLocalStorageInterface } from "./globals.cjs";
-
 //#region src/singletons/async_local_storage/index.d.ts
 declare class MockAsyncLocalStorage implements AsyncLocalStorageInterface {
   getStore(): any;
@@ -14,5 +13,5 @@ declare class AsyncLocalStorageProvider {
 }
 declare const AsyncLocalStorageProviderSingleton: AsyncLocalStorageProvider;
 //#endregion
-export { AsyncLocalStorageProviderSingleton, MockAsyncLocalStorage };
+export { type AsyncLocalStorageInterface, AsyncLocalStorageProviderSingleton, MockAsyncLocalStorage };
 //# sourceMappingURL=index.d.cts.map

package/dist/singletons/async_local_storage/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/singletons/async_local_storage/index.ts"],"mappings":";;;cAWa,qBAAA,YAAiC,0BAAA;EAC5C,QAAA,CAAA;EAIA,GAAA,GAAA,CAAO,MAAA,OAAa,QAAA,QAAgB,CAAA,GAAI,CAAA;EAIxC,SAAA,CAAU,MAAA;AAAA;AAAA,cASN,yBAAA;EACJ,WAAA,CAAA,GAAe,0BAAA;EAIf,iBAAA,CAAA;EAQA,aAAA,GAAA,CACE,MAAA,OACA,QAAA,QAAgB,CAAA,EAChB,wBAAA,aACC,CAAA;EA4CH,wBAAA,CAAyB,QAAA,EAAU,0BAAA;AAAA;AAAA,cAO/B,kCAAA,EAAkC,yBAAA"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/singletons/async_local_storage/index.ts"],"mappings":";;cAWa,iCAAiC;EAC5C;EAIA,IAAI,GAAG,aAAa,gBAAgB,IAAI;EAIxC,UAAU;;cASN;EACJ,eAAe;EAIf;EAQA,cAAc,GACZ,aACA,gBAAgB,GAChB,qCACC;EA4CH,yBAAyB,UAAU;;cAO/B,oCAAkC"}

package/dist/singletons/async_local_storage/index.d.ts

@@ -1,5 +1,4 @@
 import { AsyncLocalStorageInterface } from "./globals.js";
-
 //#region src/singletons/async_local_storage/index.d.ts
 declare class MockAsyncLocalStorage implements AsyncLocalStorageInterface {
   getStore(): any;
@@ -14,5 +13,5 @@ declare class AsyncLocalStorageProvider {
 }
 declare const AsyncLocalStorageProviderSingleton: AsyncLocalStorageProvider;
 //#endregion
-export { AsyncLocalStorageProviderSingleton, MockAsyncLocalStorage };
+export { type AsyncLocalStorageInterface, AsyncLocalStorageProviderSingleton, MockAsyncLocalStorage };
 //# sourceMappingURL=index.d.ts.map

package/dist/singletons/async_local_storage/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/singletons/async_local_storage/index.ts"],"mappings":";;;cAWa,qBAAA,YAAiC,0BAAA;EAC5C,QAAA,CAAA;EAIA,GAAA,GAAA,CAAO,MAAA,OAAa,QAAA,QAAgB,CAAA,GAAI,CAAA;EAIxC,SAAA,CAAU,MAAA;AAAA;AAAA,cASN,yBAAA;EACJ,WAAA,CAAA,GAAe,0BAAA;EAIf,iBAAA,CAAA;EAQA,aAAA,GAAA,CACE,MAAA,OACA,QAAA,QAAgB,CAAA,EAChB,wBAAA,aACC,CAAA;EA4CH,wBAAA,CAAyB,QAAA,EAAU,0BAAA;AAAA;AAAA,cAO/B,kCAAA,EAAkC,yBAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/singletons/async_local_storage/index.ts"],"mappings":";;cAWa,iCAAiC;EAC5C;EAIA,IAAI,GAAG,aAAa,gBAAgB,IAAI;EAIxC,UAAU;;cASN;EACJ,eAAe;EAIf;EAQA,cAAc,GACZ,aACA,gBAAgB,GAChB,qCACC;EA4CH,yBAAyB,UAAU;;cAO/B,oCAAkC"}

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,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"}
+{"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,CAEhB;CAEA,IAAO,QAAa,UAAsB;EACxC,OAAO,SAAS;CAClB;CAEA,UAAU,QAAa,CAEvB;AACF;AAEA,MAAM,wBAAwB,IAAI,sBAAsB;AAExD,MAAM,eAAe,OAAO,IAAI,iBAAiB;AAEjD,IAAM,4BAAN,MAAgC;CAC9B,cAA0C;EACxC,OAAO,mCAAmC,KAAK;CACjD;CAEA,oBAAoB;EAKlB,OAJgB,KAAK,YAIR,CAAC,CAAC,SAAS,CAAC,EAAE,QAAQ;CACrC;CAEA,cACE,QACA,UACA,0BACG;EACH,MAAM,kBAAkB,gBAAgB,eACtC,QAAQ,WACR,KAAA,GACA,QAAQ,MACR,KAAA,GACA,QAAQ,QACV;EACA,MAAM,UAAU,KAAK,YAAY;EACjC,MAAM,gBAAgB,QAAQ,SAAS;EACvC,MAAM,cAAc,iBAAiB,eAAe;EAEpD,MAAM,kBAAkB,iBAAiB,UAAU,MAChD,YAAY,SAAS,SAAS,kBACjC;EAEA,IAAI;EACJ,IAAI,mBAAmB,aACrB,UAAU,gBAAgB,4BAA4B,WAAW;OAC5D,IAAI,CAAC,0BACV,UAAU,IAAI,QAAQ;GACpB,MAAM;GACN,gBAAgB;EAClB,CAAC;EAGH,IAAI,SACF,QAAQ,QAAQ;GAAE,GAAG,QAAQ;IAAQ,eAAe;EAAO;EAG7D,IACE,kBAAkB,KAAA,KAClB,cAAc,4BAA4B,KAAA,GAC1C;GACA,IAAI,YAAY,KAAA,GACd,UAAU,CAAC;GAEb,QAAiB,0BACf,cAAc;EAClB;EAEA,OAAO,QAAQ,IAAI,SAAS,QAAQ;CACtC;CAEA,yBAAyB,UAAsC;EAC7D,IAAI,mCAAmC,MAAM,KAAA,GAC3C,mCAAmC,QAAQ;CAE/C;AACF;AAEA,MAAM,qCAAqC,IAAI,0BAA0B"}

package/dist/singletons/callbacks.cjs

@@ -50,5 +50,6 @@ async function awaitAllCallbacks() {
 //#endregion
 exports.awaitAllCallbacks = awaitAllCallbacks;
 exports.consumeCallback = consumeCallback;
+exports.getQueue = getQueue;
 
 //# sourceMappingURL=callbacks.cjs.map

package/dist/singletons/callbacks.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"callbacks.cjs","names":["PQueueMod","getGlobalAsyncLocalStorageInstance","getDefaultLangChainClientSingleton"],"sources":["../../src/singletons/callbacks.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\n\nimport PQueueMod from \"p-queue\";\nimport { getGlobalAsyncLocalStorageInstance } from \"./async_local_storage/globals.js\";\nimport { getDefaultLangChainClientSingleton } from \"./tracer.js\";\n\nlet queue: (typeof import(\"p-queue\"))[\"default\"][\"prototype\"];\n\n/**\n * Creates a queue using the p-queue library. The queue is configured to\n * auto-start and has a concurrency of 1, meaning it will process tasks\n * one at a time.\n */\nfunction createQueue() {\n  const PQueue: any = \"default\" in PQueueMod ? PQueueMod.default : PQueueMod;\n  return new PQueue({\n    autoStart: true,\n    concurrency: 1,\n  });\n}\n\nexport function getQueue() {\n  if (typeof queue === \"undefined\") {\n    queue = createQueue();\n  }\n  return queue;\n}\n\n/**\n * Consume a promise, either adding it to the queue or waiting for it to resolve\n * @param promiseFn Promise to consume\n * @param wait Whether to wait for the promise to resolve or resolve immediately\n */\nexport async function consumeCallback<T>(\n  promiseFn: () => Promise<T> | T | void,\n  wait: boolean\n): Promise<void> {\n  if (wait === true) {\n    // Clear config since callbacks are not part of the root run\n    // Avoid using global singleton due to circuluar dependency issues\n    const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n    if (asyncLocalStorageInstance !== undefined) {\n      await asyncLocalStorageInstance.run(undefined, async () => promiseFn());\n    } else {\n      await promiseFn();\n    }\n  } else {\n    queue = getQueue();\n    // oxlint-disable-next-line no-void\n    void queue.add(async () => {\n      const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n      if (asyncLocalStorageInstance !== undefined) {\n        await asyncLocalStorageInstance.run(undefined, async () => promiseFn());\n      } else {\n        await promiseFn();\n      }\n    });\n  }\n}\n\n/**\n * Waits for all promises in the queue to resolve. If the queue is\n * undefined, it immediately resolves a promise.\n */\nexport async function awaitAllCallbacks(): Promise<void> {\n  const defaultClient = getDefaultLangChainClientSingleton();\n  await Promise.allSettled([\n    typeof queue !== \"undefined\" ? queue.onIdle() : Promise.resolve(),\n    defaultClient.awaitPendingTraceBatches(),\n  ]);\n}\n"],"mappings":";;;;;;AAMA,IAAI;;;;;;AAOJ,SAAS,cAAc;AAErB,QAAO,KADa,aAAaA,QAAAA,UAAYA,QAAAA,QAAU,UAAUA,QAAAA,SAC/C;EAChB,WAAW;EACX,aAAa;EACd,CAAC;;AAGJ,SAAgB,WAAW;AACzB,KAAI,OAAO,UAAU,YACnB,SAAQ,aAAa;AAEvB,QAAO;;;;;;;AAQT,eAAsB,gBACpB,WACA,MACe;AACf,KAAI,SAAS,MAAM;EAGjB,MAAM,4BAA4BC,gBAAAA,oCAAoC;AACtE,MAAI,8BAA8B,KAAA,EAChC,OAAM,0BAA0B,IAAI,KAAA,GAAW,YAAY,WAAW,CAAC;MAEvE,OAAM,WAAW;QAEd;AACL,UAAQ,UAAU;AAEb,QAAM,IAAI,YAAY;GACzB,MAAM,4BAA4BA,gBAAAA,oCAAoC;AACtE,OAAI,8BAA8B,KAAA,EAChC,OAAM,0BAA0B,IAAI,KAAA,GAAW,YAAY,WAAW,CAAC;OAEvE,OAAM,WAAW;IAEnB;;;;;;;AAQN,eAAsB,oBAAmC;CACvD,MAAM,gBAAgBC,eAAAA,oCAAoC;AAC1D,OAAM,QAAQ,WAAW,CACvB,OAAO,UAAU,cAAc,MAAM,QAAQ,GAAG,QAAQ,SAAS,EACjE,cAAc,0BAA0B,CACzC,CAAC"}
+{"version":3,"file":"callbacks.cjs","names":["PQueueMod","getGlobalAsyncLocalStorageInstance","getDefaultLangChainClientSingleton"],"sources":["../../src/singletons/callbacks.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\n\nimport PQueueMod from \"p-queue\";\nimport { getGlobalAsyncLocalStorageInstance } from \"./async_local_storage/globals.js\";\nimport { getDefaultLangChainClientSingleton } from \"./tracer.js\";\n\nlet queue: (typeof import(\"p-queue\"))[\"default\"][\"prototype\"];\n\n/**\n * Creates a queue using the p-queue library. The queue is configured to\n * auto-start and has a concurrency of 1, meaning it will process tasks\n * one at a time.\n */\nfunction createQueue() {\n  const PQueue: any = \"default\" in PQueueMod ? PQueueMod.default : PQueueMod;\n  return new PQueue({\n    autoStart: true,\n    concurrency: 1,\n  });\n}\n\nexport function getQueue() {\n  if (typeof queue === \"undefined\") {\n    queue = createQueue();\n  }\n  return queue;\n}\n\n/**\n * Consume a promise, either adding it to the queue or waiting for it to resolve\n * @param promiseFn Promise to consume\n * @param wait Whether to wait for the promise to resolve or resolve immediately\n */\nexport async function consumeCallback<T>(\n  promiseFn: () => Promise<T> | T | void,\n  wait: boolean\n): Promise<void> {\n  if (wait === true) {\n    // Clear config since callbacks are not part of the root run\n    // Avoid using global singleton due to circuluar dependency issues\n    const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n    if (asyncLocalStorageInstance !== undefined) {\n      await asyncLocalStorageInstance.run(undefined, async () => promiseFn());\n    } else {\n      await promiseFn();\n    }\n  } else {\n    queue = getQueue();\n    // oxlint-disable-next-line no-void\n    void queue.add(async () => {\n      const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n      if (asyncLocalStorageInstance !== undefined) {\n        await asyncLocalStorageInstance.run(undefined, async () => promiseFn());\n      } else {\n        await promiseFn();\n      }\n    });\n  }\n}\n\n/**\n * Waits for all promises in the queue to resolve. If the queue is\n * undefined, it immediately resolves a promise.\n */\nexport async function awaitAllCallbacks(): Promise<void> {\n  const defaultClient = getDefaultLangChainClientSingleton();\n  await Promise.allSettled([\n    typeof queue !== \"undefined\" ? queue.onIdle() : Promise.resolve(),\n    defaultClient.awaitPendingTraceBatches(),\n  ]);\n}\n"],"mappings":";;;;;;AAMA,IAAI;;;;;;AAOJ,SAAS,cAAc;CAErB,OAAO,KADa,aAAaA,QAAAA,UAAYA,QAAAA,QAAU,UAAUA,QAAAA,SAC/C;EAChB,WAAW;EACX,aAAa;CACf,CAAC;AACH;AAEA,SAAgB,WAAW;CACzB,IAAI,OAAO,UAAU,aACnB,QAAQ,YAAY;CAEtB,OAAO;AACT;;;;;;AAOA,eAAsB,gBACpB,WACA,MACe;CACf,IAAI,SAAS,MAAM;EAGjB,MAAM,4BAA4BC,gBAAAA,mCAAmC;EACrE,IAAI,8BAA8B,KAAA,GAChC,MAAM,0BAA0B,IAAI,KAAA,GAAW,YAAY,UAAU,CAAC;OAEtE,MAAM,UAAU;CAEpB,OAAO;EACL,QAAQ,SAAS;EAEjB,MAAW,IAAI,YAAY;GACzB,MAAM,4BAA4BA,gBAAAA,mCAAmC;GACrE,IAAI,8BAA8B,KAAA,GAChC,MAAM,0BAA0B,IAAI,KAAA,GAAW,YAAY,UAAU,CAAC;QAEtE,MAAM,UAAU;EAEpB,CAAC;CACH;AACF;;;;;AAMA,eAAsB,oBAAmC;CACvD,MAAM,gBAAgBC,eAAAA,mCAAmC;CACzD,MAAM,QAAQ,WAAW,CACvB,OAAO,UAAU,cAAc,MAAM,OAAO,IAAI,QAAQ,QAAQ,GAChE,cAAc,yBAAyB,CACzC,CAAC;AACH"}

package/dist/singletons/callbacks.d.cts

@@ -1,3 +1,4 @@
+import "p-queue";
 //#region src/singletons/callbacks.d.ts
 /**
  * Consume a promise, either adding it to the queue or waiting for it to resolve

package/dist/singletons/callbacks.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"callbacks.d.cts","names":[],"sources":["../../src/singletons/callbacks.ts"],"mappings":";;AAiCA;;;;iBAAsB,eAAA,GAAA,CACpB,SAAA,QAAiB,OAAA,CAAQ,CAAA,IAAK,CAAA,SAC9B,IAAA,YACC,OAAA;;;;;iBA4BmB,iBAAA,CAAA,GAAqB,OAAA"}
+{"version":3,"file":"callbacks.d.cts","names":[],"sources":["../../src/singletons/callbacks.ts"],"mappings":";;;;;;;iBAiCsB,gBAAgB,GACpC,iBAAiB,QAAQ,KAAK,UAC9B,gBACC;;;;;iBA4BmB,qBAAqB"}

package/dist/singletons/callbacks.d.ts

@@ -1,5 +1,4 @@
 import PQueueMod from "p-queue";
-
 //#region src/singletons/callbacks.d.ts
 /**
  * Consume a promise, either adding it to the queue or waiting for it to resolve

package/dist/singletons/callbacks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"callbacks.d.ts","names":[],"sources":["../../src/singletons/callbacks.ts"],"mappings":";;;;AAiCA;;;;iBAAsB,eAAA,GAAA,CACpB,SAAA,QAAiB,OAAA,CAAQ,CAAA,IAAK,CAAA,SAC9B,IAAA,YACC,OAAA;;;;;iBA4BmB,iBAAA,CAAA,GAAqB,OAAA"}
+{"version":3,"file":"callbacks.d.ts","names":[],"sources":["../../src/singletons/callbacks.ts"],"mappings":";;;;;;;iBAiCsB,gBAAgB,GACpC,iBAAiB,QAAQ,KAAK,UAC9B,gBACC;;;;;iBA4BmB,qBAAqB"}

package/dist/singletons/callbacks.js

@@ -46,6 +46,6 @@ async function awaitAllCallbacks() {
 	await Promise.allSettled([typeof queue !== "undefined" ? queue.onIdle() : Promise.resolve(), defaultClient.awaitPendingTraceBatches()]);
 }
 //#endregion
-export { awaitAllCallbacks, consumeCallback };
+export { awaitAllCallbacks, consumeCallback, getQueue };
 
 //# sourceMappingURL=callbacks.js.map

package/dist/singletons/callbacks.js.map

@@ -1 +1 @@
-{"version":3,"file":"callbacks.js","names":[],"sources":["../../src/singletons/callbacks.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\n\nimport PQueueMod from \"p-queue\";\nimport { getGlobalAsyncLocalStorageInstance } from \"./async_local_storage/globals.js\";\nimport { getDefaultLangChainClientSingleton } from \"./tracer.js\";\n\nlet queue: (typeof import(\"p-queue\"))[\"default\"][\"prototype\"];\n\n/**\n * Creates a queue using the p-queue library. The queue is configured to\n * auto-start and has a concurrency of 1, meaning it will process tasks\n * one at a time.\n */\nfunction createQueue() {\n  const PQueue: any = \"default\" in PQueueMod ? PQueueMod.default : PQueueMod;\n  return new PQueue({\n    autoStart: true,\n    concurrency: 1,\n  });\n}\n\nexport function getQueue() {\n  if (typeof queue === \"undefined\") {\n    queue = createQueue();\n  }\n  return queue;\n}\n\n/**\n * Consume a promise, either adding it to the queue or waiting for it to resolve\n * @param promiseFn Promise to consume\n * @param wait Whether to wait for the promise to resolve or resolve immediately\n */\nexport async function consumeCallback<T>(\n  promiseFn: () => Promise<T> | T | void,\n  wait: boolean\n): Promise<void> {\n  if (wait === true) {\n    // Clear config since callbacks are not part of the root run\n    // Avoid using global singleton due to circuluar dependency issues\n    const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n    if (asyncLocalStorageInstance !== undefined) {\n      await asyncLocalStorageInstance.run(undefined, async () => promiseFn());\n    } else {\n      await promiseFn();\n    }\n  } else {\n    queue = getQueue();\n    // oxlint-disable-next-line no-void\n    void queue.add(async () => {\n      const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n      if (asyncLocalStorageInstance !== undefined) {\n        await asyncLocalStorageInstance.run(undefined, async () => promiseFn());\n      } else {\n        await promiseFn();\n      }\n    });\n  }\n}\n\n/**\n * Waits for all promises in the queue to resolve. If the queue is\n * undefined, it immediately resolves a promise.\n */\nexport async function awaitAllCallbacks(): Promise<void> {\n  const defaultClient = getDefaultLangChainClientSingleton();\n  await Promise.allSettled([\n    typeof queue !== \"undefined\" ? queue.onIdle() : Promise.resolve(),\n    defaultClient.awaitPendingTraceBatches(),\n  ]);\n}\n"],"mappings":";;;;AAMA,IAAI;;;;;;AAOJ,SAAS,cAAc;AAErB,QAAO,KADa,aAAa,YAAY,UAAU,UAAU,WAC/C;EAChB,WAAW;EACX,aAAa;EACd,CAAC;;AAGJ,SAAgB,WAAW;AACzB,KAAI,OAAO,UAAU,YACnB,SAAQ,aAAa;AAEvB,QAAO;;;;;;;AAQT,eAAsB,gBACpB,WACA,MACe;AACf,KAAI,SAAS,MAAM;EAGjB,MAAM,4BAA4B,oCAAoC;AACtE,MAAI,8BAA8B,KAAA,EAChC,OAAM,0BAA0B,IAAI,KAAA,GAAW,YAAY,WAAW,CAAC;MAEvE,OAAM,WAAW;QAEd;AACL,UAAQ,UAAU;AAEb,QAAM,IAAI,YAAY;GACzB,MAAM,4BAA4B,oCAAoC;AACtE,OAAI,8BAA8B,KAAA,EAChC,OAAM,0BAA0B,IAAI,KAAA,GAAW,YAAY,WAAW,CAAC;OAEvE,OAAM,WAAW;IAEnB;;;;;;;AAQN,eAAsB,oBAAmC;CACvD,MAAM,gBAAgB,oCAAoC;AAC1D,OAAM,QAAQ,WAAW,CACvB,OAAO,UAAU,cAAc,MAAM,QAAQ,GAAG,QAAQ,SAAS,EACjE,cAAc,0BAA0B,CACzC,CAAC"}
+{"version":3,"file":"callbacks.js","names":[],"sources":["../../src/singletons/callbacks.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\n\nimport PQueueMod from \"p-queue\";\nimport { getGlobalAsyncLocalStorageInstance } from \"./async_local_storage/globals.js\";\nimport { getDefaultLangChainClientSingleton } from \"./tracer.js\";\n\nlet queue: (typeof import(\"p-queue\"))[\"default\"][\"prototype\"];\n\n/**\n * Creates a queue using the p-queue library. The queue is configured to\n * auto-start and has a concurrency of 1, meaning it will process tasks\n * one at a time.\n */\nfunction createQueue() {\n  const PQueue: any = \"default\" in PQueueMod ? PQueueMod.default : PQueueMod;\n  return new PQueue({\n    autoStart: true,\n    concurrency: 1,\n  });\n}\n\nexport function getQueue() {\n  if (typeof queue === \"undefined\") {\n    queue = createQueue();\n  }\n  return queue;\n}\n\n/**\n * Consume a promise, either adding it to the queue or waiting for it to resolve\n * @param promiseFn Promise to consume\n * @param wait Whether to wait for the promise to resolve or resolve immediately\n */\nexport async function consumeCallback<T>(\n  promiseFn: () => Promise<T> | T | void,\n  wait: boolean\n): Promise<void> {\n  if (wait === true) {\n    // Clear config since callbacks are not part of the root run\n    // Avoid using global singleton due to circuluar dependency issues\n    const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n    if (asyncLocalStorageInstance !== undefined) {\n      await asyncLocalStorageInstance.run(undefined, async () => promiseFn());\n    } else {\n      await promiseFn();\n    }\n  } else {\n    queue = getQueue();\n    // oxlint-disable-next-line no-void\n    void queue.add(async () => {\n      const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n      if (asyncLocalStorageInstance !== undefined) {\n        await asyncLocalStorageInstance.run(undefined, async () => promiseFn());\n      } else {\n        await promiseFn();\n      }\n    });\n  }\n}\n\n/**\n * Waits for all promises in the queue to resolve. If the queue is\n * undefined, it immediately resolves a promise.\n */\nexport async function awaitAllCallbacks(): Promise<void> {\n  const defaultClient = getDefaultLangChainClientSingleton();\n  await Promise.allSettled([\n    typeof queue !== \"undefined\" ? queue.onIdle() : Promise.resolve(),\n    defaultClient.awaitPendingTraceBatches(),\n  ]);\n}\n"],"mappings":";;;;AAMA,IAAI;;;;;;AAOJ,SAAS,cAAc;CAErB,OAAO,KADa,aAAa,YAAY,UAAU,UAAU,WAC/C;EAChB,WAAW;EACX,aAAa;CACf,CAAC;AACH;AAEA,SAAgB,WAAW;CACzB,IAAI,OAAO,UAAU,aACnB,QAAQ,YAAY;CAEtB,OAAO;AACT;;;;;;AAOA,eAAsB,gBACpB,WACA,MACe;CACf,IAAI,SAAS,MAAM;EAGjB,MAAM,4BAA4B,mCAAmC;EACrE,IAAI,8BAA8B,KAAA,GAChC,MAAM,0BAA0B,IAAI,KAAA,GAAW,YAAY,UAAU,CAAC;OAEtE,MAAM,UAAU;CAEpB,OAAO;EACL,QAAQ,SAAS;EAEjB,MAAW,IAAI,YAAY;GACzB,MAAM,4BAA4B,mCAAmC;GACrE,IAAI,8BAA8B,KAAA,GAChC,MAAM,0BAA0B,IAAI,KAAA,GAAW,YAAY,UAAU,CAAC;QAEtE,MAAM,UAAU;EAEpB,CAAC;CACH;AACF;;;;;AAMA,eAAsB,oBAAmC;CACvD,MAAM,gBAAgB,mCAAmC;CACzD,MAAM,QAAQ,WAAW,CACvB,OAAO,UAAU,cAAc,MAAM,OAAO,IAAI,QAAQ,QAAQ,GAChE,cAAc,yBAAyB,CACzC,CAAC;AACH"}

package/dist/singletons/tracer.cjs

@@ -1,4 +1,3 @@
-require("../_virtual/_rolldown/runtime.cjs");
 const require_utils_env = require("../utils/env.cjs");
 let langsmith = require("langsmith");
 //#region src/singletons/tracer.ts

package/dist/singletons/tracer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"tracer.cjs","names":["Client","getEnvironmentVariable"],"sources":["../../src/singletons/tracer.ts"],"sourcesContent":["import { Client } from \"langsmith\";\nimport { getEnvironmentVariable } from \"../utils/env.js\";\n\nlet client: Client;\n\nexport const getDefaultLangChainClientSingleton = () => {\n  if (client === undefined) {\n    const clientParams =\n      getEnvironmentVariable(\"LANGCHAIN_CALLBACKS_BACKGROUND\") === \"false\"\n        ? {\n            // LangSmith has its own backgrounding system\n            blockOnRootRunFinalization: true,\n          }\n        : {};\n    client = new Client(clientParams);\n  }\n  return client;\n};\n\nexport const setDefaultLangChainClientSingleton = (newClient: Client) => {\n  client = newClient;\n};\n"],"mappings":";;;;AAGA,IAAI;AAEJ,MAAa,2CAA2C;AACtD,KAAI,WAAW,KAAA,EAQb,UAAS,IAAIA,UAAAA,OANXC,kBAAAA,uBAAuB,iCAAiC,KAAK,UACzD,EAEE,4BAA4B,MAC7B,GACD,EAAE,CACyB;AAEnC,QAAO"}
+{"version":3,"file":"tracer.cjs","names":["Client","getEnvironmentVariable"],"sources":["../../src/singletons/tracer.ts"],"sourcesContent":["import { Client } from \"langsmith\";\nimport { getEnvironmentVariable } from \"../utils/env.js\";\n\nlet client: Client;\n\nexport const getDefaultLangChainClientSingleton = () => {\n  if (client === undefined) {\n    const clientParams =\n      getEnvironmentVariable(\"LANGCHAIN_CALLBACKS_BACKGROUND\") === \"false\"\n        ? {\n            // LangSmith has its own backgrounding system\n            blockOnRootRunFinalization: true,\n          }\n        : {};\n    client = new Client(clientParams);\n  }\n  return client;\n};\n\nexport const setDefaultLangChainClientSingleton = (newClient: Client) => {\n  client = newClient;\n};\n"],"mappings":";;;AAGA,IAAI;AAEJ,MAAa,2CAA2C;CACtD,IAAI,WAAW,KAAA,GAQb,SAAS,IAAIA,UAAAA,OANXC,kBAAAA,uBAAuB,gCAAgC,MAAM,UACzD,EAEE,4BAA4B,KAC9B,IACA,CAAC,CACyB;CAElC,OAAO;AACT"}

package/dist/singletons/tracer.js.map

@@ -1 +1 @@
-{"version":3,"file":"tracer.js","names":[],"sources":["../../src/singletons/tracer.ts"],"sourcesContent":["import { Client } from \"langsmith\";\nimport { getEnvironmentVariable } from \"../utils/env.js\";\n\nlet client: Client;\n\nexport const getDefaultLangChainClientSingleton = () => {\n  if (client === undefined) {\n    const clientParams =\n      getEnvironmentVariable(\"LANGCHAIN_CALLBACKS_BACKGROUND\") === \"false\"\n        ? {\n            // LangSmith has its own backgrounding system\n            blockOnRootRunFinalization: true,\n          }\n        : {};\n    client = new Client(clientParams);\n  }\n  return client;\n};\n\nexport const setDefaultLangChainClientSingleton = (newClient: Client) => {\n  client = newClient;\n};\n"],"mappings":";;;AAGA,IAAI;AAEJ,MAAa,2CAA2C;AACtD,KAAI,WAAW,KAAA,EAQb,UAAS,IAAI,OANX,uBAAuB,iCAAiC,KAAK,UACzD,EAEE,4BAA4B,MAC7B,GACD,EAAE,CACyB;AAEnC,QAAO"}
+{"version":3,"file":"tracer.js","names":[],"sources":["../../src/singletons/tracer.ts"],"sourcesContent":["import { Client } from \"langsmith\";\nimport { getEnvironmentVariable } from \"../utils/env.js\";\n\nlet client: Client;\n\nexport const getDefaultLangChainClientSingleton = () => {\n  if (client === undefined) {\n    const clientParams =\n      getEnvironmentVariable(\"LANGCHAIN_CALLBACKS_BACKGROUND\") === \"false\"\n        ? {\n            // LangSmith has its own backgrounding system\n            blockOnRootRunFinalization: true,\n          }\n        : {};\n    client = new Client(clientParams);\n  }\n  return client;\n};\n\nexport const setDefaultLangChainClientSingleton = (newClient: Client) => {\n  client = newClient;\n};\n"],"mappings":";;;AAGA,IAAI;AAEJ,MAAa,2CAA2C;CACtD,IAAI,WAAW,KAAA,GAQb,SAAS,IAAI,OANX,uBAAuB,gCAAgC,MAAM,UACzD,EAEE,4BAA4B,KAC9B,IACA,CAAC,CACyB;CAElC,OAAO;AACT"}

package/dist/stores.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"stores.cjs","names":["Serializable"],"sources":["../src/stores.ts"],"sourcesContent":["import { Serializable } from \"./load/serializable.js\";\n\n/**\n * Abstract interface for a key-value store.\n */\nexport abstract class BaseStore<K, V> extends Serializable {\n  /**\n   * Abstract method to get multiple values for a set of keys.\n   * @param {K[]} keys - An array of keys.\n   * @returns {Promise<(V | undefined)[]>} - A Promise that resolves with array of values or undefined if key not found.\n   */\n  abstract mget(keys: K[]): Promise<(V | undefined)[]>;\n\n  /**\n   * Abstract method to set a value for multiple keys.\n   * @param {[K, V][]} keyValuePairs - An array of key-value pairs.\n   * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n   */\n  abstract mset(keyValuePairs: [K, V][]): Promise<void>;\n\n  /**\n   * Abstract method to delete multiple keys.\n   * @param {K[]} keys - An array of keys to delete.\n   * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n   */\n  abstract mdelete(keys: K[]): Promise<void>;\n\n  /**\n   * Abstract method to yield keys optionally based on a prefix.\n   * @param {string} prefix - Optional prefix to filter keys.\n   * @returns {AsyncGenerator<K | string>} - An asynchronous generator that yields keys on iteration.\n   */\n  abstract yieldKeys(prefix?: string): AsyncGenerator<K | string>;\n}\n\n/**\n * In-memory implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in memory.\n * @example\n * ```typescript\n * const store = new InMemoryStore<BaseMessage>();\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     index % 2 === 0\n *       ? new AIMessage(\"ai stuff...\")\n *       : new HumanMessage(\"human stuff...\"),\n *   ]),\n * );\n *\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * await store.mdelete(await store.yieldKeys(\"message:id:\").toArray());\n * ```\n */\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport class InMemoryStore<T = any> extends BaseStore<string, T> {\n  lc_namespace = [\"langchain\", \"storage\"];\n\n  protected store: Record<string, T> = {};\n\n  /**\n   * Retrieves the values associated with the given keys from the store.\n   * @param keys Keys to retrieve values for.\n   * @returns Array of values associated with the given keys.\n   */\n  async mget(keys: string[]) {\n    return keys.map((key) => this.store[key]);\n  }\n\n  /**\n   * Sets the values for the given keys in the store.\n   * @param keyValuePairs Array of key-value pairs to set in the store.\n   * @returns Promise that resolves when all key-value pairs have been set.\n   */\n  async mset(keyValuePairs: [string, T][]): Promise<void> {\n    for (const [key, value] of keyValuePairs) {\n      this.store[key] = value;\n    }\n  }\n\n  /**\n   * Deletes the given keys and their associated values from the store.\n   * @param keys Keys to delete from the store.\n   * @returns Promise that resolves when all keys have been deleted.\n   */\n  async mdelete(keys: string[]): Promise<void> {\n    for (const key of keys) {\n      delete this.store[key];\n    }\n  }\n\n  /**\n   * Asynchronous generator that yields keys from the store. If a prefix is\n   * provided, it only yields keys that start with the prefix.\n   * @param prefix Optional prefix to filter keys.\n   * @returns AsyncGenerator that yields keys from the store.\n   */\n  async *yieldKeys(prefix?: string | undefined): AsyncGenerator<string> {\n    const keys = Object.keys(this.store);\n    for (const key of keys) {\n      if (prefix === undefined || key.startsWith(prefix)) {\n        yield key;\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;AAKA,IAAsB,YAAtB,cAA8CA,0BAAAA,aAAa;;;;;;;;;;;;;;;;;;;;AAkD3D,IAAa,gBAAb,cAA4C,UAAqB;CAC/D,eAAe,CAAC,aAAa,UAAU;CAEvC,QAAqC,EAAE;;;;;;CAOvC,MAAM,KAAK,MAAgB;AACzB,SAAO,KAAK,KAAK,QAAQ,KAAK,MAAM,KAAK;;;;;;;CAQ3C,MAAM,KAAK,eAA6C;AACtD,OAAK,MAAM,CAAC,KAAK,UAAU,cACzB,MAAK,MAAM,OAAO;;;;;;;CAStB,MAAM,QAAQ,MAA+B;AAC3C,OAAK,MAAM,OAAO,KAChB,QAAO,KAAK,MAAM;;;;;;;;CAUtB,OAAO,UAAU,QAAqD;EACpE,MAAM,OAAO,OAAO,KAAK,KAAK,MAAM;AACpC,OAAK,MAAM,OAAO,KAChB,KAAI,WAAW,KAAA,KAAa,IAAI,WAAW,OAAO,CAChD,OAAM"}
+{"version":3,"file":"stores.cjs","names":["Serializable"],"sources":["../src/stores.ts"],"sourcesContent":["import { Serializable } from \"./load/serializable.js\";\n\n/**\n * Abstract interface for a key-value store.\n */\nexport abstract class BaseStore<K, V> extends Serializable {\n  /**\n   * Abstract method to get multiple values for a set of keys.\n   * @param {K[]} keys - An array of keys.\n   * @returns {Promise<(V | undefined)[]>} - A Promise that resolves with array of values or undefined if key not found.\n   */\n  abstract mget(keys: K[]): Promise<(V | undefined)[]>;\n\n  /**\n   * Abstract method to set a value for multiple keys.\n   * @param {[K, V][]} keyValuePairs - An array of key-value pairs.\n   * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n   */\n  abstract mset(keyValuePairs: [K, V][]): Promise<void>;\n\n  /**\n   * Abstract method to delete multiple keys.\n   * @param {K[]} keys - An array of keys to delete.\n   * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n   */\n  abstract mdelete(keys: K[]): Promise<void>;\n\n  /**\n   * Abstract method to yield keys optionally based on a prefix.\n   * @param {string} prefix - Optional prefix to filter keys.\n   * @returns {AsyncGenerator<K | string>} - An asynchronous generator that yields keys on iteration.\n   */\n  abstract yieldKeys(prefix?: string): AsyncGenerator<K | string>;\n}\n\n/**\n * In-memory implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in memory.\n * @example\n * ```typescript\n * const store = new InMemoryStore<BaseMessage>();\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     index % 2 === 0\n *       ? new AIMessage(\"ai stuff...\")\n *       : new HumanMessage(\"human stuff...\"),\n *   ]),\n * );\n *\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * await store.mdelete(await store.yieldKeys(\"message:id:\").toArray());\n * ```\n */\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport class InMemoryStore<T = any> extends BaseStore<string, T> {\n  lc_namespace = [\"langchain\", \"storage\"];\n\n  protected store: Record<string, T> = {};\n\n  /**\n   * Retrieves the values associated with the given keys from the store.\n   * @param keys Keys to retrieve values for.\n   * @returns Array of values associated with the given keys.\n   */\n  async mget(keys: string[]) {\n    return keys.map((key) => this.store[key]);\n  }\n\n  /**\n   * Sets the values for the given keys in the store.\n   * @param keyValuePairs Array of key-value pairs to set in the store.\n   * @returns Promise that resolves when all key-value pairs have been set.\n   */\n  async mset(keyValuePairs: [string, T][]): Promise<void> {\n    for (const [key, value] of keyValuePairs) {\n      this.store[key] = value;\n    }\n  }\n\n  /**\n   * Deletes the given keys and their associated values from the store.\n   * @param keys Keys to delete from the store.\n   * @returns Promise that resolves when all keys have been deleted.\n   */\n  async mdelete(keys: string[]): Promise<void> {\n    for (const key of keys) {\n      delete this.store[key];\n    }\n  }\n\n  /**\n   * Asynchronous generator that yields keys from the store. If a prefix is\n   * provided, it only yields keys that start with the prefix.\n   * @param prefix Optional prefix to filter keys.\n   * @returns AsyncGenerator that yields keys from the store.\n   */\n  async *yieldKeys(prefix?: string | undefined): AsyncGenerator<string> {\n    const keys = Object.keys(this.store);\n    for (const key of keys) {\n      if (prefix === undefined || key.startsWith(prefix)) {\n        yield key;\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;AAKA,IAAsB,YAAtB,cAA8CA,0BAAAA,aAAa,CA4B3D;;;;;;;;;;;;;;;;;;;;AAsBA,IAAa,gBAAb,cAA4C,UAAqB;CAC/D,eAAe,CAAC,aAAa,SAAS;CAEtC,QAAqC,CAAC;;;;;;CAOtC,MAAM,KAAK,MAAgB;EACzB,OAAO,KAAK,KAAK,QAAQ,KAAK,MAAM,IAAI;CAC1C;;;;;;CAOA,MAAM,KAAK,eAA6C;EACtD,KAAK,MAAM,CAAC,KAAK,UAAU,eACzB,KAAK,MAAM,OAAO;CAEtB;;;;;;CAOA,MAAM,QAAQ,MAA+B;EAC3C,KAAK,MAAM,OAAO,MAChB,OAAO,KAAK,MAAM;CAEtB;;;;;;;CAQA,OAAO,UAAU,QAAqD;EACpE,MAAM,OAAO,OAAO,KAAK,KAAK,KAAK;EACnC,KAAK,MAAM,OAAO,MAChB,IAAI,WAAW,KAAA,KAAa,IAAI,WAAW,MAAM,GAC/C,MAAM;CAGZ;AACF"}

package/dist/stores.d.cts

@@ -1,5 +1,4 @@
 import { Serializable } from "./load/serializable.cjs";
-
 //#region src/stores.d.ts
 /**
  * Abstract interface for a key-value store.

package/dist/stores.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"stores.d.cts","names":[],"sources":["../src/stores.ts"],"mappings":";;;;;AAKA;uBAAsB,SAAA,eAAwB,YAAA;EAAf;;;;;EAAA,SAMpB,IAAA,CAAK,IAAA,EAAM,CAAA,KAAM,OAAA,EAAS,CAAA;EAOK;;;;;EAAA,SAA/B,IAAA,CAAK,aAAA,GAAgB,CAAA,EAAG,CAAA,MAAO,OAAA;EAbgB;;;;;EAAA,SAoB/C,OAAA,CAAQ,IAAA,EAAM,CAAA,KAAM,OAAA;EAdT;;;;;EAAA,SAqBX,SAAA,CAAU,MAAA,YAAkB,cAAA,CAAe,CAAA;AAAA;;;;;;;;;;;;;AAuBtD;;;;;;;cAAa,aAAA,kBAA+B,SAAA,SAAkB,CAAA;EAC5D,YAAA;EAAA,UAEU,KAAA,EAAO,MAAA,SAAe,CAAA;EA2BD;;;;;EApBzB,IAAA,CAAK,IAAA,aAAc,OAAA,CAAA,CAAA;EAViB;;;;;EAmBpC,IAAA,CAAK,aAAA,WAAwB,CAAA,MAAO,OAAA;EATpC;;;;;EAoBA,OAAA,CAAQ,IAAA,aAAiB,OAAA;EAXpB;;;;;;EAuBJ,SAAA,CAAU,MAAA,wBAA8B,cAAA;AAAA"}
+{"version":3,"file":"stores.d.cts","names":[],"sources":["../src/stores.ts"],"mappings":";;;;;uBAKsB,UAAU,GAAG,WAAW;;;;;;WAMnC,KAAK,MAAM,MAAM,SAAS;;;;;;WAO1B,KAAK,gBAAgB,GAAG,OAAO;;;;;;WAO/B,QAAQ,MAAM,MAAM;;;;;;WAOpB,UAAU,kBAAkB,eAAe;;;;;;;;;;;;;;;;;;;;;cAuBzC,cAAc,iBAAiB,kBAAkB;EAC5D;YAEU,OAAO,eAAe;;;;;;EAO1B,KAAK,iBAAc,QAAA;;;;;;EASnB,KAAK,wBAAwB,OAAO;;;;;;EAWpC,QAAQ,iBAAiB;;;;;;;EAYxB,UAAU,8BAA8B"}

package/dist/stores.d.ts

@@ -1,5 +1,4 @@
 import { Serializable } from "./load/serializable.js";
-
 //#region src/stores.d.ts
 /**
  * Abstract interface for a key-value store.

package/dist/stores.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stores.d.ts","names":[],"sources":["../src/stores.ts"],"mappings":";;;;;AAKA;uBAAsB,SAAA,eAAwB,YAAA;EAAf;;;;;EAAA,SAMpB,IAAA,CAAK,IAAA,EAAM,CAAA,KAAM,OAAA,EAAS,CAAA;EAOK;;;;;EAAA,SAA/B,IAAA,CAAK,aAAA,GAAgB,CAAA,EAAG,CAAA,MAAO,OAAA;EAbgB;;;;;EAAA,SAoB/C,OAAA,CAAQ,IAAA,EAAM,CAAA,KAAM,OAAA;EAdT;;;;;EAAA,SAqBX,SAAA,CAAU,MAAA,YAAkB,cAAA,CAAe,CAAA;AAAA;;;;;;;;;;;;;AAuBtD;;;;;;;cAAa,aAAA,kBAA+B,SAAA,SAAkB,CAAA;EAC5D,YAAA;EAAA,UAEU,KAAA,EAAO,MAAA,SAAe,CAAA;EA2BD;;;;;EApBzB,IAAA,CAAK,IAAA,aAAc,OAAA,CAAA,CAAA;EAViB;;;;;EAmBpC,IAAA,CAAK,aAAA,WAAwB,CAAA,MAAO,OAAA;EATpC;;;;;EAoBA,OAAA,CAAQ,IAAA,aAAiB,OAAA;EAXpB;;;;;;EAuBJ,SAAA,CAAU,MAAA,wBAA8B,cAAA;AAAA"}
+{"version":3,"file":"stores.d.ts","names":[],"sources":["../src/stores.ts"],"mappings":";;;;;uBAKsB,UAAU,GAAG,WAAW;;;;;;WAMnC,KAAK,MAAM,MAAM,SAAS;;;;;;WAO1B,KAAK,gBAAgB,GAAG,OAAO;;;;;;WAO/B,QAAQ,MAAM,MAAM;;;;;;WAOpB,UAAU,kBAAkB,eAAe;;;;;;;;;;;;;;;;;;;;;cAuBzC,cAAc,iBAAiB,kBAAkB;EAC5D;YAEU,OAAO,eAAe;;;;;;EAO1B,KAAK,iBAAc,QAAA;;;;;;EASnB,KAAK,wBAAwB,OAAO;;;;;;EAWpC,QAAQ,iBAAiB;;;;;;;EAYxB,UAAU,8BAA8B"}

package/dist/stores.js.map

@@ -1 +1 @@
-{"version":3,"file":"stores.js","names":[],"sources":["../src/stores.ts"],"sourcesContent":["import { Serializable } from \"./load/serializable.js\";\n\n/**\n * Abstract interface for a key-value store.\n */\nexport abstract class BaseStore<K, V> extends Serializable {\n  /**\n   * Abstract method to get multiple values for a set of keys.\n   * @param {K[]} keys - An array of keys.\n   * @returns {Promise<(V | undefined)[]>} - A Promise that resolves with array of values or undefined if key not found.\n   */\n  abstract mget(keys: K[]): Promise<(V | undefined)[]>;\n\n  /**\n   * Abstract method to set a value for multiple keys.\n   * @param {[K, V][]} keyValuePairs - An array of key-value pairs.\n   * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n   */\n  abstract mset(keyValuePairs: [K, V][]): Promise<void>;\n\n  /**\n   * Abstract method to delete multiple keys.\n   * @param {K[]} keys - An array of keys to delete.\n   * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n   */\n  abstract mdelete(keys: K[]): Promise<void>;\n\n  /**\n   * Abstract method to yield keys optionally based on a prefix.\n   * @param {string} prefix - Optional prefix to filter keys.\n   * @returns {AsyncGenerator<K | string>} - An asynchronous generator that yields keys on iteration.\n   */\n  abstract yieldKeys(prefix?: string): AsyncGenerator<K | string>;\n}\n\n/**\n * In-memory implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in memory.\n * @example\n * ```typescript\n * const store = new InMemoryStore<BaseMessage>();\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     index % 2 === 0\n *       ? new AIMessage(\"ai stuff...\")\n *       : new HumanMessage(\"human stuff...\"),\n *   ]),\n * );\n *\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * await store.mdelete(await store.yieldKeys(\"message:id:\").toArray());\n * ```\n */\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport class InMemoryStore<T = any> extends BaseStore<string, T> {\n  lc_namespace = [\"langchain\", \"storage\"];\n\n  protected store: Record<string, T> = {};\n\n  /**\n   * Retrieves the values associated with the given keys from the store.\n   * @param keys Keys to retrieve values for.\n   * @returns Array of values associated with the given keys.\n   */\n  async mget(keys: string[]) {\n    return keys.map((key) => this.store[key]);\n  }\n\n  /**\n   * Sets the values for the given keys in the store.\n   * @param keyValuePairs Array of key-value pairs to set in the store.\n   * @returns Promise that resolves when all key-value pairs have been set.\n   */\n  async mset(keyValuePairs: [string, T][]): Promise<void> {\n    for (const [key, value] of keyValuePairs) {\n      this.store[key] = value;\n    }\n  }\n\n  /**\n   * Deletes the given keys and their associated values from the store.\n   * @param keys Keys to delete from the store.\n   * @returns Promise that resolves when all keys have been deleted.\n   */\n  async mdelete(keys: string[]): Promise<void> {\n    for (const key of keys) {\n      delete this.store[key];\n    }\n  }\n\n  /**\n   * Asynchronous generator that yields keys from the store. If a prefix is\n   * provided, it only yields keys that start with the prefix.\n   * @param prefix Optional prefix to filter keys.\n   * @returns AsyncGenerator that yields keys from the store.\n   */\n  async *yieldKeys(prefix?: string | undefined): AsyncGenerator<string> {\n    const keys = Object.keys(this.store);\n    for (const key of keys) {\n      if (prefix === undefined || key.startsWith(prefix)) {\n        yield key;\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;AAKA,IAAsB,YAAtB,cAA8C,aAAa;;;;;;;;;;;;;;;;;;;;AAkD3D,IAAa,gBAAb,cAA4C,UAAqB;CAC/D,eAAe,CAAC,aAAa,UAAU;CAEvC,QAAqC,EAAE;;;;;;CAOvC,MAAM,KAAK,MAAgB;AACzB,SAAO,KAAK,KAAK,QAAQ,KAAK,MAAM,KAAK;;;;;;;CAQ3C,MAAM,KAAK,eAA6C;AACtD,OAAK,MAAM,CAAC,KAAK,UAAU,cACzB,MAAK,MAAM,OAAO;;;;;;;CAStB,MAAM,QAAQ,MAA+B;AAC3C,OAAK,MAAM,OAAO,KAChB,QAAO,KAAK,MAAM;;;;;;;;CAUtB,OAAO,UAAU,QAAqD;EACpE,MAAM,OAAO,OAAO,KAAK,KAAK,MAAM;AACpC,OAAK,MAAM,OAAO,KAChB,KAAI,WAAW,KAAA,KAAa,IAAI,WAAW,OAAO,CAChD,OAAM"}
+{"version":3,"file":"stores.js","names":[],"sources":["../src/stores.ts"],"sourcesContent":["import { Serializable } from \"./load/serializable.js\";\n\n/**\n * Abstract interface for a key-value store.\n */\nexport abstract class BaseStore<K, V> extends Serializable {\n  /**\n   * Abstract method to get multiple values for a set of keys.\n   * @param {K[]} keys - An array of keys.\n   * @returns {Promise<(V | undefined)[]>} - A Promise that resolves with array of values or undefined if key not found.\n   */\n  abstract mget(keys: K[]): Promise<(V | undefined)[]>;\n\n  /**\n   * Abstract method to set a value for multiple keys.\n   * @param {[K, V][]} keyValuePairs - An array of key-value pairs.\n   * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n   */\n  abstract mset(keyValuePairs: [K, V][]): Promise<void>;\n\n  /**\n   * Abstract method to delete multiple keys.\n   * @param {K[]} keys - An array of keys to delete.\n   * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n   */\n  abstract mdelete(keys: K[]): Promise<void>;\n\n  /**\n   * Abstract method to yield keys optionally based on a prefix.\n   * @param {string} prefix - Optional prefix to filter keys.\n   * @returns {AsyncGenerator<K | string>} - An asynchronous generator that yields keys on iteration.\n   */\n  abstract yieldKeys(prefix?: string): AsyncGenerator<K | string>;\n}\n\n/**\n * In-memory implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in memory.\n * @example\n * ```typescript\n * const store = new InMemoryStore<BaseMessage>();\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     index % 2 === 0\n *       ? new AIMessage(\"ai stuff...\")\n *       : new HumanMessage(\"human stuff...\"),\n *   ]),\n * );\n *\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * await store.mdelete(await store.yieldKeys(\"message:id:\").toArray());\n * ```\n */\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport class InMemoryStore<T = any> extends BaseStore<string, T> {\n  lc_namespace = [\"langchain\", \"storage\"];\n\n  protected store: Record<string, T> = {};\n\n  /**\n   * Retrieves the values associated with the given keys from the store.\n   * @param keys Keys to retrieve values for.\n   * @returns Array of values associated with the given keys.\n   */\n  async mget(keys: string[]) {\n    return keys.map((key) => this.store[key]);\n  }\n\n  /**\n   * Sets the values for the given keys in the store.\n   * @param keyValuePairs Array of key-value pairs to set in the store.\n   * @returns Promise that resolves when all key-value pairs have been set.\n   */\n  async mset(keyValuePairs: [string, T][]): Promise<void> {\n    for (const [key, value] of keyValuePairs) {\n      this.store[key] = value;\n    }\n  }\n\n  /**\n   * Deletes the given keys and their associated values from the store.\n   * @param keys Keys to delete from the store.\n   * @returns Promise that resolves when all keys have been deleted.\n   */\n  async mdelete(keys: string[]): Promise<void> {\n    for (const key of keys) {\n      delete this.store[key];\n    }\n  }\n\n  /**\n   * Asynchronous generator that yields keys from the store. If a prefix is\n   * provided, it only yields keys that start with the prefix.\n   * @param prefix Optional prefix to filter keys.\n   * @returns AsyncGenerator that yields keys from the store.\n   */\n  async *yieldKeys(prefix?: string | undefined): AsyncGenerator<string> {\n    const keys = Object.keys(this.store);\n    for (const key of keys) {\n      if (prefix === undefined || key.startsWith(prefix)) {\n        yield key;\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;AAKA,IAAsB,YAAtB,cAA8C,aAAa,CA4B3D;;;;;;;;;;;;;;;;;;;;AAsBA,IAAa,gBAAb,cAA4C,UAAqB;CAC/D,eAAe,CAAC,aAAa,SAAS;CAEtC,QAAqC,CAAC;;;;;;CAOtC,MAAM,KAAK,MAAgB;EACzB,OAAO,KAAK,KAAK,QAAQ,KAAK,MAAM,IAAI;CAC1C;;;;;;CAOA,MAAM,KAAK,eAA6C;EACtD,KAAK,MAAM,CAAC,KAAK,UAAU,eACzB,KAAK,MAAM,OAAO;CAEtB;;;;;;CAOA,MAAM,QAAQ,MAA+B;EAC3C,KAAK,MAAM,OAAO,MAChB,OAAO,KAAK,MAAM;CAEtB;;;;;;;CAQA,OAAO,UAAU,QAAqD;EACpE,MAAM,OAAO,OAAO,KAAK,KAAK,KAAK;EACnC,KAAK,MAAM,OAAO,MAChB,IAAI,WAAW,KAAA,KAAa,IAAI,WAAW,MAAM,GAC/C,MAAM;CAGZ;AACF"}