@langchain/core 1.2.14 → 1.2.16

package/dist/language_models/stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream.d.ts","names":[],"sources":["../../src/language_models/stream.ts"],"mappings":";;;;;;;;;;;;;cAqBM;UACI;UACA;UACA;UACA;EAER,KAAK,OAAO;EAQZ;EAQA,SAAS,KAAK;EASP,WAAW,eAAe;;;;;;;;;cAiNtB,6BACA,uBAAuB;;UAG1B;;EAGR,YAAY,QAAQ;;MAKhB,QAAQ;;GAiBX,OAAO,kBAAkB;EAa1B,KAAK,mBAAmB,kBACtB,gBAAgB,kBAAkB,WAAW,YAAY,mBACzD,eAAe,oBAAoB,WAAW,YAAY,oBACzD,YAAY,WAAW;;;;;;;;;cAqBf,2BAET,cAAc,aAAa,MAAM,WACjC,YAAY,MAAM,aAAa,MAAM;;UAG/B;;EAGR,YAAY,QAAQ;MAIhB,QAAQ,cAAc,MAAM,aAAa,MAAM;GAkBlD,OAAO,kBAAkB,cAAc,aAAa,MAAM;EAe3D,KAAK,WAAW,MAAM,aAAa,MAAM,WAAW,kBAClD,gBAEM,OAAO,MAAM,aAAa,MAAM,cAC7B,WAAW,YAAY,mBAEhC,eAAe,oBAAoB,WAAW,YAAY,oBACzD,YAAY,WAAW;;;;;;cAkBf,kCACA,uBAAuB;;UAG1B;;EAGR,YAAY,QAAQ;MAIhB,QAAQ;GAsCX,OAAO,kBAAkB;EAgC1B,KAAK,mBAAmB,kBACtB,gBAAgB,kBAAkB,WAAW,YAAY,mBACzD,eAAe,oBAAoB,WAAW,YAAY,oBACzD,YAAY,WAAW;;;;;cAiBf,+BAET,cAAc,gBACd,YAAY;;UAGN;;EAGR,YAAY,QAAQ;GAInB,OAAO,kBAAkB,cAAc;EAmBxC,KAAK,WAAW,2BAA2B,kBACzC,gBACM,OAAO,8BAA8B,WAAW,YAAY,mBAElE,eAAe,oBAAoB,WAAW,YAAY,oBACzD,YAAY,WAAW;;;;;;;;cAoBf,2BACA,cAAc,uBAAuB,YAAY;;UAGpD;;EAGR,YAAY,QAAQ,cAAc;;UAMpB;GAeb,OAAO,kBAAkB,cAAc;MAIpC,QAAQ;MAIR,aAAa;MAIb,aAAa;MAIb,SAAS;MAIT,UAAU,YAAY;EAI1B,KAAK,WAAW,WAAW,kBACzB,gBACM,OAAO,cAAc,WAAW,YAAY,mBAElD,eAAe,oBAAoB,WAAW,YAAY,oBACzD,YAAY,WAAW;;UAKZ"}
+{"version":3,"file":"stream.d.ts","names":[],"sources":["../../src/language_models/stream.ts"],"mappings":";;;;;;;;;;;;;cAqBM;UACI;UACA;UACA;UACA;EAER,KAAK,OAAO;EAQZ;EAQA,SAAS,KAAK;EASP,WAAW,eAAe;;;;;;;;;qBAiNtB,6BACA,uBAAuB;;UAG1B;;EAGR,YAAY,QAAQ;;MAKhB,QAAQ;;GAiBX,OAAO,kBAAkB;EAa1B,KAAK,mBAAmB,kBACtB,gBAAgB,kBAAkB,WAAW,YAAY,mBACzD,eAAe,oBAAoB,WAAW,YAAY,oBACzD,YAAY,WAAW;;;;;;;;;qBAqBf,2BAET,cAAc,aAAa,MAAM,WACjC,YAAY,MAAM,aAAa,MAAM;;UAG/B;;EAGR,YAAY,QAAQ;MAIhB,QAAQ,cAAc,MAAM,aAAa,MAAM;GAkBlD,OAAO,kBAAkB,cAAc,aAAa,MAAM;EAe3D,KAAK,WAAW,MAAM,aAAa,MAAM,WAAW,kBAClD,gBAEM,OAAO,MAAM,aAAa,MAAM,cAC7B,WAAW,YAAY,mBAEhC,eAAe,oBAAoB,WAAW,YAAY,oBACzD,YAAY,WAAW;;;;;;qBAkBf,kCACA,uBAAuB;;UAG1B;;EAGR,YAAY,QAAQ;MAIhB,QAAQ;GAsCX,OAAO,kBAAkB;EAgC1B,KAAK,mBAAmB,kBACtB,gBAAgB,kBAAkB,WAAW,YAAY,mBACzD,eAAe,oBAAoB,WAAW,YAAY,oBACzD,YAAY,WAAW;;;;;qBAiBf,+BAET,cAAc,gBACd,YAAY;;UAGN;;EAGR,YAAY,QAAQ;GAInB,OAAO,kBAAkB,cAAc;EAmBxC,KAAK,WAAW,2BAA2B,kBACzC,gBACM,OAAO,8BAA8B,WAAW,YAAY,mBAElE,eAAe,oBAAoB,WAAW,YAAY,oBACzD,YAAY,WAAW;;;;;;;;qBAoBf,2BACA,cAAc,uBAAuB,YAAY;;UAGpD;;EAGR,YAAY,QAAQ,cAAc;;UAMpB;GAeb,OAAO,kBAAkB,cAAc;MAIpC,QAAQ;MAIR,aAAa;MAIb,aAAa;MAIb,SAAS;MAIT,UAAU,YAAY;EAI1B,KAAK,WAAW,WAAW,kBACzB,gBACM,OAAO,cAAc,WAAW,YAAY,mBAElD,eAAe,oBAAoB,WAAW,YAAY,oBACzD,YAAY,WAAW;;UAKZ"}

package/dist/language_models/structured_output.d.cts

@@ -17,7 +17,7 @@ import "../output_parsers/index.cjs";
  * - Standard schema -> StandardSchemaOutputParser (standard schema validation)
  * - Plain JSON schema -> JsonOutputParser (no validation)
  */
-declare function createContentParser<RunOutput extends Record<string, any> = Record<string, any>>(schema: InteropZodType<RunOutput> | SerializableSchema<RunOutput> | Record<string, any>): BaseOutputParser<RunOutput>;
+export declare function createContentParser<RunOutput extends Record<string, any> = Record<string, any>>(schema: InteropZodType<RunOutput> | SerializableSchema<RunOutput> | Record<string, any>): BaseOutputParser<RunOutput>;
 type FunctionCallingParserConstructor<T extends Record<string, any> = Record<string, any>> = new (params: {
   keyName: string;
   returnSingle?: boolean;
@@ -32,7 +32,7 @@ type FunctionCallingParserConstructor<T extends Record<string, any> = Record<str
  * - Standard schema -> parser with standard schema validation
  * - Plain JSON schema -> parser with no validation
  */
-declare function createFunctionCallingParser<RunOutput extends Record<string, any> = Record<string, any>>(schema: InteropZodType<RunOutput> | SerializableSchema<RunOutput> | Record<string, any>, keyName: string, ParserClass?: FunctionCallingParserConstructor<RunOutput>): BaseLLMOutputParser<RunOutput>;
+export declare function createFunctionCallingParser<RunOutput extends Record<string, any> = Record<string, any>>(schema: InteropZodType<RunOutput> | SerializableSchema<RunOutput> | Record<string, any>, keyName: string, ParserClass?: FunctionCallingParserConstructor<RunOutput>): BaseLLMOutputParser<RunOutput>;
 /**
  * Pipes an LLM through an output parser, optionally wrapping the result
  * to include the raw LLM response alongside the parsed output.
@@ -40,10 +40,9 @@ declare function createFunctionCallingParser<RunOutput extends Record<string, an
  * When `includeRaw` is true, returns `{ raw: BaseMessage, parsed: RunOutput }`.
  * If parsing fails, `parsed` falls back to null.
  */
-declare function assembleStructuredOutputPipeline<RunOutput extends Record<string, any> = Record<string, any>>(llm: Runnable<BaseLanguageModelInput>, outputParser: Runnable<any, RunOutput>, includeRaw?: boolean, runName?: string): Runnable<BaseLanguageModelInput, RunOutput> | Runnable<BaseLanguageModelInput, {
+export declare function assembleStructuredOutputPipeline<RunOutput extends Record<string, any> = Record<string, any>>(llm: Runnable<BaseLanguageModelInput>, outputParser: Runnable<any, RunOutput>, includeRaw?: boolean, runName?: string): Runnable<BaseLanguageModelInput, RunOutput> | Runnable<BaseLanguageModelInput, {
   raw: BaseMessage;
   parsed: RunOutput;
 }>;
 //#endregion
-export { assembleStructuredOutputPipeline, createContentParser, createFunctionCallingParser };
 //# sourceMappingURL=structured_output.d.cts.map

package/dist/language_models/structured_output.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"structured_output.d.cts","names":[],"sources":["../../src/language_models/structured_output.ts"],"mappings":";;;;;;;;;;;;;;;;;;;iBA6BgB,oBAEd,kBAAkB,sBAAsB,qBAExC,QACI,eAAe,aACf,mBAAmB,aAEnB,sBACH,iBAAiB;KAUf,iCAEH,UAAU,sBAAsB,4BACzB;EACP;EACA;EACA,YAAY,eAAe;EAC3B,qBAAqB,mBAAmB;MACpC,oBAAoB;;;;;;;;;iBAUV,4BAEd,kBAAkB,sBAAsB,qBAExC,QACI,eAAe,aACf,mBAAmB,aAEnB,qBACJ,iBACA,cAAc,iCAAiC,aAC9C,oBAAoB;;;;;;;;iBAsBP,iCAEd,kBAAkB,sBAAsB,qBAExC,KAAK,SAAS,yBAEd,cAAc,cAAc,YAC5B,sBACA,mBAEE,SAAS,wBAAwB,aACjC,SAAS;EAA0B,KAAK;EAAa,QAAQ"}
+{"version":3,"file":"structured_output.d.cts","names":[],"sources":["../../src/language_models/structured_output.ts"],"mappings":";;;;;;;;;;;;;;;;;;;wBA6BgB,oBAEd,kBAAkB,sBAAsB,qBAExC,QACI,eAAe,aACf,mBAAmB,aAEnB,sBACH,iBAAiB;KAUf,iCAEH,UAAU,sBAAsB,4BACzB;EACP;EACA;EACA,YAAY,eAAe;EAC3B,qBAAqB,mBAAmB;MACpC,oBAAoB;;;;;;;;;wBAUV,4BAEd,kBAAkB,sBAAsB,qBAExC,QACI,eAAe,aACf,mBAAmB,aAEnB,qBACJ,iBACA,cAAc,iCAAiC,aAC9C,oBAAoB;;;;;;;;wBAsBP,iCAEd,kBAAkB,sBAAsB,qBAExC,KAAK,SAAS,yBAEd,cAAc,cAAc,YAC5B,sBACA,mBAEE,SAAS,wBAAwB,aACjC,SAAS;EAA0B,KAAK;EAAa,QAAQ"}

package/dist/language_models/structured_output.d.ts

@@ -17,7 +17,7 @@ import "../output_parsers/index.js";
  * - Standard schema -> StandardSchemaOutputParser (standard schema validation)
  * - Plain JSON schema -> JsonOutputParser (no validation)
  */
-declare function createContentParser<RunOutput extends Record<string, any> = Record<string, any>>(schema: InteropZodType<RunOutput> | SerializableSchema<RunOutput> | Record<string, any>): BaseOutputParser<RunOutput>;
+export declare function createContentParser<RunOutput extends Record<string, any> = Record<string, any>>(schema: InteropZodType<RunOutput> | SerializableSchema<RunOutput> | Record<string, any>): BaseOutputParser<RunOutput>;
 type FunctionCallingParserConstructor<T extends Record<string, any> = Record<string, any>> = new (params: {
   keyName: string;
   returnSingle?: boolean;
@@ -32,7 +32,7 @@ type FunctionCallingParserConstructor<T extends Record<string, any> = Record<str
  * - Standard schema -> parser with standard schema validation
  * - Plain JSON schema -> parser with no validation
  */
-declare function createFunctionCallingParser<RunOutput extends Record<string, any> = Record<string, any>>(schema: InteropZodType<RunOutput> | SerializableSchema<RunOutput> | Record<string, any>, keyName: string, ParserClass?: FunctionCallingParserConstructor<RunOutput>): BaseLLMOutputParser<RunOutput>;
+export declare function createFunctionCallingParser<RunOutput extends Record<string, any> = Record<string, any>>(schema: InteropZodType<RunOutput> | SerializableSchema<RunOutput> | Record<string, any>, keyName: string, ParserClass?: FunctionCallingParserConstructor<RunOutput>): BaseLLMOutputParser<RunOutput>;
 /**
  * Pipes an LLM through an output parser, optionally wrapping the result
  * to include the raw LLM response alongside the parsed output.
@@ -40,10 +40,9 @@ declare function createFunctionCallingParser<RunOutput extends Record<string, an
  * When `includeRaw` is true, returns `{ raw: BaseMessage, parsed: RunOutput }`.
  * If parsing fails, `parsed` falls back to null.
  */
-declare function assembleStructuredOutputPipeline<RunOutput extends Record<string, any> = Record<string, any>>(llm: Runnable<BaseLanguageModelInput>, outputParser: Runnable<any, RunOutput>, includeRaw?: boolean, runName?: string): Runnable<BaseLanguageModelInput, RunOutput> | Runnable<BaseLanguageModelInput, {
+export declare function assembleStructuredOutputPipeline<RunOutput extends Record<string, any> = Record<string, any>>(llm: Runnable<BaseLanguageModelInput>, outputParser: Runnable<any, RunOutput>, includeRaw?: boolean, runName?: string): Runnable<BaseLanguageModelInput, RunOutput> | Runnable<BaseLanguageModelInput, {
   raw: BaseMessage;
   parsed: RunOutput;
 }>;
 //#endregion
-export { assembleStructuredOutputPipeline, createContentParser, createFunctionCallingParser };
 //# sourceMappingURL=structured_output.d.ts.map

package/dist/language_models/structured_output.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"structured_output.d.ts","names":[],"sources":["../../src/language_models/structured_output.ts"],"mappings":";;;;;;;;;;;;;;;;;;;iBA6BgB,oBAEd,kBAAkB,sBAAsB,qBAExC,QACI,eAAe,aACf,mBAAmB,aAEnB,sBACH,iBAAiB;KAUf,iCAEH,UAAU,sBAAsB,4BACzB;EACP;EACA;EACA,YAAY,eAAe;EAC3B,qBAAqB,mBAAmB;MACpC,oBAAoB;;;;;;;;;iBAUV,4BAEd,kBAAkB,sBAAsB,qBAExC,QACI,eAAe,aACf,mBAAmB,aAEnB,qBACJ,iBACA,cAAc,iCAAiC,aAC9C,oBAAoB;;;;;;;;iBAsBP,iCAEd,kBAAkB,sBAAsB,qBAExC,KAAK,SAAS,yBAEd,cAAc,cAAc,YAC5B,sBACA,mBAEE,SAAS,wBAAwB,aACjC,SAAS;EAA0B,KAAK;EAAa,QAAQ"}
+{"version":3,"file":"structured_output.d.ts","names":[],"sources":["../../src/language_models/structured_output.ts"],"mappings":";;;;;;;;;;;;;;;;;;;wBA6BgB,oBAEd,kBAAkB,sBAAsB,qBAExC,QACI,eAAe,aACf,mBAAmB,aAEnB,sBACH,iBAAiB;KAUf,iCAEH,UAAU,sBAAsB,4BACzB;EACP;EACA;EACA,YAAY,eAAe;EAC3B,qBAAqB,mBAAmB;MACpC,oBAAoB;;;;;;;;;wBAUV,4BAEd,kBAAkB,sBAAsB,qBAExC,QACI,eAAe,aACf,mBAAmB,aAEnB,qBACJ,iBACA,cAAc,iCAAiC,aAC9C,oBAAoB;;;;;;;;wBAsBP,iCAEd,kBAAkB,sBAAsB,qBAExC,KAAK,SAAS,yBAEd,cAAc,cAAc,YAC5B,sBACA,mBAEE,SAAS,wBAAwB,aACjC,SAAS;EAA0B,KAAK;EAAa,QAAQ"}

package/dist/load/import_type.d.cts

@@ -1,6 +1,5 @@
 //#region src/load/import_type.d.ts
-interface OptionalImportMap {}
-interface SecretMap {}
+export interface OptionalImportMap {}
+export interface SecretMap {}
 //#endregion
-export { OptionalImportMap, SecretMap };
 //# sourceMappingURL=import_type.d.cts.map

package/dist/load/import_type.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"import_type.d.cts","names":[],"sources":["../../src/load/import_type.ts"],"mappings":";UAEiB;UAEA"}
+{"version":3,"file":"import_type.d.cts","names":[],"sources":["../../src/load/import_type.ts"],"mappings":";iBAEiB;iBAEA"}

package/dist/load/import_type.d.ts

@@ -1,6 +1,5 @@
 //#region src/load/import_type.d.ts
-interface OptionalImportMap {}
-interface SecretMap {}
+export interface OptionalImportMap {}
+export interface SecretMap {}
 //#endregion
-export { OptionalImportMap, SecretMap };
 //# sourceMappingURL=import_type.d.ts.map

package/dist/load/import_type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"import_type.d.ts","names":[],"sources":["../../src/load/import_type.ts"],"mappings":";UAEiB;UAEA"}
+{"version":3,"file":"import_type.d.ts","names":[],"sources":["../../src/load/import_type.ts"],"mappings":";iBAEiB;iBAEA"}

package/dist/load/index.d.cts

@@ -21,7 +21,7 @@ import { OptionalImportMap, SecretMap } from "./import_type.cjs";
  *    with the deserialized kwargs. If a class performs side effects in its
  *    constructor (network calls, file I/O, etc.), those will execute.
  */
-interface LoadOptions {
+export interface LoadOptions {
   /**
    * A map of secrets to load. Keys are secret identifiers, values are the secret values.
    *
@@ -128,7 +128,6 @@ interface LoadOptions {
  * });
  * ```
  */
-declare function load<T>(text: string, options?: LoadOptions): Promise<T>;
+export declare function load<T>(text: string, options?: LoadOptions): Promise<T>;
 //#endregion
-export { LoadOptions, load };
 //# sourceMappingURL=index.d.cts.map

package/dist/load/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/load/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;UAuGiB;;;;;;;;EAQf,aAAa;;;;;;;;;;;;EAab;;;;;;;;;;;;;EAcA,qBAAqB;;;;;;;;;EAUrB;;;;;;;;;;;;EAaA,YAAY;;;;;;;;;;;EAYZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6SoB,KAAK,GAAG,cAAc,UAAU,cAAc,QAAQ"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/load/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;iBAuGiB;;;;;;;;EAQf,aAAa;;;;;;;;;;;;EAab;;;;;;;;;;;;;EAcA,qBAAqB;;;;;;;;;EAUrB;;;;;;;;;;;;EAaA,YAAY;;;;;;;;;;;EAYZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6SoB,KAAK,GAAG,cAAc,UAAU,cAAc,QAAQ"}

package/dist/load/index.d.ts

@@ -21,7 +21,7 @@ import { OptionalImportMap, SecretMap } from "./import_type.js";
  *    with the deserialized kwargs. If a class performs side effects in its
  *    constructor (network calls, file I/O, etc.), those will execute.
  */
-interface LoadOptions {
+export interface LoadOptions {
   /**
    * A map of secrets to load. Keys are secret identifiers, values are the secret values.
    *
@@ -128,7 +128,6 @@ interface LoadOptions {
  * });
  * ```
  */
-declare function load<T>(text: string, options?: LoadOptions): Promise<T>;
+export declare function load<T>(text: string, options?: LoadOptions): Promise<T>;
 //#endregion
-export { LoadOptions, load };
 //# sourceMappingURL=index.d.ts.map

package/dist/load/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/load/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;UAuGiB;;;;;;;;EAQf,aAAa;;;;;;;;;;;;EAab;;;;;;;;;;;;;EAcA,qBAAqB;;;;;;;;;EAUrB;;;;;;;;;;;;EAaA,YAAY;;;;;;;;;;;EAYZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6SoB,KAAK,GAAG,cAAc,UAAU,cAAc,QAAQ"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/load/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;iBAuGiB;;;;;;;;EAQf,aAAa;;;;;;;;;;;;EAab;;;;;;;;;;;;;EAcA,qBAAqB;;;;;;;;;EAUrB;;;;;;;;;;;;EAaA,YAAY;;;;;;;;;;;EAYZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6SoB,KAAK,GAAG,cAAc,UAAU,cAAc,QAAQ"}

package/dist/load/map_keys.d.cts

@@ -1,7 +1,6 @@
 //#region src/load/map_keys.d.ts
-interface SerializedFields {
+export interface SerializedFields {
   [key: string]: any;
 }
 //#endregion
-export { SerializedFields };
 //# sourceMappingURL=map_keys.d.cts.map

package/dist/load/map_keys.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"map_keys.d.cts","names":[],"sources":["../../src/load/map_keys.ts"],"mappings":";UAuBiB;GAEd"}
+{"version":3,"file":"map_keys.d.cts","names":[],"sources":["../../src/load/map_keys.ts"],"mappings":";iBAuBiB;GAEd"}

package/dist/load/map_keys.d.ts

@@ -1,7 +1,6 @@
 //#region src/load/map_keys.d.ts
-interface SerializedFields {
+export interface SerializedFields {
   [key: string]: any;
 }
 //#endregion
-export { SerializedFields };
 //# sourceMappingURL=map_keys.d.ts.map

package/dist/load/map_keys.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"map_keys.d.ts","names":[],"sources":["../../src/load/map_keys.ts"],"mappings":";UAuBiB;GAEd"}
+{"version":3,"file":"map_keys.d.ts","names":[],"sources":["../../src/load/map_keys.ts"],"mappings":";iBAuBiB;GAEd"}

package/dist/load/serializable.d.cts

@@ -1,28 +1,28 @@
 import { SerializedFields } from "./map_keys.cjs";
 //#region src/load/serializable.d.ts
-interface BaseSerialized<T extends string> {
+export interface BaseSerialized<T extends string> {
   lc: number;
   type: T;
   id: string[];
   name?: string;
   graph?: Record<string, any>;
 }
-interface SerializedConstructor extends BaseSerialized<"constructor"> {
+export interface SerializedConstructor extends BaseSerialized<"constructor"> {
   kwargs: SerializedFields;
 }
-interface SerializedSecret extends BaseSerialized<"secret"> {}
-interface SerializedNotImplemented extends BaseSerialized<"not_implemented"> {}
-type Serialized = SerializedConstructor | SerializedSecret | SerializedNotImplemented;
+export interface SerializedSecret extends BaseSerialized<"secret"> {}
+export interface SerializedNotImplemented extends BaseSerialized<"not_implemented"> {}
+export type Serialized = SerializedConstructor | SerializedSecret | SerializedNotImplemented;
 /**
  * Get a unique name for the module, rather than parent class implementations.
  * Should not be subclassed, subclass lc_name above instead.
  */
-declare function get_lc_unique_name(serializableClass: typeof Serializable): string;
+export declare function get_lc_unique_name(serializableClass: typeof Serializable): string;
 /**
  * Interface for objects that can be serialized.
  * This is a duck-typed interface to avoid circular imports.
  */
-interface SerializableLike {
+export interface SerializableLike {
   lc_serializable: boolean;
   lc_secrets?: Record<string, string>;
   toJSON(): {
@@ -32,10 +32,10 @@ interface SerializableLike {
     kwargs?: Record<string, unknown>;
   };
 }
-interface SerializableInterface {
+export interface SerializableInterface {
   get lc_id(): string[];
 }
-declare abstract class Serializable implements SerializableInterface {
+export declare abstract class Serializable implements SerializableInterface {
   lc_serializable: boolean;
   lc_kwargs: SerializedFields;
   /**
@@ -88,5 +88,4 @@ declare abstract class Serializable implements SerializableInterface {
   toJSONNotImplemented(): SerializedNotImplemented;
 }
 //#endregion
-export { BaseSerialized, Serializable, SerializableInterface, SerializableLike, Serialized, SerializedConstructor, SerializedNotImplemented, SerializedSecret, get_lc_unique_name };
 //# sourceMappingURL=serializable.d.cts.map

package/dist/load/serializable.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"serializable.d.cts","names":[],"sources":["../../src/load/serializable.ts"],"mappings":";;UAGiB,eAAe;EAC9B;EACA,MAAM;EACN;EACA;EAEA,QAAQ;;UAGO,8BAA8B;EAC7C,QAAQ;;UAGO,yBAAyB;UAEzB,iCAAiC;KAEtC,aACR,wBACA,mBACA;;;;;iBAqCY,mBACd,0BAA0B;;;;;UAoBX;EACf;EACA,aAAa;EACb;IACE;IACA;IACA;IACA,SAAS;;;UAII;MACX;;uBAGgB,wBAAwB;EAC5C;EAEA,WAAW;;;;;WAMF;;;;;;;SAQF;;;;MAOH;;;;;;MAYA;KAAiB;;;;;;;;MAUjB,iBAAiB;;;;;;;MAUjB;KAAiB;;;;;;MAQjB;EAIJ,YAAY,SAAS,qBAAqB;EAY1C,UAAU;EAsFV,wBAAwB"}
+{"version":3,"file":"serializable.d.cts","names":[],"sources":["../../src/load/serializable.ts"],"mappings":";;iBAGiB,eAAe;EAC9B;EACA,MAAM;EACN;EACA;EAEA,QAAQ;;iBAGO,8BAA8B;EAC7C,QAAQ;;iBAGO,yBAAyB;iBAEzB,iCAAiC;YAEtC,aACR,wBACA,mBACA;;;;;wBAqCY,mBACd,0BAA0B;;;;;iBAoBX;EACf;EACA,aAAa;EACb;IACE;IACA;IACA;IACA,SAAS;;;iBAII;MACX;;8BAGgB,wBAAwB;EAC5C;EAEA,WAAW;;;;;WAMF;;;;;;;SAQF;;;;MAOH;;;;;;MAYA;KAAiB;;;;;;;;MAUjB,iBAAiB;;;;;;;MAUjB;KAAiB;;;;;;MAQjB;EAIJ,YAAY,SAAS,qBAAqB;EAY1C,UAAU;EAsFV,wBAAwB"}

package/dist/load/serializable.d.ts

@@ -1,28 +1,28 @@
 import { SerializedFields } from "./map_keys.js";
 //#region src/load/serializable.d.ts
-interface BaseSerialized<T extends string> {
+export interface BaseSerialized<T extends string> {
   lc: number;
   type: T;
   id: string[];
   name?: string;
   graph?: Record<string, any>;
 }
-interface SerializedConstructor extends BaseSerialized<"constructor"> {
+export interface SerializedConstructor extends BaseSerialized<"constructor"> {
   kwargs: SerializedFields;
 }
-interface SerializedSecret extends BaseSerialized<"secret"> {}
-interface SerializedNotImplemented extends BaseSerialized<"not_implemented"> {}
-type Serialized = SerializedConstructor | SerializedSecret | SerializedNotImplemented;
+export interface SerializedSecret extends BaseSerialized<"secret"> {}
+export interface SerializedNotImplemented extends BaseSerialized<"not_implemented"> {}
+export type Serialized = SerializedConstructor | SerializedSecret | SerializedNotImplemented;
 /**
  * Get a unique name for the module, rather than parent class implementations.
  * Should not be subclassed, subclass lc_name above instead.
  */
-declare function get_lc_unique_name(serializableClass: typeof Serializable): string;
+export declare function get_lc_unique_name(serializableClass: typeof Serializable): string;
 /**
  * Interface for objects that can be serialized.
  * This is a duck-typed interface to avoid circular imports.
  */
-interface SerializableLike {
+export interface SerializableLike {
   lc_serializable: boolean;
   lc_secrets?: Record<string, string>;
   toJSON(): {
@@ -32,10 +32,10 @@ interface SerializableLike {
     kwargs?: Record<string, unknown>;
   };
 }
-interface SerializableInterface {
+export interface SerializableInterface {
   get lc_id(): string[];
 }
-declare abstract class Serializable implements SerializableInterface {
+export declare abstract class Serializable implements SerializableInterface {
   lc_serializable: boolean;
   lc_kwargs: SerializedFields;
   /**
@@ -88,5 +88,4 @@ declare abstract class Serializable implements SerializableInterface {
   toJSONNotImplemented(): SerializedNotImplemented;
 }
 //#endregion
-export { BaseSerialized, Serializable, SerializableInterface, SerializableLike, Serialized, SerializedConstructor, SerializedNotImplemented, SerializedSecret, get_lc_unique_name };
 //# sourceMappingURL=serializable.d.ts.map

package/dist/load/serializable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serializable.d.ts","names":[],"sources":["../../src/load/serializable.ts"],"mappings":";;UAGiB,eAAe;EAC9B;EACA,MAAM;EACN;EACA;EAEA,QAAQ;;UAGO,8BAA8B;EAC7C,QAAQ;;UAGO,yBAAyB;UAEzB,iCAAiC;KAEtC,aACR,wBACA,mBACA;;;;;iBAqCY,mBACd,0BAA0B;;;;;UAoBX;EACf;EACA,aAAa;EACb;IACE;IACA;IACA;IACA,SAAS;;;UAII;MACX;;uBAGgB,wBAAwB;EAC5C;EAEA,WAAW;;;;;WAMF;;;;;;;SAQF;;;;MAOH;;;;;;MAYA;KAAiB;;;;;;;;MAUjB,iBAAiB;;;;;;;MAUjB;KAAiB;;;;;;MAQjB;EAIJ,YAAY,SAAS,qBAAqB;EAY1C,UAAU;EAsFV,wBAAwB"}
+{"version":3,"file":"serializable.d.ts","names":[],"sources":["../../src/load/serializable.ts"],"mappings":";;iBAGiB,eAAe;EAC9B;EACA,MAAM;EACN;EACA;EAEA,QAAQ;;iBAGO,8BAA8B;EAC7C,QAAQ;;iBAGO,yBAAyB;iBAEzB,iCAAiC;YAEtC,aACR,wBACA,mBACA;;;;;wBAqCY,mBACd,0BAA0B;;;;;iBAoBX;EACf;EACA,aAAa;EACb;IACE;IACA;IACA;IACA,SAAS;;;iBAII;MACX;;8BAGgB,wBAAwB;EAC5C;EAEA,WAAW;;;;;WAMF;;;;;;;SAQF;;;;MAOH;;;;;;MAYA;KAAiB;;;;;;;;MAUjB,iBAAiB;;;;;;;MAUjB;KAAiB;;;;;;MAQjB;EAIJ,YAAY,SAAS,qBAAqB;EAY1C,UAAU;EAsFV,wBAAwB"}

package/dist/memory.d.cts

@@ -3,24 +3,24 @@
  * Type alias for a record where the keys are strings and the values can
  * be any type. This is used to represent the input values for a Chain.
  */
-type InputValues = Record<string, any>;
+export type InputValues = Record<string, any>;
 /**
  * Type alias for a record where the keys are strings and the values can
  * be any type. This is used to represent the output values from a Chain.
  */
-type OutputValues = Record<string, any>;
+export type OutputValues = Record<string, any>;
 /**
  * Type alias for a record where the keys are strings and the values can
  * be any type. This is used to represent the memory variables in a Chain.
  */
-type MemoryVariables = Record<string, any>;
+export type MemoryVariables = Record<string, any>;
 /**
  * Abstract base class for memory in LangChain's Chains. Memory refers to
  * the state in Chains. It can be used to store information about past
  * executions of a Chain and inject that information into the inputs of
  * future executions of the Chain.
  */
-declare abstract class BaseMemory {
+export declare abstract class BaseMemory {
   abstract get memoryKeys(): string[];
   /**
    * Abstract method that should take an object of input values and return a
@@ -47,20 +47,19 @@ declare abstract class BaseMemory {
  * to use for the memory. If there is only one input value, it is used.
  * If there are multiple input values, the inputKey must be specified.
  */
-declare const getInputValue: (inputValues: InputValues, inputKey?: string) => any;
+export declare const getInputValue: (inputValues: InputValues, inputKey?: string) => any;
 /**
  * This function is used by memory classes to select the output value
  * to use for the memory. If there is only one output value, it is used.
  * If there are multiple output values, the outputKey must be specified.
  * If no outputKey is specified, an error is thrown.
  */
-declare const getOutputValue: (outputValues: OutputValues, outputKey?: string) => any;
+export declare const getOutputValue: (outputValues: OutputValues, outputKey?: string) => any;
 /**
  * Function used by memory classes to get the key of the prompt input,
  * excluding any keys that are memory variables or the "stop" key. If
  * there is not exactly one prompt input key, an error is thrown.
  */
-declare function getPromptInputKey(inputs: Record<string, unknown>, memoryVariables: string[]): string;
+export declare function getPromptInputKey(inputs: Record<string, unknown>, memoryVariables: string[]): string;
 //#endregion
-export { BaseMemory, InputValues, MemoryVariables, OutputValues, getInputValue, getOutputValue, getPromptInputKey };
 //# sourceMappingURL=memory.d.cts.map

package/dist/memory.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"memory.d.cts","names":[],"sources":["../src/memory.ts"],"mappings":";;;;;KAKY,cAAc;;;;;KAOd,eAAe;;;;;KAOf,kBAAkB;;;;;;;uBAQR;eACP;;;;;;;;;WAUJ,oBAAoB,QAAQ,cAAc,QAAQ;;;;;;;;;;WAWlD,YACP,aAAa,aACb,cAAc,eACb;;;;;;;cAkBQ,gBAAa,aAAiB,aAAW;;;;;;;cAiBzC,iBAAc,cACX,cAAY;;;;;;iBAkBZ,kBACd,QAAQ,yBACR"}
+{"version":3,"file":"memory.d.cts","names":[],"sources":["../src/memory.ts"],"mappings":";;;;;YAKY,cAAc;;;;;YAOd,eAAe;;;;;YAOf,kBAAkB;;;;;;;8BAQR;eACP;;;;;;;;;WAUJ,oBAAoB,QAAQ,cAAc,QAAQ;;;;;;;;;;WAWlD,YACP,aAAa,aACb,cAAc,eACb;;;;;;;qBAkBQ,gBAAa,aAAiB,aAAW;;;;;;;qBAiBzC,iBAAc,cACX,cAAY;;;;;;wBAkBZ,kBACd,QAAQ,yBACR"}

package/dist/memory.d.ts

@@ -3,24 +3,24 @@
  * Type alias for a record where the keys are strings and the values can
  * be any type. This is used to represent the input values for a Chain.
  */
-type InputValues = Record<string, any>;
+export type InputValues = Record<string, any>;
 /**
  * Type alias for a record where the keys are strings and the values can
  * be any type. This is used to represent the output values from a Chain.
  */
-type OutputValues = Record<string, any>;
+export type OutputValues = Record<string, any>;
 /**
  * Type alias for a record where the keys are strings and the values can
  * be any type. This is used to represent the memory variables in a Chain.
  */
-type MemoryVariables = Record<string, any>;
+export type MemoryVariables = Record<string, any>;
 /**
  * Abstract base class for memory in LangChain's Chains. Memory refers to
  * the state in Chains. It can be used to store information about past
  * executions of a Chain and inject that information into the inputs of
  * future executions of the Chain.
  */
-declare abstract class BaseMemory {
+export declare abstract class BaseMemory {
   abstract get memoryKeys(): string[];
   /**
    * Abstract method that should take an object of input values and return a
@@ -47,20 +47,19 @@ declare abstract class BaseMemory {
  * to use for the memory. If there is only one input value, it is used.
  * If there are multiple input values, the inputKey must be specified.
  */
-declare const getInputValue: (inputValues: InputValues, inputKey?: string) => any;
+export declare const getInputValue: (inputValues: InputValues, inputKey?: string) => any;
 /**
  * This function is used by memory classes to select the output value
  * to use for the memory. If there is only one output value, it is used.
  * If there are multiple output values, the outputKey must be specified.
  * If no outputKey is specified, an error is thrown.
  */
-declare const getOutputValue: (outputValues: OutputValues, outputKey?: string) => any;
+export declare const getOutputValue: (outputValues: OutputValues, outputKey?: string) => any;
 /**
  * Function used by memory classes to get the key of the prompt input,
  * excluding any keys that are memory variables or the "stop" key. If
  * there is not exactly one prompt input key, an error is thrown.
  */
-declare function getPromptInputKey(inputs: Record<string, unknown>, memoryVariables: string[]): string;
+export declare function getPromptInputKey(inputs: Record<string, unknown>, memoryVariables: string[]): string;
 //#endregion
-export { BaseMemory, InputValues, MemoryVariables, OutputValues, getInputValue, getOutputValue, getPromptInputKey };
 //# sourceMappingURL=memory.d.ts.map

package/dist/memory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory.d.ts","names":[],"sources":["../src/memory.ts"],"mappings":";;;;;KAKY,cAAc;;;;;KAOd,eAAe;;;;;KAOf,kBAAkB;;;;;;;uBAQR;eACP;;;;;;;;;WAUJ,oBAAoB,QAAQ,cAAc,QAAQ;;;;;;;;;;WAWlD,YACP,aAAa,aACb,cAAc,eACb;;;;;;;cAkBQ,gBAAa,aAAiB,aAAW;;;;;;;cAiBzC,iBAAc,cACX,cAAY;;;;;;iBAkBZ,kBACd,QAAQ,yBACR"}
+{"version":3,"file":"memory.d.ts","names":[],"sources":["../src/memory.ts"],"mappings":";;;;;YAKY,cAAc;;;;;YAOd,eAAe;;;;;YAOf,kBAAkB;;;;;;;8BAQR;eACP;;;;;;;;;WAUJ,oBAAoB,QAAQ,cAAc,QAAQ;;;;;;;;;;WAWlD,YACP,aAAa,aACb,cAAc,eACb;;;;;;;qBAkBQ,gBAAa,aAAiB,aAAW;;;;;;;qBAiBzC,iBAAc,cACX,cAAY;;;;;;wBAkBZ,kBACd,QAAQ,yBACR"}

package/dist/messages/ai.d.cts

@@ -3,12 +3,12 @@ import { BaseMessage, BaseMessageChunk, BaseMessageFields } from "./base.cjs";
 import { InvalidToolCall, ToolCallChunk } from "./tool.cjs";
 import { $InferMessageContent, $InferMessageProperty, $InferToolCalls, MessageStructure, MessageToolSet } from "./message.cjs";
 //#region src/messages/ai.d.ts
-interface AIMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, "ai"> {
+export interface AIMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, "ai"> {
   tool_calls?: $InferToolCalls<TStructure>[];
   invalid_tool_calls?: InvalidToolCall[];
   usage_metadata?: $InferMessageProperty<TStructure, "ai", "usage_metadata">;
 }
-declare class AIMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, "ai"> implements AIMessageFields<TStructure> {
+export declare class AIMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, "ai"> implements AIMessageFields<TStructure> {
   readonly type: "ai";
   tool_calls?: $InferToolCalls<TStructure>[];
   invalid_tool_calls?: InvalidToolCall[];
@@ -34,19 +34,19 @@ declare class AIMessage<TStructure extends MessageStructure = MessageStructure>
 /**
  * @deprecated Use {@link AIMessage.isInstance} instead
  */
-declare function isAIMessage<TStructure extends MessageStructure>(x: BaseMessage): x is AIMessage<TStructure>;
+export declare function isAIMessage<TStructure extends MessageStructure>(x: BaseMessage): x is AIMessage<TStructure>;
 /**
  * @deprecated Use {@link AIMessageChunk.isInstance} instead
  */
-declare function isAIMessageChunk<TStructure extends MessageStructure>(x: BaseMessageChunk): x is AIMessageChunk<TStructure>;
-type AIMessageChunkFields<TStructure extends MessageStructure = MessageStructure> = AIMessageFields<TStructure> & {
+export declare function isAIMessageChunk<TStructure extends MessageStructure>(x: BaseMessageChunk): x is AIMessageChunk<TStructure>;
+export type AIMessageChunkFields<TStructure extends MessageStructure = MessageStructure> = AIMessageFields<TStructure> & {
   tool_call_chunks?: ToolCallChunk[];
 };
 /**
  * Represents a chunk of an AI message, which can be concatenated with
  * other AI message chunks.
  */
-declare class AIMessageChunk<TStructure extends MessageStructure = MessageStructure> extends BaseMessageChunk<TStructure, "ai"> implements AIMessage<TStructure>, AIMessageChunkFields<TStructure> {
+export declare class AIMessageChunk<TStructure extends MessageStructure = MessageStructure> extends BaseMessageChunk<TStructure, "ai"> implements AIMessage<TStructure>, AIMessageChunkFields<TStructure> {
   readonly type: "ai";
   tool_calls?: $InferToolCalls<TStructure>[];
   invalid_tool_calls?: InvalidToolCall[];
@@ -72,5 +72,4 @@ declare class AIMessageChunk<TStructure extends MessageStructure = MessageStruct
   static [Symbol.hasInstance](obj: unknown): obj is AIMessageChunk<MessageStructure<MessageToolSet>>;
 }
 //#endregion
-export { AIMessage, AIMessageChunk, AIMessageChunkFields, AIMessageFields, isAIMessage, isAIMessageChunk };
 //# sourceMappingURL=ai.d.cts.map

package/dist/messages/ai.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"ai.d.cts","names":[],"sources":["../../src/messages/ai.ts"],"mappings":";;;;;UAqCiB,gBACf,mBAAmB,mBAAmB,0BAC9B,kBAAkB;EAC1B,aAAa,gBAAgB;EAC7B,qBAAqB;EACrB,iBAAiB,sBAAsB;;cAG5B,UAAU,mBAAmB,mBAAmB,0BACnD,YAAY,6BACT,gBAAgB;WAElB;EAET,aAAa,gBAAgB;EAE7B,qBAAqB;EAErB,iBAAiB,gBAAgB;MAE7B,cAAc;EAUlB,YACE,QAAQ,qBAAqB,oBAAoB,gBAAgB;SA0H5D;MAIH,iBAAiB,MAAM,aAAa;MAwC3B,oBAAoB;;;;;;SAc1B,WAAW,UAAU,kBAC1B,KAAK,YAAY,KAChB,OAAO,YAAY,KAAK,UAAU;;;;;SAK9B,WAAW,eAAe,OAAO;UAOhC,OAAO,aAAa,eAAY,OAAA,UAAA,iBAPA;;;;;iBAe1B,YAAY,mBAAmB,kBAC7C,GAAG,cACF,KAAK,UAAU;;;;iBAOF,iBAAiB,mBAAmB,kBAClD,GAAG,mBACF,KAAK,eAAe;KAIX,qBACV,mBAAmB,mBAAmB,oBACpC,gBAAgB;EAClB,mBAAmB;;;;;;cAOR,eACX,mBAAmB,mBAAmB,0BAE9B,iBAAiB,6BACd,UAAU,aAAa,qBAAqB;WAE9C;EAET,aAAa,gBAAgB;EAE7B,qBAAqB;EAErB,mBAAmB;EAEnB,iBAAiB,qBAAqB;EAEtC,YACE,QACI,qBAAqB,oBACrB,qBAAqB;MAgDvB,cAAc;SAWX;MAIH,iBAAiB,MAAM,aAAa;MA4C3B,oBAAoB;EAUjC,OAAO,OAAO,eAAe;;;;;;SAuDtB,WAAW,UAAU,kBAC1B,KAAK,YAAY,KAChB,OAAO,YAAY,KAAK,eAAe;;;;;SAKnC,WAAW,eAAe,OAAO;UAOhC,OAAO,aAAa,eAAY,OAAA,eAAA,iBAPA"}
+{"version":3,"file":"ai.d.cts","names":["_$__message_js0.MessageToolSet"],"sources":["../../src/messages/ai.ts"],"mappings":";;;;;iBAqCiB,gBACf,mBAAmB,mBAAmB,0BAC9B,kBAAkB;EAC1B,aAAa,gBAAgB;EAC7B,qBAAqB;EACrB,iBAAiB,sBAAsB;;qBAG5B,UAAU,mBAAmB,mBAAmB,0BACnD,YAAY,6BACT,gBAAgB;WAElB;EAET,aAAa,gBAAgB;EAE7B,qBAAqB;EAErB,iBAAiB,gBAAgB;MAE7B,cAAc;EAUlB,YACE,QAAQ,qBAAqB,oBAAoB,gBAAgB;SA0H5D;MAIH,iBAAiB,MAAM,aAAa;MAwC3B,oBAAoB;;;;;;SAc1B,WAAW,UAAU,kBAC1B,KAAK,YAAY,KAChB,OAAO,YAAY,KAAK,UAAU;;;;;SAK9B,WAAW,eAAe,OAAO;UAOhC,OAAO,aAAa,eAAY,OAAA,UAAA,iBAPAA;;;;;wBAe1B,YAAY,mBAAmB,kBAC7C,GAAG,cACF,KAAK,UAAU;;;;wBAOF,iBAAiB,mBAAmB,kBAClD,GAAG,mBACF,KAAK,eAAe;YAIX,qBACV,mBAAmB,mBAAmB,oBACpC,gBAAgB;EAClB,mBAAmB;;;;;;qBAOR,eACX,mBAAmB,mBAAmB,0BAE9B,iBAAiB,6BACd,UAAU,aAAa,qBAAqB;WAE9C;EAET,aAAa,gBAAgB;EAE7B,qBAAqB;EAErB,mBAAmB;EAEnB,iBAAiB,qBAAqB;EAEtC,YACE,QACI,qBAAqB,oBACrB,qBAAqB;MAgDvB,cAAc;SAWX;MAIH,iBAAiB,MAAM,aAAa;MA4C3B,oBAAoB;EAUjC,OAAO,OAAO,eAAe;;;;;;SAuDtB,WAAW,UAAU,kBAC1B,KAAK,YAAY,KAChB,OAAO,YAAY,KAAK,eAAe;;;;;SAKnC,WAAW,eAAe,OAAO;UAOhC,OAAO,aAAa,eAAY,OAAA,eAAA,iBAPAA"}

package/dist/messages/ai.d.ts

@@ -3,12 +3,12 @@ import { BaseMessage, BaseMessageChunk, BaseMessageFields } from "./base.js";
 import { InvalidToolCall, ToolCallChunk } from "./tool.js";
 import { $InferMessageContent, $InferMessageProperty, $InferToolCalls, MessageStructure, MessageToolSet } from "./message.js";
 //#region src/messages/ai.d.ts
-interface AIMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, "ai"> {
+export interface AIMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, "ai"> {
   tool_calls?: $InferToolCalls<TStructure>[];
   invalid_tool_calls?: InvalidToolCall[];
   usage_metadata?: $InferMessageProperty<TStructure, "ai", "usage_metadata">;
 }
-declare class AIMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, "ai"> implements AIMessageFields<TStructure> {
+export declare class AIMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, "ai"> implements AIMessageFields<TStructure> {
   readonly type: "ai";
   tool_calls?: $InferToolCalls<TStructure>[];
   invalid_tool_calls?: InvalidToolCall[];
@@ -34,19 +34,19 @@ declare class AIMessage<TStructure extends MessageStructure = MessageStructure>
 /**
  * @deprecated Use {@link AIMessage.isInstance} instead
  */
-declare function isAIMessage<TStructure extends MessageStructure>(x: BaseMessage): x is AIMessage<TStructure>;
+export declare function isAIMessage<TStructure extends MessageStructure>(x: BaseMessage): x is AIMessage<TStructure>;
 /**
  * @deprecated Use {@link AIMessageChunk.isInstance} instead
  */
-declare function isAIMessageChunk<TStructure extends MessageStructure>(x: BaseMessageChunk): x is AIMessageChunk<TStructure>;
-type AIMessageChunkFields<TStructure extends MessageStructure = MessageStructure> = AIMessageFields<TStructure> & {
+export declare function isAIMessageChunk<TStructure extends MessageStructure>(x: BaseMessageChunk): x is AIMessageChunk<TStructure>;
+export type AIMessageChunkFields<TStructure extends MessageStructure = MessageStructure> = AIMessageFields<TStructure> & {
   tool_call_chunks?: ToolCallChunk[];
 };
 /**
  * Represents a chunk of an AI message, which can be concatenated with
  * other AI message chunks.
  */
-declare class AIMessageChunk<TStructure extends MessageStructure = MessageStructure> extends BaseMessageChunk<TStructure, "ai"> implements AIMessage<TStructure>, AIMessageChunkFields<TStructure> {
+export declare class AIMessageChunk<TStructure extends MessageStructure = MessageStructure> extends BaseMessageChunk<TStructure, "ai"> implements AIMessage<TStructure>, AIMessageChunkFields<TStructure> {
   readonly type: "ai";
   tool_calls?: $InferToolCalls<TStructure>[];
   invalid_tool_calls?: InvalidToolCall[];
@@ -72,5 +72,4 @@ declare class AIMessageChunk<TStructure extends MessageStructure = MessageStruct
   static [Symbol.hasInstance](obj: unknown): obj is AIMessageChunk<MessageStructure<MessageToolSet>>;
 }
 //#endregion
-export { AIMessage, AIMessageChunk, AIMessageChunkFields, AIMessageFields, isAIMessage, isAIMessageChunk };
 //# sourceMappingURL=ai.d.ts.map

package/dist/messages/ai.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ai.d.ts","names":[],"sources":["../../src/messages/ai.ts"],"mappings":";;;;;UAqCiB,gBACf,mBAAmB,mBAAmB,0BAC9B,kBAAkB;EAC1B,aAAa,gBAAgB;EAC7B,qBAAqB;EACrB,iBAAiB,sBAAsB;;cAG5B,UAAU,mBAAmB,mBAAmB,0BACnD,YAAY,6BACT,gBAAgB;WAElB;EAET,aAAa,gBAAgB;EAE7B,qBAAqB;EAErB,iBAAiB,gBAAgB;MAE7B,cAAc;EAUlB,YACE,QAAQ,qBAAqB,oBAAoB,gBAAgB;SA0H5D;MAIH,iBAAiB,MAAM,aAAa;MAwC3B,oBAAoB;;;;;;SAc1B,WAAW,UAAU,kBAC1B,KAAK,YAAY,KAChB,OAAO,YAAY,KAAK,UAAU;;;;;SAK9B,WAAW,eAAe,OAAO;UAOhC,OAAO,aAAa,eAAY,OAAA,UAAA,iBAPA;;;;;iBAe1B,YAAY,mBAAmB,kBAC7C,GAAG,cACF,KAAK,UAAU;;;;iBAOF,iBAAiB,mBAAmB,kBAClD,GAAG,mBACF,KAAK,eAAe;KAIX,qBACV,mBAAmB,mBAAmB,oBACpC,gBAAgB;EAClB,mBAAmB;;;;;;cAOR,eACX,mBAAmB,mBAAmB,0BAE9B,iBAAiB,6BACd,UAAU,aAAa,qBAAqB;WAE9C;EAET,aAAa,gBAAgB;EAE7B,qBAAqB;EAErB,mBAAmB;EAEnB,iBAAiB,qBAAqB;EAEtC,YACE,QACI,qBAAqB,oBACrB,qBAAqB;MAgDvB,cAAc;SAWX;MAIH,iBAAiB,MAAM,aAAa;MA4C3B,oBAAoB;EAUjC,OAAO,OAAO,eAAe;;;;;;SAuDtB,WAAW,UAAU,kBAC1B,KAAK,YAAY,KAChB,OAAO,YAAY,KAAK,eAAe;;;;;SAKnC,WAAW,eAAe,OAAO;UAOhC,OAAO,aAAa,eAAY,OAAA,eAAA,iBAPA"}
+{"version":3,"file":"ai.d.ts","names":["_$__message_js0.MessageToolSet"],"sources":["../../src/messages/ai.ts"],"mappings":";;;;;iBAqCiB,gBACf,mBAAmB,mBAAmB,0BAC9B,kBAAkB;EAC1B,aAAa,gBAAgB;EAC7B,qBAAqB;EACrB,iBAAiB,sBAAsB;;qBAG5B,UAAU,mBAAmB,mBAAmB,0BACnD,YAAY,6BACT,gBAAgB;WAElB;EAET,aAAa,gBAAgB;EAE7B,qBAAqB;EAErB,iBAAiB,gBAAgB;MAE7B,cAAc;EAUlB,YACE,QAAQ,qBAAqB,oBAAoB,gBAAgB;SA0H5D;MAIH,iBAAiB,MAAM,aAAa;MAwC3B,oBAAoB;;;;;;SAc1B,WAAW,UAAU,kBAC1B,KAAK,YAAY,KAChB,OAAO,YAAY,KAAK,UAAU;;;;;SAK9B,WAAW,eAAe,OAAO;UAOhC,OAAO,aAAa,eAAY,OAAA,UAAA,iBAPAA;;;;;wBAe1B,YAAY,mBAAmB,kBAC7C,GAAG,cACF,KAAK,UAAU;;;;wBAOF,iBAAiB,mBAAmB,kBAClD,GAAG,mBACF,KAAK,eAAe;YAIX,qBACV,mBAAmB,mBAAmB,oBACpC,gBAAgB;EAClB,mBAAmB;;;;;;qBAOR,eACX,mBAAmB,mBAAmB,0BAE9B,iBAAiB,6BACd,UAAU,aAAa,qBAAqB;WAE9C;EAET,aAAa,gBAAgB;EAE7B,qBAAqB;EAErB,mBAAmB;EAEnB,iBAAiB,qBAAqB;EAEtC,YACE,QACI,qBAAqB,oBACrB,qBAAqB;MAgDvB,cAAc;SAWX;MAIH,iBAAiB,MAAM,aAAa;MA4C3B,oBAAoB;EAUjC,OAAO,OAAO,eAAe;;;;;;SAuDtB,WAAW,UAAU,kBAC1B,KAAK,YAAY,KAChB,OAAO,YAAY,KAAK,eAAe;;;;;SAKnC,WAAW,eAAe,OAAO;UAOhC,OAAO,aAAa,eAAY,OAAA,eAAA,iBAPAA"}