@langchain/core 1.2.13 → 1.2.16

package/dist/messages/system.d.ts

@@ -1,11 +1,11 @@
 import { BaseMessage, BaseMessageChunk, BaseMessageFields } from "./base.js";
 import { $InferMessageContent, MessageStructure, MessageToolSet } from "./message.js";
 //#region src/messages/system.d.ts
-interface SystemMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, "system"> {}
+export interface SystemMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, "system"> {}
 /**
  * Represents a system message in a conversation.
  */
-declare class SystemMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, "system"> {
+export declare class SystemMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, "system"> {
   static lc_name(): string;
   readonly type: "system";
   constructor(fields: $InferMessageContent<TStructure, "system"> | SystemMessageFields<TStructure>);
@@ -22,7 +22,7 @@ declare class SystemMessage<TStructure extends MessageStructure = MessageStructu
  * Represents a chunk of a system message, which can be concatenated with
  * other system message chunks.
  */
-declare class SystemMessageChunk<TStructure extends MessageStructure = MessageStructure> extends BaseMessageChunk<TStructure, "system"> {
+export declare class SystemMessageChunk<TStructure extends MessageStructure = MessageStructure> extends BaseMessageChunk<TStructure, "system"> {
   static lc_name(): string;
   readonly type: "system";
   constructor(fields: $InferMessageContent<TStructure, "system"> | SystemMessageFields<TStructure>);
@@ -33,11 +33,10 @@ declare class SystemMessageChunk<TStructure extends MessageStructure = MessageSt
 /**
  * @deprecated Use {@link SystemMessage.isInstance} instead
  */
-declare function isSystemMessage<TStructure extends MessageStructure>(x: BaseMessage): x is SystemMessage<TStructure>;
+export declare function isSystemMessage<TStructure extends MessageStructure>(x: BaseMessage): x is SystemMessage<TStructure>;
 /**
  * @deprecated Use {@link SystemMessageChunk.isInstance} instead
  */
-declare function isSystemMessageChunk<TStructure extends MessageStructure>(x: BaseMessageChunk): x is SystemMessageChunk<TStructure>;
+export declare function isSystemMessageChunk<TStructure extends MessageStructure>(x: BaseMessageChunk): x is SystemMessageChunk<TStructure>;
 //#endregion
-export { SystemMessage, SystemMessageChunk, SystemMessageFields, isSystemMessage, isSystemMessageChunk };
 //# sourceMappingURL=system.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"system.d.ts","names":[],"sources":["../../src/messages/system.ts"],"mappings":";;;UAUiB,oBACf,mBAAmB,mBAAmB,0BAC9B,kBAAkB;;;;cAKf,cACX,mBAAmB,mBAAmB,0BAC9B,YAAY;SACb;WAIE;EAET,YACE,QACI,qBAAqB,wBACrB,oBAAoB;;;;;;EAU1B,OAAO,gBAAgB,gBAAa,cAAA;SA8B7B,WAAW,eAAe,OAAO;UAIhC,OAAO,aAAa,eAAY,OAAA,cAAA,iBAJA;;;;;;cAa7B,mBACX,mBAAmB,mBAAmB,0BAC9B,iBAAiB;SAClB;WAIE;EAET,YACE,QACI,qBAAqB,wBACrB,oBAAoB;EAK1B,OAAO,OAAO,mBAAmB;SAgB1B,WAAW,eAAe,OAAO;UAIhC,OAAO,aAAa,eAAY,OAAA,mBAAA,iBAJA;;;;;iBAY1B,gBAAgB,mBAAmB,kBACjD,GAAG,cACF,KAAK,cAAc;;;;iBAON,qBAAqB,mBAAmB,kBACtD,GAAG,mBACF,KAAK,mBAAmB"}
+{"version":3,"file":"system.d.ts","names":["_$__message_js0.MessageToolSet"],"sources":["../../src/messages/system.ts"],"mappings":";;;iBAUiB,oBACf,mBAAmB,mBAAmB,0BAC9B,kBAAkB;;;;qBAKf,cACX,mBAAmB,mBAAmB,0BAC9B,YAAY;SACb;WAIE;EAET,YACE,QACI,qBAAqB,wBACrB,oBAAoB;;;;;;EAU1B,OAAO,gBAAgB,gBAAa,cAAA;SA8B7B,WAAW,eAAe,OAAO;UAIhC,OAAO,aAAa,eAAY,OAAA,cAAA,iBAJAA;;;;;;qBAa7B,mBACX,mBAAmB,mBAAmB,0BAC9B,iBAAiB;SAClB;WAIE;EAET,YACE,QACI,qBAAqB,wBACrB,oBAAoB;EAK1B,OAAO,OAAO,mBAAmB;SAgB1B,WAAW,eAAe,OAAO;UAIhC,OAAO,aAAa,eAAY,OAAA,mBAAA,iBAJAA;;;;;wBAY1B,gBAAgB,mBAAmB,kBACjD,GAAG,cACF,KAAK,cAAc;;;;wBAON,qBAAqB,mBAAmB,kBACtD,GAAG,mBACF,KAAK,mBAAmB"}

package/dist/messages/tool.d.cts

@@ -1,7 +1,7 @@
 import { BaseMessage, BaseMessageChunk, BaseMessageFields } from "./base.cjs";
 import { $InferMessageContent, MessageStructure, MessageToolSet } from "./message.cjs";
 //#region src/messages/tool.d.ts
-interface ToolMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, "tool"> {
+export interface ToolMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, "tool"> {
   /**
    * Artifact of the Tool execution which is not meant to be sent to the model.
    *
@@ -21,14 +21,14 @@ interface ToolMessageFields<TStructure extends MessageStructure = MessageStructu
  * not an instance of DirectToolOutput, the output will automatically be coerced to
  * a string and wrapped in a ToolMessage.
  */
-interface DirectToolOutput {
+export interface DirectToolOutput {
   readonly lc_direct_tool_output: true;
 }
-declare function isDirectToolOutput(x: unknown): x is DirectToolOutput;
+export declare function isDirectToolOutput(x: unknown): x is DirectToolOutput;
 /**
  * Represents a tool message in a conversation.
  */
-declare class ToolMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, "tool"> implements DirectToolOutput {
+export declare class ToolMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, "tool"> implements DirectToolOutput {
   static lc_name(): string;
   get lc_aliases(): Record<string, string>;
   lc_direct_tool_output: true;
@@ -68,7 +68,7 @@ declare class ToolMessage<TStructure extends MessageStructure = MessageStructure
  * Represents a chunk of a tool message, which can be concatenated
  * with other tool message chunks.
  */
-declare class ToolMessageChunk<TStructure extends MessageStructure = MessageStructure> extends BaseMessageChunk<TStructure, "tool"> {
+export declare class ToolMessageChunk<TStructure extends MessageStructure = MessageStructure> extends BaseMessageChunk<TStructure, "tool"> {
   readonly type: "tool";
   tool_call_id: string;
   /**
@@ -91,7 +91,7 @@ declare class ToolMessageChunk<TStructure extends MessageStructure = MessageStru
   static [Symbol.hasInstance](obj: unknown): obj is ToolMessageChunk<MessageStructure<MessageToolSet>>;
   get _printableFields(): Record<string, unknown>;
 }
-interface ToolCall<TName extends string = string, TArgs extends Record<string, any> = Record<string, any>> {
+export interface ToolCall<TName extends string = string, TArgs extends Record<string, any> = Record<string, any>> {
   readonly type?: "tool_call";
   /**
    * If provided, an identifier associated with the tool call
@@ -151,7 +151,7 @@ interface ToolCall<TName extends string = string, TArgs extends Record<string, a
  * // ]
  * ```
  */
-interface ToolCallChunk<TName extends string = string> {
+export interface ToolCallChunk<TName extends string = string> {
   readonly type?: "tool_call_chunk";
   /**
    * If provided, a substring of an identifier for the tool call
@@ -170,7 +170,7 @@ interface ToolCallChunk<TName extends string = string> {
    */
   index?: number;
 }
-interface InvalidToolCall<TName extends string = string> {
+export interface InvalidToolCall<TName extends string = string> {
   readonly type?: "invalid_tool_call";
   /**
    * If provided, an identifier associated with the tool call
@@ -194,15 +194,14 @@ interface InvalidToolCall<TName extends string = string> {
    */
   index?: string | number;
 }
-declare function defaultToolCallParser(rawToolCalls: Record<string, any>[]): [ToolCall[], InvalidToolCall[]];
+export declare function defaultToolCallParser(rawToolCalls: Record<string, any>[]): [ToolCall[], InvalidToolCall[]];
 /**
  * @deprecated Use {@link ToolMessage.isInstance} instead
  */
-declare function isToolMessage(x: unknown): x is ToolMessage;
+export declare function isToolMessage(x: unknown): x is ToolMessage;
 /**
  * @deprecated Use {@link ToolMessageChunk.isInstance} instead
  */
-declare function isToolMessageChunk(x: BaseMessageChunk): x is ToolMessageChunk;
+export declare function isToolMessageChunk(x: BaseMessageChunk): x is ToolMessageChunk;
 //#endregion
-export { DirectToolOutput, InvalidToolCall, ToolCall, ToolCallChunk, ToolMessage, ToolMessageChunk, ToolMessageFields, defaultToolCallParser, isDirectToolOutput, isToolMessage, isToolMessageChunk };
 //# sourceMappingURL=tool.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.cts","names":[],"sources":["../../src/messages/tool.ts"],"mappings":";;;UAYiB,kBACf,mBAAmB,mBAAmB,0BAC9B,kBAAkB;;;;;;;;EAS1B;EACA;EACA;EACA,WAAW;;;;;;;;;UAUI;WACN;;iBAGK,mBAAmB,aAAa,KAAK;;;;cAYxC,YAAY,mBAAmB,mBAAmB,0BACrD,YAAY,+BACT;SAEJ;MAIH,cAAc;EAKlB;WAES;;;;;EAMT;EAEA;EAEA,WAAW;;;;;;;;EAUX;EAEA,YACE,QAAQ,qBAAqB,sBAAsB,mBACnD,sBACA;EAGF,YAAY,QAAQ,kBAAkB;;;;;;SA6B/B,WAAW,UAAU,kBAC1B,SAAS,YAAY,KACpB,WAAW,YAAY,KAAK,YAAY;;;;;SAKpC,WAAW,mBAAmB,WAAW;UASxC,OAAO,aAAa,eAAY,OAAA,YAAA,iBATQ;MAanC,oBAAoB;;;;;;cAatB,iBACX,mBAAmB,mBAAmB,0BAC9B,iBAAiB;WAChB;EAET;;;;;EAMA;;;;;;;;EAUA;EAEA,YAAY,QAAQ,kBAAkB;SAO/B;EAIP,OAAO,OAAO,iBAAiB;SAmBxB,WAAW,eAAe,OAAO;UAIhC,OAAO,aAAa,eAAY,OAAA,iBAAA,iBAJA;MAQ3B,oBAAoB;;UASlB,SACf,+BAEA,cAAc,sBAAsB;WAE3B;;;;EAIT;;;;EAIA,MAAM;;;;EAIN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAgDS,cAAc;WACpB;;;;EAIT;;;;EAIA,OAAO;;;;EAIP;;;;EAIA;;UAGe,gBAAgB;WACtB;;;;EAIT;;;;;EAKA,OAAO;;;;EAIP;;;;EAIA;;;;EAIA;;iBAGc,sBAEd,cAAc,yBACZ,YAAY;;;;iBA+BA,cAAc,aAAa,KAAK;;;;iBAahC,mBAAmB,GAAG,mBAAmB,KAAK"}
+{"version":3,"file":"tool.d.cts","names":["_$__message_js0.MessageToolSet"],"sources":["../../src/messages/tool.ts"],"mappings":";;;iBAYiB,kBACf,mBAAmB,mBAAmB,0BAC9B,kBAAkB;;;;;;;;EAS1B;EACA;EACA;EACA,WAAW;;;;;;;;;iBAUI;WACN;;wBAGK,mBAAmB,aAAa,KAAK;;;;qBAYxC,YAAY,mBAAmB,mBAAmB,0BACrD,YAAY,+BACT;SAEJ;MAIH,cAAc;EAKlB;WAES;;;;;EAMT;EAEA;EAEA,WAAW;;;;;;;;EAUX;EAEA,YACE,QAAQ,qBAAqB,sBAAsB,mBACnD,sBACA;EAGF,YAAY,QAAQ,kBAAkB;;;;;;SA6B/B,WAAW,UAAU,kBAC1B,SAAS,YAAY,KACpB,WAAW,YAAY,KAAK,YAAY;;;;;SAKpC,WAAW,mBAAmB,WAAW;UASxC,OAAO,aAAa,eAAY,OAAA,YAAA,iBATQA;MAanC,oBAAoB;;;;;;qBAatB,iBACX,mBAAmB,mBAAmB,0BAC9B,iBAAiB;WAChB;EAET;;;;;EAMA;;;;;;;;EAUA;EAEA,YAAY,QAAQ,kBAAkB;SAO/B;EAIP,OAAO,OAAO,iBAAiB;SAmBxB,WAAW,eAAe,OAAO;UAIhC,OAAO,aAAa,eAAY,OAAA,iBAAA,iBAJAA;MAQ3B,oBAAoB;;iBASlB,SACf,+BAEA,cAAc,sBAAsB;WAE3B;;;;EAIT;;;;EAIA,MAAM;;;;EAIN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgDS,cAAc;WACpB;;;;EAIT;;;;EAIA,OAAO;;;;EAIP;;;;EAIA;;iBAGe,gBAAgB;WACtB;;;;EAIT;;;;;EAKA,OAAO;;;;EAIP;;;;EAIA;;;;EAIA;;wBAGc,sBAEd,cAAc,yBACZ,YAAY;;;;wBA+BA,cAAc,aAAa,KAAK;;;;wBAahC,mBAAmB,GAAG,mBAAmB,KAAK"}

package/dist/messages/tool.d.ts

@@ -1,7 +1,7 @@
 import { BaseMessage, BaseMessageChunk, BaseMessageFields } from "./base.js";
 import { $InferMessageContent, MessageStructure, MessageToolSet } from "./message.js";
 //#region src/messages/tool.d.ts
-interface ToolMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, "tool"> {
+export interface ToolMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, "tool"> {
   /**
    * Artifact of the Tool execution which is not meant to be sent to the model.
    *
@@ -21,14 +21,14 @@ interface ToolMessageFields<TStructure extends MessageStructure = MessageStructu
  * not an instance of DirectToolOutput, the output will automatically be coerced to
  * a string and wrapped in a ToolMessage.
  */
-interface DirectToolOutput {
+export interface DirectToolOutput {
   readonly lc_direct_tool_output: true;
 }
-declare function isDirectToolOutput(x: unknown): x is DirectToolOutput;
+export declare function isDirectToolOutput(x: unknown): x is DirectToolOutput;
 /**
  * Represents a tool message in a conversation.
  */
-declare class ToolMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, "tool"> implements DirectToolOutput {
+export declare class ToolMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, "tool"> implements DirectToolOutput {
   static lc_name(): string;
   get lc_aliases(): Record<string, string>;
   lc_direct_tool_output: true;
@@ -68,7 +68,7 @@ declare class ToolMessage<TStructure extends MessageStructure = MessageStructure
  * Represents a chunk of a tool message, which can be concatenated
  * with other tool message chunks.
  */
-declare class ToolMessageChunk<TStructure extends MessageStructure = MessageStructure> extends BaseMessageChunk<TStructure, "tool"> {
+export declare class ToolMessageChunk<TStructure extends MessageStructure = MessageStructure> extends BaseMessageChunk<TStructure, "tool"> {
   readonly type: "tool";
   tool_call_id: string;
   /**
@@ -91,7 +91,7 @@ declare class ToolMessageChunk<TStructure extends MessageStructure = MessageStru
   static [Symbol.hasInstance](obj: unknown): obj is ToolMessageChunk<MessageStructure<MessageToolSet>>;
   get _printableFields(): Record<string, unknown>;
 }
-interface ToolCall<TName extends string = string, TArgs extends Record<string, any> = Record<string, any>> {
+export interface ToolCall<TName extends string = string, TArgs extends Record<string, any> = Record<string, any>> {
   readonly type?: "tool_call";
   /**
    * If provided, an identifier associated with the tool call
@@ -151,7 +151,7 @@ interface ToolCall<TName extends string = string, TArgs extends Record<string, a
  * // ]
  * ```
  */
-interface ToolCallChunk<TName extends string = string> {
+export interface ToolCallChunk<TName extends string = string> {
   readonly type?: "tool_call_chunk";
   /**
    * If provided, a substring of an identifier for the tool call
@@ -170,7 +170,7 @@ interface ToolCallChunk<TName extends string = string> {
    */
   index?: number;
 }
-interface InvalidToolCall<TName extends string = string> {
+export interface InvalidToolCall<TName extends string = string> {
   readonly type?: "invalid_tool_call";
   /**
    * If provided, an identifier associated with the tool call
@@ -194,15 +194,14 @@ interface InvalidToolCall<TName extends string = string> {
    */
   index?: string | number;
 }
-declare function defaultToolCallParser(rawToolCalls: Record<string, any>[]): [ToolCall[], InvalidToolCall[]];
+export declare function defaultToolCallParser(rawToolCalls: Record<string, any>[]): [ToolCall[], InvalidToolCall[]];
 /**
  * @deprecated Use {@link ToolMessage.isInstance} instead
  */
-declare function isToolMessage(x: unknown): x is ToolMessage;
+export declare function isToolMessage(x: unknown): x is ToolMessage;
 /**
  * @deprecated Use {@link ToolMessageChunk.isInstance} instead
  */
-declare function isToolMessageChunk(x: BaseMessageChunk): x is ToolMessageChunk;
+export declare function isToolMessageChunk(x: BaseMessageChunk): x is ToolMessageChunk;
 //#endregion
-export { DirectToolOutput, InvalidToolCall, ToolCall, ToolCallChunk, ToolMessage, ToolMessageChunk, ToolMessageFields, defaultToolCallParser, isDirectToolOutput, isToolMessage, isToolMessageChunk };
 //# sourceMappingURL=tool.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","names":[],"sources":["../../src/messages/tool.ts"],"mappings":";;;UAYiB,kBACf,mBAAmB,mBAAmB,0BAC9B,kBAAkB;;;;;;;;EAS1B;EACA;EACA;EACA,WAAW;;;;;;;;;UAUI;WACN;;iBAGK,mBAAmB,aAAa,KAAK;;;;cAYxC,YAAY,mBAAmB,mBAAmB,0BACrD,YAAY,+BACT;SAEJ;MAIH,cAAc;EAKlB;WAES;;;;;EAMT;EAEA;EAEA,WAAW;;;;;;;;EAUX;EAEA,YACE,QAAQ,qBAAqB,sBAAsB,mBACnD,sBACA;EAGF,YAAY,QAAQ,kBAAkB;;;;;;SA6B/B,WAAW,UAAU,kBAC1B,SAAS,YAAY,KACpB,WAAW,YAAY,KAAK,YAAY;;;;;SAKpC,WAAW,mBAAmB,WAAW;UASxC,OAAO,aAAa,eAAY,OAAA,YAAA,iBATQ;MAanC,oBAAoB;;;;;;cAatB,iBACX,mBAAmB,mBAAmB,0BAC9B,iBAAiB;WAChB;EAET;;;;;EAMA;;;;;;;;EAUA;EAEA,YAAY,QAAQ,kBAAkB;SAO/B;EAIP,OAAO,OAAO,iBAAiB;SAmBxB,WAAW,eAAe,OAAO;UAIhC,OAAO,aAAa,eAAY,OAAA,iBAAA,iBAJA;MAQ3B,oBAAoB;;UASlB,SACf,+BAEA,cAAc,sBAAsB;WAE3B;;;;EAIT;;;;EAIA,MAAM;;;;EAIN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAgDS,cAAc;WACpB;;;;EAIT;;;;EAIA,OAAO;;;;EAIP;;;;EAIA;;UAGe,gBAAgB;WACtB;;;;EAIT;;;;;EAKA,OAAO;;;;EAIP;;;;EAIA;;;;EAIA;;iBAGc,sBAEd,cAAc,yBACZ,YAAY;;;;iBA+BA,cAAc,aAAa,KAAK;;;;iBAahC,mBAAmB,GAAG,mBAAmB,KAAK"}
+{"version":3,"file":"tool.d.ts","names":["_$__message_js0.MessageToolSet"],"sources":["../../src/messages/tool.ts"],"mappings":";;;iBAYiB,kBACf,mBAAmB,mBAAmB,0BAC9B,kBAAkB;;;;;;;;EAS1B;EACA;EACA;EACA,WAAW;;;;;;;;;iBAUI;WACN;;wBAGK,mBAAmB,aAAa,KAAK;;;;qBAYxC,YAAY,mBAAmB,mBAAmB,0BACrD,YAAY,+BACT;SAEJ;MAIH,cAAc;EAKlB;WAES;;;;;EAMT;EAEA;EAEA,WAAW;;;;;;;;EAUX;EAEA,YACE,QAAQ,qBAAqB,sBAAsB,mBACnD,sBACA;EAGF,YAAY,QAAQ,kBAAkB;;;;;;SA6B/B,WAAW,UAAU,kBAC1B,SAAS,YAAY,KACpB,WAAW,YAAY,KAAK,YAAY;;;;;SAKpC,WAAW,mBAAmB,WAAW;UASxC,OAAO,aAAa,eAAY,OAAA,YAAA,iBATQA;MAanC,oBAAoB;;;;;;qBAatB,iBACX,mBAAmB,mBAAmB,0BAC9B,iBAAiB;WAChB;EAET;;;;;EAMA;;;;;;;;EAUA;EAEA,YAAY,QAAQ,kBAAkB;SAO/B;EAIP,OAAO,OAAO,iBAAiB;SAmBxB,WAAW,eAAe,OAAO;UAIhC,OAAO,aAAa,eAAY,OAAA,iBAAA,iBAJAA;MAQ3B,oBAAoB;;iBASlB,SACf,+BAEA,cAAc,sBAAsB;WAE3B;;;;EAIT;;;;EAIA,MAAM;;;;EAIN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgDS,cAAc;WACpB;;;;EAIT;;;;EAIA,OAAO;;;;EAIP;;;;EAIA;;iBAGe,gBAAgB;WACtB;;;;EAIT;;;;;EAKA,OAAO;;;;EAIP;;;;EAIA;;;;EAIA;;wBAGc,sBAEd,cAAc,yBACZ,YAAY;;;;wBA+BA,cAAc,aAAa,KAAK;;;;wBAahC,mBAAmB,GAAG,mBAAmB,KAAK"}

package/dist/messages/transformers.d.cts

@@ -10,10 +10,10 @@ import { Runnable } from "../runnables/base.cjs";
 import { BaseLanguageModel } from "../language_models/base.cjs";
 import { RemoveMessage } from "./modifier.cjs";
 //#region src/messages/transformers.d.ts
-type MessageUnion = typeof HumanMessage | typeof AIMessage | typeof SystemMessage | typeof ChatMessage | typeof FunctionMessage | typeof ToolMessage | typeof RemoveMessage;
-type MessageChunkUnion = typeof HumanMessageChunk | typeof AIMessageChunk | typeof SystemMessageChunk | typeof FunctionMessageChunk | typeof ToolMessageChunk | typeof ChatMessageChunk | typeof RemoveMessage;
-type MessageTypeOrClass = MessageType | MessageUnion | MessageChunkUnion;
-interface FilterMessagesFields {
+export type MessageUnion = typeof HumanMessage | typeof AIMessage | typeof SystemMessage | typeof ChatMessage | typeof FunctionMessage | typeof ToolMessage | typeof RemoveMessage;
+export type MessageChunkUnion = typeof HumanMessageChunk | typeof AIMessageChunk | typeof SystemMessageChunk | typeof FunctionMessageChunk | typeof ToolMessageChunk | typeof ChatMessageChunk | typeof RemoveMessage;
+export type MessageTypeOrClass = MessageType | MessageUnion | MessageChunkUnion;
+export interface FilterMessagesFields {
   /**
    * @param {string[] | undefined} includeNames Message names to include.
    */
@@ -80,8 +80,8 @@ interface FilterMessagesFields {
  * ]
  * ```
  */
-declare function filterMessages(options?: FilterMessagesFields): Runnable<BaseMessage[], BaseMessage[]>;
-declare function filterMessages(messages: BaseMessage[], options?: FilterMessagesFields): BaseMessage[];
+export declare function filterMessages(options?: FilterMessagesFields): Runnable<BaseMessage[], BaseMessage[]>;
+export declare function filterMessages(messages: BaseMessage[], options?: FilterMessagesFields): BaseMessage[];
 /**
  * Merge consecutive Messages of the same type.
  *
@@ -140,12 +140,12 @@ declare function filterMessages(messages: BaseMessage[], options?: FilterMessage
  * ]
  * ```
  */
-declare function mergeMessageRuns(): Runnable<BaseMessage[], BaseMessage[]>;
-declare function mergeMessageRuns(messages: BaseMessage[]): BaseMessage[];
+export declare function mergeMessageRuns(): Runnable<BaseMessage[], BaseMessage[]>;
+export declare function mergeMessageRuns(messages: BaseMessage[]): BaseMessage[];
 interface _TextSplitterInterface {
   splitText(text: string): Promise<string[]>;
 }
-interface TrimMessagesFields {
+export interface TrimMessagesFields {
   /**
    * @param {number} maxTokens Max token count of trimmed messages.
    */
@@ -455,15 +455,14 @@ interface TrimMessagesFields {
  * ]
  * ```
  */
-declare function trimMessages(options: TrimMessagesFields): Runnable<BaseMessage[], BaseMessage[]>;
-declare function trimMessages(messages: BaseMessage[], options: TrimMessagesFields): Promise<BaseMessage[]>;
+export declare function trimMessages(options: TrimMessagesFields): Runnable<BaseMessage[], BaseMessage[]>;
+export declare function trimMessages(messages: BaseMessage[], options: TrimMessagesFields): Promise<BaseMessage[]>;
 /**
  * The default text splitter function that splits text by newlines.
  *
  * @param {string} text
  * @returns A promise that resolves to an array of strings split by newlines.
  */
-declare function defaultTextSplitter(text: string): Promise<string[]>;
+export declare function defaultTextSplitter(text: string): Promise<string[]>;
 //#endregion
-export { FilterMessagesFields, MessageChunkUnion, MessageTypeOrClass, MessageUnion, TrimMessagesFields, defaultTextSplitter, filterMessages, mergeMessageRuns, trimMessages };
 //# sourceMappingURL=transformers.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"transformers.d.cts","names":[],"sources":["../../src/messages/transformers.ts"],"mappings":";;;;;;;;;;;;KAsBY,sBACD,sBACA,mBACA,uBACA,qBACA,yBACA,qBACA;KACC,2BACD,2BACA,wBACA,4BACA,8BACA,0BACA,0BACA;KACC,qBAAqB,cAAc,eAAe;UAyB7C;;;;EAIf;;;;EAIA;;;;;;EAMA,eAAe;;;;;;EAMf,eAAe;;;;EAIf;;;;EAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwCc,eACd,UAAU,uBACT,SAAS,eAAe;iBACX,eACd,UAAU,eACV,UAAU,uBACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkHa,oBAAoB,SAAS,eAAe;iBAC5C,iBAAiB,UAAU,gBAAgB;UA6CjD;EACR,UAAU,eAAe;;UAGV;;;;EAIf;;;;;;EAMA,gBACM,UAAU,8BACV,UAAU,kBAAkB,mBAC9B;;;;;;;EAOJ;;;;;;;EAOA;;;;;;;;;EASA,QAAQ,qBAAqB;;;;;;;;;EAS7B,UAAU,qBAAqB;;;;;;EAM/B;;;;;;;;;EASA,iBACM,+BACA,iBAAiB,qBACnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8PU,aACd,SAAS,qBACR,SAAS,eAAe;iBACX,aACd,UAAU,eACV,SAAS,qBACR,QAAQ;;;;;;;iBAydK,oBAAoB,eAAe"}
+{"version":3,"file":"transformers.d.cts","names":[],"sources":["../../src/messages/transformers.ts"],"mappings":";;;;;;;;;;;;YAsBY,sBACD,sBACA,mBACA,uBACA,qBACA,yBACA,qBACA;YACC,2BACD,2BACA,wBACA,4BACA,8BACA,0BACA,0BACA;YACC,qBAAqB,cAAc,eAAe;iBAyB7C;;;;EAIf;;;;EAIA;;;;;;EAMA,eAAe;;;;;;EAMf,eAAe;;;;EAIf;;;;EAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAwCc,eACd,UAAU,uBACT,SAAS,eAAe;wBACX,eACd,UAAU,eACV,UAAU,uBACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAkHa,oBAAoB,SAAS,eAAe;wBAC5C,iBAAiB,UAAU,gBAAgB;UA6CjD;EACR,UAAU,eAAe;;iBAGV;;;;EAIf;;;;;;EAMA,gBACM,UAAU,8BACV,UAAU,kBAAkB,mBAC9B;;;;;;;EAOJ;;;;;;;EAOA;;;;;;;;;EASA,QAAQ,qBAAqB;;;;;;;;;EAS7B,UAAU,qBAAqB;;;;;;EAM/B;;;;;;;;;EASA,iBACM,+BACA,iBAAiB,qBACnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8PU,aACd,SAAS,qBACR,SAAS,eAAe;wBACX,aACd,UAAU,eACV,SAAS,qBACR,QAAQ;;;;;;;wBAydK,oBAAoB,eAAe"}

package/dist/messages/transformers.d.ts

@@ -10,10 +10,10 @@ import { Runnable } from "../runnables/base.js";
 import { BaseLanguageModel } from "../language_models/base.js";
 import { RemoveMessage } from "./modifier.js";
 //#region src/messages/transformers.d.ts
-type MessageUnion = typeof HumanMessage | typeof AIMessage | typeof SystemMessage | typeof ChatMessage | typeof FunctionMessage | typeof ToolMessage | typeof RemoveMessage;
-type MessageChunkUnion = typeof HumanMessageChunk | typeof AIMessageChunk | typeof SystemMessageChunk | typeof FunctionMessageChunk | typeof ToolMessageChunk | typeof ChatMessageChunk | typeof RemoveMessage;
-type MessageTypeOrClass = MessageType | MessageUnion | MessageChunkUnion;
-interface FilterMessagesFields {
+export type MessageUnion = typeof HumanMessage | typeof AIMessage | typeof SystemMessage | typeof ChatMessage | typeof FunctionMessage | typeof ToolMessage | typeof RemoveMessage;
+export type MessageChunkUnion = typeof HumanMessageChunk | typeof AIMessageChunk | typeof SystemMessageChunk | typeof FunctionMessageChunk | typeof ToolMessageChunk | typeof ChatMessageChunk | typeof RemoveMessage;
+export type MessageTypeOrClass = MessageType | MessageUnion | MessageChunkUnion;
+export interface FilterMessagesFields {
   /**
    * @param {string[] | undefined} includeNames Message names to include.
    */
@@ -80,8 +80,8 @@ interface FilterMessagesFields {
  * ]
  * ```
  */
-declare function filterMessages(options?: FilterMessagesFields): Runnable<BaseMessage[], BaseMessage[]>;
-declare function filterMessages(messages: BaseMessage[], options?: FilterMessagesFields): BaseMessage[];
+export declare function filterMessages(options?: FilterMessagesFields): Runnable<BaseMessage[], BaseMessage[]>;
+export declare function filterMessages(messages: BaseMessage[], options?: FilterMessagesFields): BaseMessage[];
 /**
  * Merge consecutive Messages of the same type.
  *
@@ -140,12 +140,12 @@ declare function filterMessages(messages: BaseMessage[], options?: FilterMessage
  * ]
  * ```
  */
-declare function mergeMessageRuns(): Runnable<BaseMessage[], BaseMessage[]>;
-declare function mergeMessageRuns(messages: BaseMessage[]): BaseMessage[];
+export declare function mergeMessageRuns(): Runnable<BaseMessage[], BaseMessage[]>;
+export declare function mergeMessageRuns(messages: BaseMessage[]): BaseMessage[];
 interface _TextSplitterInterface {
   splitText(text: string): Promise<string[]>;
 }
-interface TrimMessagesFields {
+export interface TrimMessagesFields {
   /**
    * @param {number} maxTokens Max token count of trimmed messages.
    */
@@ -455,15 +455,14 @@ interface TrimMessagesFields {
  * ]
  * ```
  */
-declare function trimMessages(options: TrimMessagesFields): Runnable<BaseMessage[], BaseMessage[]>;
-declare function trimMessages(messages: BaseMessage[], options: TrimMessagesFields): Promise<BaseMessage[]>;
+export declare function trimMessages(options: TrimMessagesFields): Runnable<BaseMessage[], BaseMessage[]>;
+export declare function trimMessages(messages: BaseMessage[], options: TrimMessagesFields): Promise<BaseMessage[]>;
 /**
  * The default text splitter function that splits text by newlines.
  *
  * @param {string} text
  * @returns A promise that resolves to an array of strings split by newlines.
  */
-declare function defaultTextSplitter(text: string): Promise<string[]>;
+export declare function defaultTextSplitter(text: string): Promise<string[]>;
 //#endregion
-export { FilterMessagesFields, MessageChunkUnion, MessageTypeOrClass, MessageUnion, TrimMessagesFields, defaultTextSplitter, filterMessages, mergeMessageRuns, trimMessages };
 //# sourceMappingURL=transformers.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"transformers.d.ts","names":[],"sources":["../../src/messages/transformers.ts"],"mappings":";;;;;;;;;;;;KAsBY,sBACD,sBACA,mBACA,uBACA,qBACA,yBACA,qBACA;KACC,2BACD,2BACA,wBACA,4BACA,8BACA,0BACA,0BACA;KACC,qBAAqB,cAAc,eAAe;UAyB7C;;;;EAIf;;;;EAIA;;;;;;EAMA,eAAe;;;;;;EAMf,eAAe;;;;EAIf;;;;EAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwCc,eACd,UAAU,uBACT,SAAS,eAAe;iBACX,eACd,UAAU,eACV,UAAU,uBACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkHa,oBAAoB,SAAS,eAAe;iBAC5C,iBAAiB,UAAU,gBAAgB;UA6CjD;EACR,UAAU,eAAe;;UAGV;;;;EAIf;;;;;;EAMA,gBACM,UAAU,8BACV,UAAU,kBAAkB,mBAC9B;;;;;;;EAOJ;;;;;;;EAOA;;;;;;;;;EASA,QAAQ,qBAAqB;;;;;;;;;EAS7B,UAAU,qBAAqB;;;;;;EAM/B;;;;;;;;;EASA,iBACM,+BACA,iBAAiB,qBACnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8PU,aACd,SAAS,qBACR,SAAS,eAAe;iBACX,aACd,UAAU,eACV,SAAS,qBACR,QAAQ;;;;;;;iBAydK,oBAAoB,eAAe"}
+{"version":3,"file":"transformers.d.ts","names":[],"sources":["../../src/messages/transformers.ts"],"mappings":";;;;;;;;;;;;YAsBY,sBACD,sBACA,mBACA,uBACA,qBACA,yBACA,qBACA;YACC,2BACD,2BACA,wBACA,4BACA,8BACA,0BACA,0BACA;YACC,qBAAqB,cAAc,eAAe;iBAyB7C;;;;EAIf;;;;EAIA;;;;;;EAMA,eAAe;;;;;;EAMf,eAAe;;;;EAIf;;;;EAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAwCc,eACd,UAAU,uBACT,SAAS,eAAe;wBACX,eACd,UAAU,eACV,UAAU,uBACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAkHa,oBAAoB,SAAS,eAAe;wBAC5C,iBAAiB,UAAU,gBAAgB;UA6CjD;EACR,UAAU,eAAe;;iBAGV;;;;EAIf;;;;;;EAMA,gBACM,UAAU,8BACV,UAAU,kBAAkB,mBAC9B;;;;;;;EAOJ;;;;;;;EAOA;;;;;;;;;EASA,QAAQ,qBAAqB;;;;;;;;;EAS7B,UAAU,qBAAqB;;;;;;EAM/B;;;;;;;;;EASA,iBACM,+BACA,iBAAiB,qBACnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8PU,aACd,SAAS,qBACR,SAAS,eAAe;wBACX,aACd,UAAU,eACV,SAAS,qBACR,QAAQ;;;;;;;wBAydK,oBAAoB,eAAe"}

package/dist/messages/utils.d.cts

@@ -7,13 +7,13 @@ import { HumanMessage, HumanMessageChunk } from "./human.cjs";
 import { SystemMessage, SystemMessageChunk } from "./system.cjs";
 import { MessageStructure, MessageToolSet } from "./message.cjs";
 //#region src/messages/utils.d.ts
-type $Expand<T> = T extends (infer U) ? { [K in keyof U]: U[K]; } : never;
+export type $Expand<T> = T extends (infer U) ? { [K in keyof U]: U[K]; } : never;
 /**
  * Provider streaming marker for raw (non-JSON) tool input.
  * Not part of the public {@link ToolCallChunk} type; integrations may attach
  * `isCustomTool` at runtime and pass chunks typed as this alias.
  */
-type RawInputToolCallChunk = ToolCallChunk & {
+export type RawInputToolCallChunk = ToolCallChunk & {
   isCustomTool?: boolean;
 };
 /**
@@ -70,7 +70,7 @@ type $OnlyIndexSignatures<T> = $HasIndexSignature<T> extends true ? [$KnownKeys<
  * // }
  * ```
  */
-type $MergeObjects<T, U> = $OnlyIndexSignatures<U> extends true ? U : $OnlyIndexSignatures<T> extends true ? U : { [K in keyof T | keyof U]: K extends keyof T ? K extends keyof U ? T[K] extends Record<string, unknown> ? U[K] extends Record<string, unknown> ? $MergeObjects<T[K], U[K]> : U[K] : U[K] : T[K] : K extends keyof U ? U[K] : never; };
+export type $MergeObjects<T, U> = $OnlyIndexSignatures<U> extends true ? U : $OnlyIndexSignatures<T> extends true ? U : { [K in keyof T | keyof U]: K extends keyof T ? K extends keyof U ? T[K] extends Record<string, unknown> ? U[K] extends Record<string, unknown> ? $MergeObjects<T[K], U[K]> : U[K] : U[K] : T[K] : K extends keyof U ? U[K] : never; };
 /**
  * Merges two discriminated unions A and B based on a discriminator key (defaults to "type").
  * For each possible value of the discriminator across both unions:
@@ -82,16 +82,16 @@ type $MergeObjects<T, U> = $OnlyIndexSignatures<U> extends true ? U : $OnlyIndex
  * @template B - Second discriminated union type that extends Record<Key, PropertyKey>
  * @template Key - The discriminator key property, defaults to "type"
  */
-type $MergeDiscriminatedUnion<A extends Record<Key, PropertyKey>, B extends Record<Key, PropertyKey>, Key extends PropertyKey = "type"> = { [T in A[Key] | B[Key]]: [Extract<B, Record<Key, T>>] extends [never] ? Extract<A, Record<Key, T>> : [Extract<A, Record<Key, T>>] extends [never] ? Extract<B, Record<Key, T>> : $MergeObjects<Extract<A, Record<Key, T>>, Extract<B, Record<Key, T>>>; }[A[Key] | B[Key]];
-type Constructor<T> = new (...args: unknown[]) => T;
+export type $MergeDiscriminatedUnion<A extends Record<Key, PropertyKey>, B extends Record<Key, PropertyKey>, Key extends PropertyKey = "type"> = { [T in A[Key] | B[Key]]: [Extract<B, Record<Key, T>>] extends [never] ? Extract<A, Record<Key, T>> : [Extract<A, Record<Key, T>>] extends [never] ? Extract<B, Record<Key, T>> : $MergeObjects<Extract<A, Record<Key, T>>, Extract<B, Record<Key, T>>>; }[A[Key] | B[Key]];
+export type Constructor<T> = new (...args: unknown[]) => T;
 /**
  * Immediately-invoked function expression.
  *
  * @param fn - The function to execute
  * @returns The result of the function
  */
-declare const iife: <T>(fn: () => T) => T;
-declare function coerceMessageLikeToMessage(messageLike: BaseMessageLike): BaseMessage;
+export declare const iife: <T>(fn: () => T) => T;
+export declare function coerceMessageLikeToMessage(messageLike: BaseMessageLike): BaseMessage;
 /**
  * This function is used by memory classes to get a string representation
  * of the chat message history, based on the message content and role.
@@ -106,8 +106,8 @@ declare function coerceMessageLikeToMessage(messageLike: BaseMessageLike): BaseM
  * This avoids token inflation from metadata when stringifying message objects directly.
  * Tool-call IDs longer than 64 characters are shortened only in the rendered string.
  */
-declare function getBufferString(messages: BaseMessage[], humanPrefix?: string, aiPrefix?: string): string;
-declare function mapStoredMessageToChatMessage(message: StoredMessage): AIMessage<MessageStructure<MessageToolSet>> | ChatMessage<MessageStructure<MessageToolSet>> | FunctionMessage<MessageStructure<MessageToolSet>> | HumanMessage<MessageStructure<MessageToolSet>> | SystemMessage<MessageStructure<MessageToolSet>> | ToolMessage<MessageStructure<MessageToolSet>>;
+export declare function getBufferString(messages: BaseMessage[], humanPrefix?: string, aiPrefix?: string): string;
+export declare function mapStoredMessageToChatMessage(message: StoredMessage): AIMessage<MessageStructure<MessageToolSet>> | ChatMessage<MessageStructure<MessageToolSet>> | FunctionMessage<MessageStructure<MessageToolSet>> | HumanMessage<MessageStructure<MessageToolSet>> | SystemMessage<MessageStructure<MessageToolSet>> | ToolMessage<MessageStructure<MessageToolSet>>;
 /**
  * Transforms an array of `StoredMessage` instances into an array of
  * `BaseMessage` instances. It uses the `mapV1MessageToStoredMessage`
@@ -116,15 +116,15 @@ declare function mapStoredMessageToChatMessage(message: StoredMessage): AIMessag
  * on the type of each message. This function is used to prepare stored
  * messages for use in a chat context.
  */
-declare function mapStoredMessagesToChatMessages(messages: StoredMessage[]): BaseMessage[];
+export declare function mapStoredMessagesToChatMessages(messages: StoredMessage[]): BaseMessage[];
 /**
  * Transforms an array of `BaseMessage` instances into an array of
  * `StoredMessage` instances. It does this by calling the `toDict` method
  * on each `BaseMessage`, which returns a `StoredMessage`. This function
  * is used to prepare chat messages for storage.
  */
-declare function mapChatMessagesToStoredMessages(messages: BaseMessage[]): StoredMessage[];
-declare function convertToChunk(message: BaseMessage): AIMessageChunk<MessageStructure<MessageToolSet>> | ChatMessageChunk<MessageStructure<MessageToolSet>> | FunctionMessageChunk<MessageStructure<MessageToolSet>> | HumanMessageChunk<MessageStructure<MessageToolSet>> | SystemMessageChunk<MessageStructure<MessageToolSet>>;
+export declare function mapChatMessagesToStoredMessages(messages: BaseMessage[]): StoredMessage[];
+export declare function convertToChunk(message: BaseMessage): AIMessageChunk<MessageStructure<MessageToolSet>> | ChatMessageChunk<MessageStructure<MessageToolSet>> | FunctionMessageChunk<MessageStructure<MessageToolSet>> | HumanMessageChunk<MessageStructure<MessageToolSet>> | SystemMessageChunk<MessageStructure<MessageToolSet>>;
 /**
  * Collapses an array of tool call chunks into complete tool calls.
  *
@@ -151,11 +151,10 @@ declare function convertToChunk(message: BaseMessage): AIMessageChunk<MessageStr
  * 3. Validates that the result is a non-null object with a valid id
  * 4. Creates either a `ToolCall` (if valid) or `InvalidToolCall` (if invalid)
  */
-declare function collapseToolCallChunks(chunks: ToolCallChunk[]): {
+export declare function collapseToolCallChunks(chunks: ToolCallChunk[]): {
   tool_call_chunks: ToolCallChunk[];
   tool_calls: ToolCall[];
   invalid_tool_calls: InvalidToolCall[];
 };
 //#endregion
-export { $Expand, $MergeDiscriminatedUnion, $MergeObjects, Constructor, RawInputToolCallChunk, coerceMessageLikeToMessage, collapseToolCallChunks, convertToChunk, getBufferString, iife, mapChatMessagesToStoredMessages, mapStoredMessageToChatMessage, mapStoredMessagesToChatMessages };
 //# sourceMappingURL=utils.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.cts","names":[],"sources":["../../src/messages/utils.ts"],"mappings":";;;;;;;;;KA+BY,QAAQ,KAAK,iBAAgB,QAAO,WAAW,IAAI,EAAE;;;;;;KAOrD,wBAAwB;EAAkB;;;;;;;;KAYjD,WAAW,QACb,WAAW,mBAAmB,2BAEZ,2BAEE,YAEb,WACF;;;;;;;KAQH,mBAAmB,0BAA0B,gCAEzB,gCAEE;;;;;;;KAUtB,qBAAqB,KACxB,mBAAmB,mBACd,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAsCN,cAAc,GAAG,KAE3B,qBAAqB,kBACjB,IAEA,qBAAqB,kBACnB,OAEG,WAAW,UAAU,IAAI,gBAAgB,IACtC,gBAAgB,IACd,EAAE,WAAW,0BACX,EAAE,WAAW,0BACX,cAAc,EAAE,IAAI,EAAE,MACtB,EAAE,KACJ,EAAE,KACJ,EAAE,KACJ,gBAAgB,IACd,EAAE;;;;;;;;;;;;KAeN,yBACV,UAAU,OAAO,KAAK,cACtB,UAAU,OAAO,KAAK,cACtB,YAAY,2BAGX,KAAK,EAAE,OAAO,EAAE,QAAQ,QAAQ,GAAG,OAAO,KAAK,uBAE5C,QAAQ,GAAG,OAAO,KAAK,OAEtB,QAAQ,GAAG,OAAO,KAAK,uBACtB,QAAQ,GAAG,OAAO,KAAK,MACvB,cAAc,QAAQ,GAAG,OAAO,KAAK,KAAK,QAAQ,GAAG,OAAO,KAAK,QAGvE,EAAE,OAAO,EAAE;KAED,YAAY,aAAa,oBAAoB;;;;;;;cAQ5C,OAAQ,GAAC,UAAY,MAAC;iBA0HnB,2BACd,aAAa,kBACZ;;;;;;;;;;;;;;;iBAwEa,gBACd,UAAU,eACV,sBACA;iBA0Fc,8BAA8B,SAAS,gBAAa,UAAA,iBAAb,mBAAa,YAAA,iBAAA,mBAAA,gBAAA,iBAAA,mBAAA,aAAA,iBAAA,mBAAA,cAAA,iBAAA,mBAAA,YAAA,iBAAA;;;;;;;;;iBAsCpD,gCACd,UAAU,kBACT;;;;;;;iBAUa,gCACd,UAAU,gBACT;iBAIa,eAAe,SAAS,cAAW,eAAA,iBAAX,mBAAW,iBAAA,iBAAA,mBAAA,qBAAA,iBAAA,mBAAA,kBAAA,iBAAA,mBAAA,mBAAA,iBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyDnC,uBAAuB,QAAQ;EAC7C,kBAAkB;EAClB,YAAY;EACZ,oBAAoB"}
+{"version":3,"file":"utils.d.cts","names":["_$__message_js0.MessageToolSet","_$__message_js0.MessageStructure"],"sources":["../../src/messages/utils.ts"],"mappings":";;;;;;;;;YA+BY,QAAQ,KAAK,iBAAgB,QAAO,WAAW,IAAI,EAAE;;;;;;YAOrD,wBAAwB;EAAkB;;;;;;;;KAYjD,WAAW,QACb,WAAW,mBAAmB,2BAEZ,2BAEE,YAEb,WACF;;;;;;;KAQH,mBAAmB,0BAA0B,gCAEzB,gCAEE;;;;;;;KAUtB,qBAAqB,KACxB,mBAAmB,mBACd,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAsCN,cAAc,GAAG,KAE3B,qBAAqB,kBACjB,IAEA,qBAAqB,kBACnB,OAEG,WAAW,UAAU,IAAI,gBAAgB,IACtC,gBAAgB,IACd,EAAE,WAAW,0BACX,EAAE,WAAW,0BACX,cAAc,EAAE,IAAI,EAAE,MACtB,EAAE,KACJ,EAAE,KACJ,EAAE,KACJ,gBAAgB,IACd,EAAE;;;;;;;;;;;;YAeN,yBACV,UAAU,OAAO,KAAK,cACtB,UAAU,OAAO,KAAK,cACtB,YAAY,2BAGX,KAAK,EAAE,OAAO,EAAE,QAAQ,QAAQ,GAAG,OAAO,KAAK,uBAE5C,QAAQ,GAAG,OAAO,KAAK,OAEtB,QAAQ,GAAG,OAAO,KAAK,uBACtB,QAAQ,GAAG,OAAO,KAAK,MACvB,cAAc,QAAQ,GAAG,OAAO,KAAK,KAAK,QAAQ,GAAG,OAAO,KAAK,QAGvE,EAAE,OAAO,EAAE;YAED,YAAY,aAAa,oBAAoB;;;;;;;qBAQ5C,OAAQ,GAAC,UAAY,MAAC;wBA0HnB,2BACd,aAAa,kBACZ;;;;;;;;;;;;;;;wBAwEa,gBACd,UAAU,eACV,sBACA;wBA0Fc,8BAA8B,SAAS,gBAAa,UAAAC,iBAAbD,mBAAa,YAAAC,iBAAAD,mBAAA,gBAAAC,iBAAAD,mBAAA,aAAAC,iBAAAD,mBAAA,cAAAC,iBAAAD,mBAAA,YAAAC,iBAAAD;;;;;;;;;wBAsCpD,gCACd,UAAU,kBACT;;;;;;;wBAUa,gCACd,UAAU,gBACT;wBAIa,eAAe,SAAS,cAAW,eAAAC,iBAAXD,mBAAW,iBAAAC,iBAAAD,mBAAA,qBAAAC,iBAAAD,mBAAA,kBAAAC,iBAAAD,mBAAA,mBAAAC,iBAAAD;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAyDnC,uBAAuB,QAAQ;EAC7C,kBAAkB;EAClB,YAAY;EACZ,oBAAoB"}

package/dist/messages/utils.d.ts

@@ -7,13 +7,13 @@ import { HumanMessage, HumanMessageChunk } from "./human.js";
 import { SystemMessage, SystemMessageChunk } from "./system.js";
 import { MessageStructure, MessageToolSet } from "./message.js";
 //#region src/messages/utils.d.ts
-type $Expand<T> = T extends (infer U) ? { [K in keyof U]: U[K]; } : never;
+export type $Expand<T> = T extends (infer U) ? { [K in keyof U]: U[K]; } : never;
 /**
  * Provider streaming marker for raw (non-JSON) tool input.
  * Not part of the public {@link ToolCallChunk} type; integrations may attach
  * `isCustomTool` at runtime and pass chunks typed as this alias.
  */
-type RawInputToolCallChunk = ToolCallChunk & {
+export type RawInputToolCallChunk = ToolCallChunk & {
   isCustomTool?: boolean;
 };
 /**
@@ -70,7 +70,7 @@ type $OnlyIndexSignatures<T> = $HasIndexSignature<T> extends true ? [$KnownKeys<
  * // }
  * ```
  */
-type $MergeObjects<T, U> = $OnlyIndexSignatures<U> extends true ? U : $OnlyIndexSignatures<T> extends true ? U : { [K in keyof T | keyof U]: K extends keyof T ? K extends keyof U ? T[K] extends Record<string, unknown> ? U[K] extends Record<string, unknown> ? $MergeObjects<T[K], U[K]> : U[K] : U[K] : T[K] : K extends keyof U ? U[K] : never; };
+export type $MergeObjects<T, U> = $OnlyIndexSignatures<U> extends true ? U : $OnlyIndexSignatures<T> extends true ? U : { [K in keyof T | keyof U]: K extends keyof T ? K extends keyof U ? T[K] extends Record<string, unknown> ? U[K] extends Record<string, unknown> ? $MergeObjects<T[K], U[K]> : U[K] : U[K] : T[K] : K extends keyof U ? U[K] : never; };
 /**
  * Merges two discriminated unions A and B based on a discriminator key (defaults to "type").
  * For each possible value of the discriminator across both unions:
@@ -82,16 +82,16 @@ type $MergeObjects<T, U> = $OnlyIndexSignatures<U> extends true ? U : $OnlyIndex
  * @template B - Second discriminated union type that extends Record<Key, PropertyKey>
  * @template Key - The discriminator key property, defaults to "type"
  */
-type $MergeDiscriminatedUnion<A extends Record<Key, PropertyKey>, B extends Record<Key, PropertyKey>, Key extends PropertyKey = "type"> = { [T in A[Key] | B[Key]]: [Extract<B, Record<Key, T>>] extends [never] ? Extract<A, Record<Key, T>> : [Extract<A, Record<Key, T>>] extends [never] ? Extract<B, Record<Key, T>> : $MergeObjects<Extract<A, Record<Key, T>>, Extract<B, Record<Key, T>>>; }[A[Key] | B[Key]];
-type Constructor<T> = new (...args: unknown[]) => T;
+export type $MergeDiscriminatedUnion<A extends Record<Key, PropertyKey>, B extends Record<Key, PropertyKey>, Key extends PropertyKey = "type"> = { [T in A[Key] | B[Key]]: [Extract<B, Record<Key, T>>] extends [never] ? Extract<A, Record<Key, T>> : [Extract<A, Record<Key, T>>] extends [never] ? Extract<B, Record<Key, T>> : $MergeObjects<Extract<A, Record<Key, T>>, Extract<B, Record<Key, T>>>; }[A[Key] | B[Key]];
+export type Constructor<T> = new (...args: unknown[]) => T;
 /**
  * Immediately-invoked function expression.
  *
  * @param fn - The function to execute
  * @returns The result of the function
  */
-declare const iife: <T>(fn: () => T) => T;
-declare function coerceMessageLikeToMessage(messageLike: BaseMessageLike): BaseMessage;
+export declare const iife: <T>(fn: () => T) => T;
+export declare function coerceMessageLikeToMessage(messageLike: BaseMessageLike): BaseMessage;
 /**
  * This function is used by memory classes to get a string representation
  * of the chat message history, based on the message content and role.
@@ -106,8 +106,8 @@ declare function coerceMessageLikeToMessage(messageLike: BaseMessageLike): BaseM
  * This avoids token inflation from metadata when stringifying message objects directly.
  * Tool-call IDs longer than 64 characters are shortened only in the rendered string.
  */
-declare function getBufferString(messages: BaseMessage[], humanPrefix?: string, aiPrefix?: string): string;
-declare function mapStoredMessageToChatMessage(message: StoredMessage): AIMessage<MessageStructure<MessageToolSet>> | ChatMessage<MessageStructure<MessageToolSet>> | FunctionMessage<MessageStructure<MessageToolSet>> | HumanMessage<MessageStructure<MessageToolSet>> | SystemMessage<MessageStructure<MessageToolSet>> | ToolMessage<MessageStructure<MessageToolSet>>;
+export declare function getBufferString(messages: BaseMessage[], humanPrefix?: string, aiPrefix?: string): string;
+export declare function mapStoredMessageToChatMessage(message: StoredMessage): AIMessage<MessageStructure<MessageToolSet>> | ChatMessage<MessageStructure<MessageToolSet>> | FunctionMessage<MessageStructure<MessageToolSet>> | HumanMessage<MessageStructure<MessageToolSet>> | SystemMessage<MessageStructure<MessageToolSet>> | ToolMessage<MessageStructure<MessageToolSet>>;
 /**
  * Transforms an array of `StoredMessage` instances into an array of
  * `BaseMessage` instances. It uses the `mapV1MessageToStoredMessage`
@@ -116,15 +116,15 @@ declare function mapStoredMessageToChatMessage(message: StoredMessage): AIMessag
  * on the type of each message. This function is used to prepare stored
  * messages for use in a chat context.
  */
-declare function mapStoredMessagesToChatMessages(messages: StoredMessage[]): BaseMessage[];
+export declare function mapStoredMessagesToChatMessages(messages: StoredMessage[]): BaseMessage[];
 /**
  * Transforms an array of `BaseMessage` instances into an array of
  * `StoredMessage` instances. It does this by calling the `toDict` method
  * on each `BaseMessage`, which returns a `StoredMessage`. This function
  * is used to prepare chat messages for storage.
  */
-declare function mapChatMessagesToStoredMessages(messages: BaseMessage[]): StoredMessage[];
-declare function convertToChunk(message: BaseMessage): AIMessageChunk<MessageStructure<MessageToolSet>> | ChatMessageChunk<MessageStructure<MessageToolSet>> | FunctionMessageChunk<MessageStructure<MessageToolSet>> | HumanMessageChunk<MessageStructure<MessageToolSet>> | SystemMessageChunk<MessageStructure<MessageToolSet>>;
+export declare function mapChatMessagesToStoredMessages(messages: BaseMessage[]): StoredMessage[];
+export declare function convertToChunk(message: BaseMessage): AIMessageChunk<MessageStructure<MessageToolSet>> | ChatMessageChunk<MessageStructure<MessageToolSet>> | FunctionMessageChunk<MessageStructure<MessageToolSet>> | HumanMessageChunk<MessageStructure<MessageToolSet>> | SystemMessageChunk<MessageStructure<MessageToolSet>>;
 /**
  * Collapses an array of tool call chunks into complete tool calls.
  *
@@ -151,11 +151,10 @@ declare function convertToChunk(message: BaseMessage): AIMessageChunk<MessageStr
  * 3. Validates that the result is a non-null object with a valid id
  * 4. Creates either a `ToolCall` (if valid) or `InvalidToolCall` (if invalid)
  */
-declare function collapseToolCallChunks(chunks: ToolCallChunk[]): {
+export declare function collapseToolCallChunks(chunks: ToolCallChunk[]): {
   tool_call_chunks: ToolCallChunk[];
   tool_calls: ToolCall[];
   invalid_tool_calls: InvalidToolCall[];
 };
 //#endregion
-export { $Expand, $MergeDiscriminatedUnion, $MergeObjects, Constructor, RawInputToolCallChunk, coerceMessageLikeToMessage, collapseToolCallChunks, convertToChunk, getBufferString, iife, mapChatMessagesToStoredMessages, mapStoredMessageToChatMessage, mapStoredMessagesToChatMessages };
 //# sourceMappingURL=utils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","names":[],"sources":["../../src/messages/utils.ts"],"mappings":";;;;;;;;;KA+BY,QAAQ,KAAK,iBAAgB,QAAO,WAAW,IAAI,EAAE;;;;;;KAOrD,wBAAwB;EAAkB;;;;;;;;KAYjD,WAAW,QACb,WAAW,mBAAmB,2BAEZ,2BAEE,YAEb,WACF;;;;;;;KAQH,mBAAmB,0BAA0B,gCAEzB,gCAEE;;;;;;;KAUtB,qBAAqB,KACxB,mBAAmB,mBACd,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAsCN,cAAc,GAAG,KAE3B,qBAAqB,kBACjB,IAEA,qBAAqB,kBACnB,OAEG,WAAW,UAAU,IAAI,gBAAgB,IACtC,gBAAgB,IACd,EAAE,WAAW,0BACX,EAAE,WAAW,0BACX,cAAc,EAAE,IAAI,EAAE,MACtB,EAAE,KACJ,EAAE,KACJ,EAAE,KACJ,gBAAgB,IACd,EAAE;;;;;;;;;;;;KAeN,yBACV,UAAU,OAAO,KAAK,cACtB,UAAU,OAAO,KAAK,cACtB,YAAY,2BAGX,KAAK,EAAE,OAAO,EAAE,QAAQ,QAAQ,GAAG,OAAO,KAAK,uBAE5C,QAAQ,GAAG,OAAO,KAAK,OAEtB,QAAQ,GAAG,OAAO,KAAK,uBACtB,QAAQ,GAAG,OAAO,KAAK,MACvB,cAAc,QAAQ,GAAG,OAAO,KAAK,KAAK,QAAQ,GAAG,OAAO,KAAK,QAGvE,EAAE,OAAO,EAAE;KAED,YAAY,aAAa,oBAAoB;;;;;;;cAQ5C,OAAQ,GAAC,UAAY,MAAC;iBA0HnB,2BACd,aAAa,kBACZ;;;;;;;;;;;;;;;iBAwEa,gBACd,UAAU,eACV,sBACA;iBA0Fc,8BAA8B,SAAS,gBAAa,UAAA,iBAAb,mBAAa,YAAA,iBAAA,mBAAA,gBAAA,iBAAA,mBAAA,aAAA,iBAAA,mBAAA,cAAA,iBAAA,mBAAA,YAAA,iBAAA;;;;;;;;;iBAsCpD,gCACd,UAAU,kBACT;;;;;;;iBAUa,gCACd,UAAU,gBACT;iBAIa,eAAe,SAAS,cAAW,eAAA,iBAAX,mBAAW,iBAAA,iBAAA,mBAAA,qBAAA,iBAAA,mBAAA,kBAAA,iBAAA,mBAAA,mBAAA,iBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyDnC,uBAAuB,QAAQ;EAC7C,kBAAkB;EAClB,YAAY;EACZ,oBAAoB"}
+{"version":3,"file":"utils.d.ts","names":["_$__message_js0.MessageToolSet","_$__message_js0.MessageStructure"],"sources":["../../src/messages/utils.ts"],"mappings":";;;;;;;;;YA+BY,QAAQ,KAAK,iBAAgB,QAAO,WAAW,IAAI,EAAE;;;;;;YAOrD,wBAAwB;EAAkB;;;;;;;;KAYjD,WAAW,QACb,WAAW,mBAAmB,2BAEZ,2BAEE,YAEb,WACF;;;;;;;KAQH,mBAAmB,0BAA0B,gCAEzB,gCAEE;;;;;;;KAUtB,qBAAqB,KACxB,mBAAmB,mBACd,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAsCN,cAAc,GAAG,KAE3B,qBAAqB,kBACjB,IAEA,qBAAqB,kBACnB,OAEG,WAAW,UAAU,IAAI,gBAAgB,IACtC,gBAAgB,IACd,EAAE,WAAW,0BACX,EAAE,WAAW,0BACX,cAAc,EAAE,IAAI,EAAE,MACtB,EAAE,KACJ,EAAE,KACJ,EAAE,KACJ,gBAAgB,IACd,EAAE;;;;;;;;;;;;YAeN,yBACV,UAAU,OAAO,KAAK,cACtB,UAAU,OAAO,KAAK,cACtB,YAAY,2BAGX,KAAK,EAAE,OAAO,EAAE,QAAQ,QAAQ,GAAG,OAAO,KAAK,uBAE5C,QAAQ,GAAG,OAAO,KAAK,OAEtB,QAAQ,GAAG,OAAO,KAAK,uBACtB,QAAQ,GAAG,OAAO,KAAK,MACvB,cAAc,QAAQ,GAAG,OAAO,KAAK,KAAK,QAAQ,GAAG,OAAO,KAAK,QAGvE,EAAE,OAAO,EAAE;YAED,YAAY,aAAa,oBAAoB;;;;;;;qBAQ5C,OAAQ,GAAC,UAAY,MAAC;wBA0HnB,2BACd,aAAa,kBACZ;;;;;;;;;;;;;;;wBAwEa,gBACd,UAAU,eACV,sBACA;wBA0Fc,8BAA8B,SAAS,gBAAa,UAAAC,iBAAbD,mBAAa,YAAAC,iBAAAD,mBAAA,gBAAAC,iBAAAD,mBAAA,aAAAC,iBAAAD,mBAAA,cAAAC,iBAAAD,mBAAA,YAAAC,iBAAAD;;;;;;;;;wBAsCpD,gCACd,UAAU,kBACT;;;;;;;wBAUa,gCACd,UAAU,gBACT;wBAIa,eAAe,SAAS,cAAW,eAAAC,iBAAXD,mBAAW,iBAAAC,iBAAAD,mBAAA,qBAAAC,iBAAAD,mBAAA,kBAAAC,iBAAAD,mBAAA,mBAAAC,iBAAAD;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAyDnC,uBAAuB,QAAQ;EAC7C,kBAAkB;EAClB,YAAY;EACZ,oBAAoB"}

package/dist/output_parsers/base.d.cts

@@ -12,13 +12,13 @@ import "../runnables/index.cjs";
 /**
  * Options for formatting instructions.
  */
-interface FormatInstructionsOptions {}
+export interface FormatInstructionsOptions {}
 /**
  * Abstract base class for parsing the output of a Large Language Model
  * (LLM) call. It provides methods for parsing the result of an LLM call
  * and invoking the parser with a given input.
  */
-declare abstract class BaseLLMOutputParser<T = unknown> extends Runnable<string | BaseMessage, T> {
+export declare abstract class BaseLLMOutputParser<T = unknown> extends Runnable<string | BaseMessage, T> {
   /**
    * Parses the result of an LLM call. This method is meant to be
    * implemented by subclasses to define how the output from the LLM should
@@ -54,7 +54,7 @@ declare abstract class BaseLLMOutputParser<T = unknown> extends Runnable<string
 /**
  * Class to parse the output of an LLM call.
  */
-declare abstract class BaseOutputParser<T = unknown> extends BaseLLMOutputParser<T> {
+export declare abstract class BaseOutputParser<T = unknown> extends BaseLLMOutputParser<T> {
   parseResult(generations: Generation[] | ChatGeneration[], callbacks?: Callbacks): Promise<T>;
   /**
    * Parse the output of an LLM call.
@@ -99,12 +99,11 @@ declare abstract class BaseOutputParser<T = unknown> extends BaseLLMOutputParser
  *     structured, in the hopes that it will update the output to the correct
  *     format.
  */
-declare class OutputParserException extends Error {
+export declare class OutputParserException extends Error {
   llmOutput?: string;
   observation?: string;
   sendToLLM: boolean;
   constructor(message: string, llmOutput?: string, observation?: string, sendToLLM?: boolean);
 }
 //#endregion
-export { BaseLLMOutputParser, BaseOutputParser, FormatInstructionsOptions, OutputParserException };
 //# sourceMappingURL=base.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"base.d.cts","names":[],"sources":["../../src/output_parsers/base.ts"],"mappings":";;;;;;;;;;;;;;UAWiB;;;;;;uBAOK,oBAAoB,qBAAqB,kBACpD,aACT;;;;;;;;;WAUS,YACP,aAAa,eAAe,kBAC5B,YAAY,YACX,QAAQ;;;;;;;;;EAUX,sBACE,aAAa,eAAe,kBAC5B,SAAS,0BACT,YAAY,YACX,QAAQ;YAID,qBAAqB,SAAS;YAM9B,4BAA4B,SAAS;;;;;;;;;;;EAczC,OACJ,gBAAgB,aAChB,UAAU,iBACT,QAAQ;;;;;uBA8BS,iBACpB,qBACQ,oBAAoB;EAC5B,YACE,aAAa,eAAe,kBAC5B,YAAY,YACX,QAAQ;;;;;;;WAUF,MAAM,cAAc,YAAY,YAAY,QAAQ;EAEvD,gBACJ,cACA,SAAS,0BACT,YAAY,YACX,QAAQ;;;;;;;;;;;;WAeF,sBAAsB,UAAU;;;;EAKzC;;;;;;;;;;;;;;;;;;;;cAuBW,8BAA8B;EACzC;EAEA;EAEA;EAEA,YACE,iBACA,oBACA,sBACA"}
+{"version":3,"file":"base.d.cts","names":[],"sources":["../../src/output_parsers/base.ts"],"mappings":";;;;;;;;;;;;;;iBAWiB;;;;;;8BAOK,oBAAoB,qBAAqB,kBACpD,aACT;;;;;;;;;WAUS,YACP,aAAa,eAAe,kBAC5B,YAAY,YACX,QAAQ;;;;;;;;;EAUX,sBACE,aAAa,eAAe,kBAC5B,SAAS,0BACT,YAAY,YACX,QAAQ;YAID,qBAAqB,SAAS;YAM9B,4BAA4B,SAAS;;;;;;;;;;;EAczC,OACJ,gBAAgB,aAChB,UAAU,iBACT,QAAQ;;;;;8BA8BS,iBACpB,qBACQ,oBAAoB;EAC5B,YACE,aAAa,eAAe,kBAC5B,YAAY,YACX,QAAQ;;;;;;;WAUF,MAAM,cAAc,YAAY,YAAY,QAAQ;EAEvD,gBACJ,cACA,SAAS,0BACT,YAAY,YACX,QAAQ;;;;;;;;;;;;WAeF,sBAAsB,UAAU;;;;EAKzC;;;;;;;;;;;;;;;;;;;;qBAuBW,8BAA8B;EACzC;EAEA;EAEA;EAEA,YACE,iBACA,oBACA,sBACA"}