@langchain/core 1.0.6 → 1.1.0

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

@@ -1 +0,0 @@
-{"version":3,"file":"serializable.d.cts","names":["SerializedFields","BaseSerialized","T","Record","SerializedConstructor","SerializedSecret","SerializedNotImplemented","Serialized","get_lc_unique_name","Serializable","SerializableInterface"],"sources":["../../src/load/serializable.d.ts"],"sourcesContent":["import { type SerializedFields } from \"./map_keys.js\";\nexport interface BaseSerialized<T extends string> {\n    lc: number;\n    type: T;\n    id: string[];\n    name?: string;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    graph?: Record<string, any>;\n}\nexport interface SerializedConstructor extends BaseSerialized<\"constructor\"> {\n    kwargs: SerializedFields;\n}\nexport interface SerializedSecret extends BaseSerialized<\"secret\"> {\n}\nexport interface SerializedNotImplemented extends BaseSerialized<\"not_implemented\"> {\n}\nexport type Serialized = SerializedConstructor | SerializedSecret | SerializedNotImplemented;\n/**\n * Get a unique name for the module, rather than parent class implementations.\n * Should not be subclassed, subclass lc_name above instead.\n */\nexport declare function get_lc_unique_name(serializableClass: typeof Serializable): string;\nexport interface SerializableInterface {\n    get lc_id(): string[];\n}\nexport declare abstract class Serializable implements SerializableInterface {\n    lc_serializable: boolean;\n    lc_kwargs: SerializedFields;\n    /**\n     * A path to the module that contains the class, eg. [\"langchain\", \"llms\"]\n     * Usually should be the same as the entrypoint the class is exported from.\n     */\n    abstract lc_namespace: string[];\n    /**\n     * The name of the serializable. Override to provide an alias or\n     * to preserve the serialized module name in minified environments.\n     *\n     * Implemented as a static method to support loading logic.\n     */\n    static lc_name(): string;\n    /**\n     * The final serialized identifier for the module.\n     */\n    get lc_id(): string[];\n    /**\n     * A map of secrets, which will be omitted from serialization.\n     * Keys are paths to the secret in constructor args, e.g. \"foo.bar.baz\".\n     * Values are the secret ids, which will be used when deserializing.\n     */\n    get lc_secrets(): {\n        [key: string]: string;\n    } | undefined;\n    /**\n     * A map of additional attributes to merge with constructor args.\n     * Keys are the attribute names, e.g. \"foo\".\n     * Values are the attribute values, which will be serialized.\n     * These attributes need to be accepted by the constructor as arguments.\n     */\n    get lc_attributes(): SerializedFields | undefined;\n    /**\n     * A map of aliases for constructor args.\n     * Keys are the attribute names, e.g. \"foo\".\n     * Values are the alias that will replace the key in serialization.\n     * This is used to eg. make argument names match Python.\n     */\n    get lc_aliases(): {\n        [key: string]: string;\n    } | undefined;\n    /**\n     * A manual list of keys that should be serialized.\n     * If not overridden, all fields passed into the constructor will be serialized.\n     */\n    get lc_serializable_keys(): string[] | undefined;\n    constructor(kwargs?: SerializedFields, ..._args: never[]);\n    toJSON(): Serialized;\n    toJSONNotImplemented(): SerializedNotImplemented;\n}\n"],"mappings":";;;UACiBC;;EAAAA,IAAAA,EAEPC,CAFOD;EAAc,EAAA,EAAA,MAAA,EAAA;EAAA,IAErBC,CAAAA,EAAAA,MAAAA;EAAC;EAIO,KAAA,CAAA,EAANC,MAAM,CAAA,MAAA,EAAA,GAAA,CAAA;AAElB;AAAsC,UAArBC,qBAAAA,SAA8BH,cAAT,CAAA,aAAA,CAAA,CAAA;EAAA,MAC1BD,EAAAA,gBAAAA;;AADiD,UAG5CK,gBAAAA,SAAyBJ,cAHmB,CAAA,QAAA,CAAA,CAAA,CAG7D;AAEiBK,UAAAA,wBAAAA,SAAiCL,cAAc,CAAA,iBAAA,CAAA,CAAA,CAEhE;AAAsB,KAAVM,UAAAA,GAAaH,qBAAH,GAA2BC,gBAA3B,GAA8CC,wBAA9C;;;;AAAsE;AAKpEE,iBAAAA,kBAAAA,CAA6CC,iBAAY,EAAA,OAAZA,YAAY,CAAA,EAAA,MAAA;AAChEC,UAAAA,qBAAAA,CAAqB;EAGRD,IAAAA,KAAAA,EAAAA,EAAAA,MAAY,EAAA;;AAE3BT,uBAFeS,YAAAA,YAAwBC,qBAEvCV,CAAAA;EAAgB,eA+BNA,EAAAA,OAAAA;EAAgB,SAehBA,EA9CVA,gBA8CUA;EAAgB;;;AAhDkC;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAiClDA;;;;;;;;;;;;;;;uBAeAA;YACXO;0BACcD"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"serializable.d.ts","names":["SerializedFields","BaseSerialized","T","Record","SerializedConstructor","SerializedSecret","SerializedNotImplemented","Serialized","get_lc_unique_name","Serializable","SerializableInterface"],"sources":["../../src/load/serializable.d.ts"],"sourcesContent":["import { type SerializedFields } from \"./map_keys.js\";\nexport interface BaseSerialized<T extends string> {\n    lc: number;\n    type: T;\n    id: string[];\n    name?: string;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    graph?: Record<string, any>;\n}\nexport interface SerializedConstructor extends BaseSerialized<\"constructor\"> {\n    kwargs: SerializedFields;\n}\nexport interface SerializedSecret extends BaseSerialized<\"secret\"> {\n}\nexport interface SerializedNotImplemented extends BaseSerialized<\"not_implemented\"> {\n}\nexport type Serialized = SerializedConstructor | SerializedSecret | SerializedNotImplemented;\n/**\n * Get a unique name for the module, rather than parent class implementations.\n * Should not be subclassed, subclass lc_name above instead.\n */\nexport declare function get_lc_unique_name(serializableClass: typeof Serializable): string;\nexport interface SerializableInterface {\n    get lc_id(): string[];\n}\nexport declare abstract class Serializable implements SerializableInterface {\n    lc_serializable: boolean;\n    lc_kwargs: SerializedFields;\n    /**\n     * A path to the module that contains the class, eg. [\"langchain\", \"llms\"]\n     * Usually should be the same as the entrypoint the class is exported from.\n     */\n    abstract lc_namespace: string[];\n    /**\n     * The name of the serializable. Override to provide an alias or\n     * to preserve the serialized module name in minified environments.\n     *\n     * Implemented as a static method to support loading logic.\n     */\n    static lc_name(): string;\n    /**\n     * The final serialized identifier for the module.\n     */\n    get lc_id(): string[];\n    /**\n     * A map of secrets, which will be omitted from serialization.\n     * Keys are paths to the secret in constructor args, e.g. \"foo.bar.baz\".\n     * Values are the secret ids, which will be used when deserializing.\n     */\n    get lc_secrets(): {\n        [key: string]: string;\n    } | undefined;\n    /**\n     * A map of additional attributes to merge with constructor args.\n     * Keys are the attribute names, e.g. \"foo\".\n     * Values are the attribute values, which will be serialized.\n     * These attributes need to be accepted by the constructor as arguments.\n     */\n    get lc_attributes(): SerializedFields | undefined;\n    /**\n     * A map of aliases for constructor args.\n     * Keys are the attribute names, e.g. \"foo\".\n     * Values are the alias that will replace the key in serialization.\n     * This is used to eg. make argument names match Python.\n     */\n    get lc_aliases(): {\n        [key: string]: string;\n    } | undefined;\n    /**\n     * A manual list of keys that should be serialized.\n     * If not overridden, all fields passed into the constructor will be serialized.\n     */\n    get lc_serializable_keys(): string[] | undefined;\n    constructor(kwargs?: SerializedFields, ..._args: never[]);\n    toJSON(): Serialized;\n    toJSONNotImplemented(): SerializedNotImplemented;\n}\n"],"mappings":";;;UACiBC;;EAAAA,IAAAA,EAEPC,CAFOD;EAAc,EAAA,EAAA,MAAA,EAAA;EAAA,IAErBC,CAAAA,EAAAA,MAAAA;EAAC;EAIO,KAAA,CAAA,EAANC,MAAM,CAAA,MAAA,EAAA,GAAA,CAAA;AAElB;AAAsC,UAArBC,qBAAAA,SAA8BH,cAAT,CAAA,aAAA,CAAA,CAAA;EAAA,MAC1BD,EAAAA,gBAAAA;;AADiD,UAG5CK,gBAAAA,SAAyBJ,cAHmB,CAAA,QAAA,CAAA,CAAA,CAG7D;AAEiBK,UAAAA,wBAAAA,SAAiCL,cAAc,CAAA,iBAAA,CAAA,CAAA,CAEhE;AAAsB,KAAVM,UAAAA,GAAaH,qBAAH,GAA2BC,gBAA3B,GAA8CC,wBAA9C;;;;AAAsE;AAKpEE,iBAAAA,kBAAAA,CAA6CC,iBAAY,EAAA,OAAZA,YAAY,CAAA,EAAA,MAAA;AAChEC,UAAAA,qBAAAA,CAAqB;EAGRD,IAAAA,KAAAA,EAAAA,EAAAA,MAAY,EAAA;;AAE3BT,uBAFeS,YAAAA,YAAwBC,qBAEvCV,CAAAA;EAAgB,eA+BNA,EAAAA,OAAAA;EAAgB,SAehBA,EA9CVA,gBA8CUA;EAAgB;;;AAhDkC;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAiClDA;;;;;;;;;;;;;;;uBAeAA;YACXO;0BACcD"}

package/dist/memory.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"memory.d.cts","names":["InputValues","Record","OutputValues","MemoryVariables","BaseMemory","Promise","getInputValue","getOutputValue","getPromptInputKey"],"sources":["../src/memory.d.ts"],"sourcesContent":["/**\n * Type alias for a record where the keys are strings and the values can\n * be any type. This is used to represent the input values for a Chain.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type InputValues = Record<string, any>;\n/**\n * Type alias for a record where the keys are strings and the values can\n * be any type. This is used to represent the output values from a Chain.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type OutputValues = Record<string, any>;\n/**\n * Type alias for a record where the keys are strings and the values can\n * be any type. This is used to represent the memory variables in a Chain.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type MemoryVariables = Record<string, any>;\n/**\n * Abstract base class for memory in LangChain's Chains. Memory refers to\n * the state in Chains. It can be used to store information about past\n * executions of a Chain and inject that information into the inputs of\n * future executions of the Chain.\n */\nexport declare abstract class BaseMemory {\n    abstract get memoryKeys(): string[];\n    /**\n     * Abstract method that should take an object of input values and return a\n     * Promise that resolves with an object of memory variables. The\n     * implementation of this method should load the memory variables from the\n     * provided input values.\n     * @param values An object of input values.\n     * @returns Promise that resolves with an object of memory variables.\n     */\n    abstract loadMemoryVariables(values: InputValues): Promise<MemoryVariables>;\n    /**\n     * Abstract method that should take two objects, one of input values and\n     * one of output values, and return a Promise that resolves when the\n     * context has been saved. The implementation of this method should save\n     * the context based on the provided input and output values.\n     * @param inputValues An object of input values.\n     * @param outputValues An object of output values.\n     * @returns Promise that resolves when the context has been saved.\n     */\n    abstract saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;\n}\n/**\n * This function is used by memory classes to select the input value\n * to use for the memory. If there is only one input value, it is used.\n * If there are multiple input values, the inputKey must be specified.\n */\nexport declare const getInputValue: (inputValues: InputValues, inputKey?: string | undefined) => any;\n/**\n * This function is used by memory classes to select the output value\n * to use for the memory. If there is only one output value, it is used.\n * If there are multiple output values, the outputKey must be specified.\n * If no outputKey is specified, an error is thrown.\n */\nexport declare const getOutputValue: (outputValues: OutputValues, outputKey?: string | undefined) => any;\n/**\n * Function used by memory classes to get the key of the prompt input,\n * excluding any keys that are memory variables or the \"stop\" key. If\n * there is not exactly one prompt input key, an error is thrown.\n */\nexport declare function getPromptInputKey(inputs: Record<string, unknown>, memoryVariables: string[]): string;\n"],"mappings":";;AAKA;AAMA;AAMA;AAOA;AAAwC,KAnB5BA,WAAAA,GAAcC,MAmBc,CAAA,MAAA,EAAA,GAAA,CAAA;;;;;;AAoBwCI,KAjCpEH,YAAAA,GAAeD,MAiCqDI,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;AAAO;AAOvF;AAOA;AAMA;;KA/CYF,eAAAA,GAAkBF;;;;;;;uBAOAG,UAAAA;;;;;;;;;;uCAUWJ,cAAcK,QAAQF;;;;;;;;;;oCAUzBH,2BAA2BE,eAAeG;;;;;;;cAO3DC,6BAA6BN;;;;;;;cAO7BO,+BAA+BL;;;;;;iBAM5BM,iBAAAA,SAA0BP"}

package/dist/memory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"memory.d.ts","names":["InputValues","Record","OutputValues","MemoryVariables","BaseMemory","Promise","getInputValue","getOutputValue","getPromptInputKey"],"sources":["../src/memory.d.ts"],"sourcesContent":["/**\n * Type alias for a record where the keys are strings and the values can\n * be any type. This is used to represent the input values for a Chain.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type InputValues = Record<string, any>;\n/**\n * Type alias for a record where the keys are strings and the values can\n * be any type. This is used to represent the output values from a Chain.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type OutputValues = Record<string, any>;\n/**\n * Type alias for a record where the keys are strings and the values can\n * be any type. This is used to represent the memory variables in a Chain.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type MemoryVariables = Record<string, any>;\n/**\n * Abstract base class for memory in LangChain's Chains. Memory refers to\n * the state in Chains. It can be used to store information about past\n * executions of a Chain and inject that information into the inputs of\n * future executions of the Chain.\n */\nexport declare abstract class BaseMemory {\n    abstract get memoryKeys(): string[];\n    /**\n     * Abstract method that should take an object of input values and return a\n     * Promise that resolves with an object of memory variables. The\n     * implementation of this method should load the memory variables from the\n     * provided input values.\n     * @param values An object of input values.\n     * @returns Promise that resolves with an object of memory variables.\n     */\n    abstract loadMemoryVariables(values: InputValues): Promise<MemoryVariables>;\n    /**\n     * Abstract method that should take two objects, one of input values and\n     * one of output values, and return a Promise that resolves when the\n     * context has been saved. The implementation of this method should save\n     * the context based on the provided input and output values.\n     * @param inputValues An object of input values.\n     * @param outputValues An object of output values.\n     * @returns Promise that resolves when the context has been saved.\n     */\n    abstract saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;\n}\n/**\n * This function is used by memory classes to select the input value\n * to use for the memory. If there is only one input value, it is used.\n * If there are multiple input values, the inputKey must be specified.\n */\nexport declare const getInputValue: (inputValues: InputValues, inputKey?: string | undefined) => any;\n/**\n * This function is used by memory classes to select the output value\n * to use for the memory. If there is only one output value, it is used.\n * If there are multiple output values, the outputKey must be specified.\n * If no outputKey is specified, an error is thrown.\n */\nexport declare const getOutputValue: (outputValues: OutputValues, outputKey?: string | undefined) => any;\n/**\n * Function used by memory classes to get the key of the prompt input,\n * excluding any keys that are memory variables or the \"stop\" key. If\n * there is not exactly one prompt input key, an error is thrown.\n */\nexport declare function getPromptInputKey(inputs: Record<string, unknown>, memoryVariables: string[]): string;\n"],"mappings":";;AAKA;AAMA;AAMA;AAOA;AAAwC,KAnB5BA,WAAAA,GAAcC,MAmBc,CAAA,MAAA,EAAA,GAAA,CAAA;;;;;;AAoBwCI,KAjCpEH,YAAAA,GAAeD,MAiCqDI,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;AAAO;AAOvF;AAOA;AAMA;;KA/CYF,eAAAA,GAAkBF;;;;;;;uBAOAG,UAAAA;;;;;;;;;;uCAUWJ,cAAcK,QAAQF;;;;;;;;;;oCAUzBH,2BAA2BE,eAAeG;;;;;;;cAO3DC,6BAA6BN;;;;;;;cAO7BO,+BAA+BL;;;;;;iBAM5BM,iBAAAA,SAA0BP"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"ai.d.cts","names":["BaseMessage","BaseMessageChunk","BaseMessageFields","ContentBlock","$InferMessageContent","$InferMessageProperty","MessageStructure","InvalidToolCall","ToolCall","ToolCallChunk","AIMessageFields","TStructure","AIMessage","Record","Standard","Array","isAIMessage","isAIMessageChunk","AIMessageChunk","AIMessageChunkFields"],"sources":["../../src/messages/ai.d.ts"],"sourcesContent":["import { BaseMessage, BaseMessageChunk, BaseMessageFields } from \"./base.js\";\nimport { ContentBlock } from \"./content/index.js\";\nimport { $InferMessageContent, $InferMessageProperty, MessageStructure } from \"./message.js\";\nimport { InvalidToolCall, ToolCall, ToolCallChunk } from \"./tool.js\";\nexport interface AIMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, \"ai\"> {\n    tool_calls?: ToolCall[];\n    invalid_tool_calls?: InvalidToolCall[];\n    usage_metadata?: $InferMessageProperty<TStructure, \"ai\", \"usage_metadata\">;\n}\nexport declare class AIMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, \"ai\"> implements AIMessageFields<TStructure> {\n    readonly type: \"ai\";\n    tool_calls?: ToolCall[];\n    invalid_tool_calls?: InvalidToolCall[];\n    usage_metadata?: AIMessageFields<TStructure>[\"usage_metadata\"];\n    get lc_aliases(): Record<string, string>;\n    constructor(fields: $InferMessageContent<TStructure, \"ai\"> | AIMessageFields<TStructure>);\n    static lc_name(): string;\n    get contentBlocks(): Array<ContentBlock.Standard>;\n    get _printableFields(): Record<string, unknown>;\n    static isInstance(obj: unknown): obj is AIMessage;\n}\n/**\n * @deprecated Use {@link AIMessage.isInstance} instead\n */\nexport declare function isAIMessage<TStructure extends MessageStructure>(x: BaseMessage): x is AIMessage<TStructure>;\n/**\n * @deprecated Use {@link AIMessageChunk.isInstance} instead\n */\nexport declare function isAIMessageChunk<TStructure extends MessageStructure>(x: BaseMessageChunk): x is AIMessageChunk<TStructure>;\nexport type AIMessageChunkFields<TStructure extends MessageStructure = MessageStructure> = AIMessageFields<TStructure> & {\n    tool_call_chunks?: ToolCallChunk[];\n};\n/**\n * Represents a chunk of an AI message, which can be concatenated with\n * other AI message chunks.\n */\nexport declare class AIMessageChunk<TStructure extends MessageStructure = MessageStructure> extends BaseMessageChunk<TStructure, \"ai\"> implements AIMessage<TStructure>, AIMessageChunkFields<TStructure> {\n    readonly type: \"ai\";\n    tool_calls?: ToolCall[];\n    invalid_tool_calls?: InvalidToolCall[];\n    tool_call_chunks?: ToolCallChunk[];\n    usage_metadata?: AIMessageChunkFields<TStructure>[\"usage_metadata\"];\n    constructor(fields: $InferMessageContent<TStructure, \"ai\"> | AIMessageChunkFields<TStructure>);\n    get lc_aliases(): Record<string, string>;\n    static lc_name(): string;\n    get contentBlocks(): Array<ContentBlock.Standard>;\n    get _printableFields(): Record<string, unknown>;\n    concat(chunk: AIMessageChunk<TStructure>): this;\n    static isInstance(obj: unknown): obj is AIMessageChunk;\n}\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"ai.d.ts","names":["BaseMessage","BaseMessageChunk","BaseMessageFields","ContentBlock","$InferMessageContent","$InferMessageProperty","MessageStructure","InvalidToolCall","ToolCall","ToolCallChunk","AIMessageFields","TStructure","AIMessage","Record","Standard","Array","isAIMessage","isAIMessageChunk","AIMessageChunk","AIMessageChunkFields"],"sources":["../../src/messages/ai.d.ts"],"sourcesContent":["import { BaseMessage, BaseMessageChunk, BaseMessageFields } from \"./base.js\";\nimport { ContentBlock } from \"./content/index.js\";\nimport { $InferMessageContent, $InferMessageProperty, MessageStructure } from \"./message.js\";\nimport { InvalidToolCall, ToolCall, ToolCallChunk } from \"./tool.js\";\nexport interface AIMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, \"ai\"> {\n    tool_calls?: ToolCall[];\n    invalid_tool_calls?: InvalidToolCall[];\n    usage_metadata?: $InferMessageProperty<TStructure, \"ai\", \"usage_metadata\">;\n}\nexport declare class AIMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, \"ai\"> implements AIMessageFields<TStructure> {\n    readonly type: \"ai\";\n    tool_calls?: ToolCall[];\n    invalid_tool_calls?: InvalidToolCall[];\n    usage_metadata?: AIMessageFields<TStructure>[\"usage_metadata\"];\n    get lc_aliases(): Record<string, string>;\n    constructor(fields: $InferMessageContent<TStructure, \"ai\"> | AIMessageFields<TStructure>);\n    static lc_name(): string;\n    get contentBlocks(): Array<ContentBlock.Standard>;\n    get _printableFields(): Record<string, unknown>;\n    static isInstance(obj: unknown): obj is AIMessage;\n}\n/**\n * @deprecated Use {@link AIMessage.isInstance} instead\n */\nexport declare function isAIMessage<TStructure extends MessageStructure>(x: BaseMessage): x is AIMessage<TStructure>;\n/**\n * @deprecated Use {@link AIMessageChunk.isInstance} instead\n */\nexport declare function isAIMessageChunk<TStructure extends MessageStructure>(x: BaseMessageChunk): x is AIMessageChunk<TStructure>;\nexport type AIMessageChunkFields<TStructure extends MessageStructure = MessageStructure> = AIMessageFields<TStructure> & {\n    tool_call_chunks?: ToolCallChunk[];\n};\n/**\n * Represents a chunk of an AI message, which can be concatenated with\n * other AI message chunks.\n */\nexport declare class AIMessageChunk<TStructure extends MessageStructure = MessageStructure> extends BaseMessageChunk<TStructure, \"ai\"> implements AIMessage<TStructure>, AIMessageChunkFields<TStructure> {\n    readonly type: \"ai\";\n    tool_calls?: ToolCall[];\n    invalid_tool_calls?: InvalidToolCall[];\n    tool_call_chunks?: ToolCallChunk[];\n    usage_metadata?: AIMessageChunkFields<TStructure>[\"usage_metadata\"];\n    constructor(fields: $InferMessageContent<TStructure, \"ai\"> | AIMessageChunkFields<TStructure>);\n    get lc_aliases(): Record<string, string>;\n    static lc_name(): string;\n    get contentBlocks(): Array<ContentBlock.Standard>;\n    get _printableFields(): Record<string, unknown>;\n    concat(chunk: AIMessageChunk<TStructure>): this;\n    static isInstance(obj: unknown): obj is AIMessageChunk;\n}\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.cts","names":["Serializable","SerializedConstructor","ContentBlock","$InferMessageContent","$InferResponseMetadata","MessageStructure","MessageType","Message","MessageStringFormat","MESSAGE_SYMBOL","StoredMessageData","Record","StoredMessage","StoredGeneration","StoredMessageV1","MessageContent","Array","FunctionCall","BaseMessageFields","TStructure","TRole","Standard","OpenAIToolCall","Partial","mergeContent","_mergeStatus","BaseMessage","NonNullable","Symbol","toStringTag","isOpenAIToolCallArray","_mergeDicts","_mergeLists","Content","_mergeObj","T","BaseMessageChunk","MessageFieldWithRole","_isMessageFieldWithRole","BaseMessageLike","isBaseMessage","isBaseMessageChunk"],"sources":["../../src/messages/base.d.ts"],"sourcesContent":["import { Serializable, SerializedConstructor } from \"../load/serializable.js\";\nimport { ContentBlock } from \"./content/index.js\";\nimport { $InferMessageContent, $InferResponseMetadata, MessageStructure, MessageType, Message } from \"./message.js\";\nimport { type MessageStringFormat } from \"./format.js\";\n/** @internal */\ndeclare const MESSAGE_SYMBOL: unique symbol;\nexport interface StoredMessageData {\n    content: string;\n    role: string | undefined;\n    name: string | undefined;\n    tool_call_id: string | undefined;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    additional_kwargs?: Record<string, any>;\n    /** Response metadata. For example: response headers, logprobs, token counts, model name. */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    response_metadata?: Record<string, any>;\n    id?: string;\n}\nexport interface StoredMessage {\n    type: string;\n    data: StoredMessageData;\n}\nexport interface StoredGeneration {\n    text: string;\n    message?: StoredMessage;\n}\nexport interface StoredMessageV1 {\n    type: string;\n    role: string | undefined;\n    text: string;\n}\nexport type MessageContent = string | Array<ContentBlock>;\nexport interface FunctionCall {\n    /**\n     * The arguments to call the function with, as generated by the model in JSON\n     * format. Note that the model does not always generate valid JSON, and may\n     * hallucinate parameters not defined by your function schema. Validate the\n     * arguments in your code before calling your function.\n     */\n    arguments: string;\n    /**\n     * The name of the function to call.\n     */\n    name: string;\n}\nexport type BaseMessageFields<TStructure extends MessageStructure = MessageStructure, TRole extends MessageType = MessageType> = {\n    id?: string;\n    name?: string;\n    content?: $InferMessageContent<TStructure, TRole>;\n    contentBlocks?: Array<ContentBlock.Standard>;\n    /** @deprecated */\n    additional_kwargs?: {\n        /**\n         * @deprecated Use \"tool_calls\" field on AIMessages instead\n         */\n        function_call?: FunctionCall;\n        /**\n         * @deprecated Use \"tool_calls\" field on AIMessages instead\n         */\n        tool_calls?: OpenAIToolCall[];\n        [key: string]: unknown;\n    };\n    response_metadata?: Partial<$InferResponseMetadata<TStructure, TRole>>;\n};\nexport declare function mergeContent(firstContent: MessageContent, secondContent: MessageContent): MessageContent;\n/**\n * 'Merge' two statuses. If either value passed is 'error', it will return 'error'. Else\n * it will return 'success'.\n *\n * @param {\"success\" | \"error\" | undefined} left The existing value to 'merge' with the new value.\n * @param {\"success\" | \"error\" | undefined} right The new value to 'merge' with the existing value\n * @returns {\"success\" | \"error\"} The 'merged' value.\n */\nexport declare function _mergeStatus(left?: \"success\" | \"error\", right?: \"success\" | \"error\"): \"success\" | \"error\" | undefined;\n/**\n * Base class for all types of messages in a conversation. It includes\n * properties like `content`, `name`, and `additional_kwargs`. It also\n * includes methods like `toDict()` and `_getType()`.\n */\nexport declare abstract class BaseMessage<TStructure extends MessageStructure = MessageStructure, TRole extends MessageType = MessageType> extends Serializable implements Message<TStructure, TRole> {\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    get lc_aliases(): Record<string, string>;\n    readonly [MESSAGE_SYMBOL]: true;\n    abstract readonly type: TRole;\n    id?: string;\n    name?: string;\n    content: $InferMessageContent<TStructure, TRole>;\n    additional_kwargs: NonNullable<BaseMessageFields<TStructure, TRole>[\"additional_kwargs\"]>;\n    response_metadata: NonNullable<BaseMessageFields<TStructure, TRole>[\"response_metadata\"]>;\n    /**\n     * @deprecated Use .getType() instead or import the proper typeguard.\n     * For example:\n     *\n     * ```ts\n     * import { isAIMessage } from \"@langchain/core/messages\";\n     *\n     * const message = new AIMessage(\"Hello!\");\n     * isAIMessage(message); // true\n     * ```\n     */\n    _getType(): MessageType;\n    /**\n     * @deprecated Use .type instead\n     * The type of the message.\n     */\n    getType(): MessageType;\n    constructor(arg: $InferMessageContent<TStructure, TRole> | BaseMessageFields<TStructure, TRole>);\n    /** Get text content of the message. */\n    get text(): string;\n    get contentBlocks(): Array<ContentBlock.Standard>;\n    toDict(): StoredMessage;\n    static lc_name(): string;\n    // Can't be protected for silly reasons\n    get _printableFields(): Record<string, unknown>;\n    static isInstance(obj: unknown): obj is BaseMessage;\n    // this private method is used to update the ID for the runtime\n    // value as well as in lc_kwargs for serialisation\n    _updateId(value: string | undefined): void;\n    get [Symbol.toStringTag](): any;\n    toFormattedString(format?: MessageStringFormat): string;\n}\n/**\n * @deprecated Use \"tool_calls\" field on AIMessages instead\n */\nexport type OpenAIToolCall = {\n    /**\n     * The ID of the tool call.\n     */\n    id: string;\n    /**\n     * The function that the model called.\n     */\n    function: FunctionCall;\n    /**\n     * The type of the tool. Currently, only `function` is supported.\n     */\n    type: \"function\";\n    index?: number;\n};\nexport declare function isOpenAIToolCallArray(value?: unknown): value is OpenAIToolCall[];\nexport declare function _mergeDicts(\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nleft?: Record<string, any>, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nright?: Record<string, any>\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n): Record<string, any>;\nexport declare function _mergeLists<Content extends ContentBlock>(left?: Content[], right?: Content[]): Content[] | undefined;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport declare function _mergeObj<T = any>(left: T | undefined, right: T | undefined): T;\n/**\n * Represents a chunk of a message, which can be concatenated with other\n * message chunks. It includes a method `_merge_kwargs_dict()` for merging\n * additional keyword arguments from another `BaseMessageChunk` into this\n * one. It also overrides the `__add__()` method to support concatenation\n * of `BaseMessageChunk` instances.\n */\nexport declare abstract class BaseMessageChunk<TStructure extends MessageStructure = MessageStructure, TRole extends MessageType = MessageType> extends BaseMessage<TStructure, TRole> {\n    abstract concat(chunk: BaseMessageChunk): BaseMessageChunk<TStructure, TRole>;\n    static isInstance(obj: unknown): obj is BaseMessageChunk;\n}\nexport type MessageFieldWithRole = {\n    role: MessageType;\n    content: MessageContent;\n    name?: string;\n} & Record<string, unknown>;\nexport declare function _isMessageFieldWithRole(x: BaseMessageLike): x is MessageFieldWithRole;\nexport type BaseMessageLike = BaseMessage | MessageFieldWithRole | [MessageType, MessageContent] | string\n/**\n * @deprecated Specifying \"type\" is deprecated and will be removed in 0.4.0.\n */\n | ({\n    type: MessageType | \"user\" | \"assistant\" | \"placeholder\";\n} & BaseMessageFields & Record<string, unknown>) | SerializedConstructor;\n/**\n * @deprecated Use {@link BaseMessage.isInstance} instead\n */\nexport declare function isBaseMessage(messageLike?: unknown): messageLike is BaseMessage;\n/**\n * @deprecated Use {@link BaseMessageChunk.isInstance} instead\n */\nexport declare function isBaseMessageChunk(messageLike?: unknown): messageLike is BaseMessageChunk;\nexport {};\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.ts","names":["Serializable","SerializedConstructor","ContentBlock","$InferMessageContent","$InferResponseMetadata","MessageStructure","MessageType","Message","MessageStringFormat","MESSAGE_SYMBOL","StoredMessageData","Record","StoredMessage","StoredGeneration","StoredMessageV1","MessageContent","Array","FunctionCall","BaseMessageFields","TStructure","TRole","Standard","OpenAIToolCall","Partial","mergeContent","_mergeStatus","BaseMessage","NonNullable","Symbol","toStringTag","isOpenAIToolCallArray","_mergeDicts","_mergeLists","Content","_mergeObj","T","BaseMessageChunk","MessageFieldWithRole","_isMessageFieldWithRole","BaseMessageLike","isBaseMessage","isBaseMessageChunk"],"sources":["../../src/messages/base.d.ts"],"sourcesContent":["import { Serializable, SerializedConstructor } from \"../load/serializable.js\";\nimport { ContentBlock } from \"./content/index.js\";\nimport { $InferMessageContent, $InferResponseMetadata, MessageStructure, MessageType, Message } from \"./message.js\";\nimport { type MessageStringFormat } from \"./format.js\";\n/** @internal */\ndeclare const MESSAGE_SYMBOL: unique symbol;\nexport interface StoredMessageData {\n    content: string;\n    role: string | undefined;\n    name: string | undefined;\n    tool_call_id: string | undefined;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    additional_kwargs?: Record<string, any>;\n    /** Response metadata. For example: response headers, logprobs, token counts, model name. */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    response_metadata?: Record<string, any>;\n    id?: string;\n}\nexport interface StoredMessage {\n    type: string;\n    data: StoredMessageData;\n}\nexport interface StoredGeneration {\n    text: string;\n    message?: StoredMessage;\n}\nexport interface StoredMessageV1 {\n    type: string;\n    role: string | undefined;\n    text: string;\n}\nexport type MessageContent = string | Array<ContentBlock>;\nexport interface FunctionCall {\n    /**\n     * The arguments to call the function with, as generated by the model in JSON\n     * format. Note that the model does not always generate valid JSON, and may\n     * hallucinate parameters not defined by your function schema. Validate the\n     * arguments in your code before calling your function.\n     */\n    arguments: string;\n    /**\n     * The name of the function to call.\n     */\n    name: string;\n}\nexport type BaseMessageFields<TStructure extends MessageStructure = MessageStructure, TRole extends MessageType = MessageType> = {\n    id?: string;\n    name?: string;\n    content?: $InferMessageContent<TStructure, TRole>;\n    contentBlocks?: Array<ContentBlock.Standard>;\n    /** @deprecated */\n    additional_kwargs?: {\n        /**\n         * @deprecated Use \"tool_calls\" field on AIMessages instead\n         */\n        function_call?: FunctionCall;\n        /**\n         * @deprecated Use \"tool_calls\" field on AIMessages instead\n         */\n        tool_calls?: OpenAIToolCall[];\n        [key: string]: unknown;\n    };\n    response_metadata?: Partial<$InferResponseMetadata<TStructure, TRole>>;\n};\nexport declare function mergeContent(firstContent: MessageContent, secondContent: MessageContent): MessageContent;\n/**\n * 'Merge' two statuses. If either value passed is 'error', it will return 'error'. Else\n * it will return 'success'.\n *\n * @param {\"success\" | \"error\" | undefined} left The existing value to 'merge' with the new value.\n * @param {\"success\" | \"error\" | undefined} right The new value to 'merge' with the existing value\n * @returns {\"success\" | \"error\"} The 'merged' value.\n */\nexport declare function _mergeStatus(left?: \"success\" | \"error\", right?: \"success\" | \"error\"): \"success\" | \"error\" | undefined;\n/**\n * Base class for all types of messages in a conversation. It includes\n * properties like `content`, `name`, and `additional_kwargs`. It also\n * includes methods like `toDict()` and `_getType()`.\n */\nexport declare abstract class BaseMessage<TStructure extends MessageStructure = MessageStructure, TRole extends MessageType = MessageType> extends Serializable implements Message<TStructure, TRole> {\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    get lc_aliases(): Record<string, string>;\n    readonly [MESSAGE_SYMBOL]: true;\n    abstract readonly type: TRole;\n    id?: string;\n    name?: string;\n    content: $InferMessageContent<TStructure, TRole>;\n    additional_kwargs: NonNullable<BaseMessageFields<TStructure, TRole>[\"additional_kwargs\"]>;\n    response_metadata: NonNullable<BaseMessageFields<TStructure, TRole>[\"response_metadata\"]>;\n    /**\n     * @deprecated Use .getType() instead or import the proper typeguard.\n     * For example:\n     *\n     * ```ts\n     * import { isAIMessage } from \"@langchain/core/messages\";\n     *\n     * const message = new AIMessage(\"Hello!\");\n     * isAIMessage(message); // true\n     * ```\n     */\n    _getType(): MessageType;\n    /**\n     * @deprecated Use .type instead\n     * The type of the message.\n     */\n    getType(): MessageType;\n    constructor(arg: $InferMessageContent<TStructure, TRole> | BaseMessageFields<TStructure, TRole>);\n    /** Get text content of the message. */\n    get text(): string;\n    get contentBlocks(): Array<ContentBlock.Standard>;\n    toDict(): StoredMessage;\n    static lc_name(): string;\n    // Can't be protected for silly reasons\n    get _printableFields(): Record<string, unknown>;\n    static isInstance(obj: unknown): obj is BaseMessage;\n    // this private method is used to update the ID for the runtime\n    // value as well as in lc_kwargs for serialisation\n    _updateId(value: string | undefined): void;\n    get [Symbol.toStringTag](): any;\n    toFormattedString(format?: MessageStringFormat): string;\n}\n/**\n * @deprecated Use \"tool_calls\" field on AIMessages instead\n */\nexport type OpenAIToolCall = {\n    /**\n     * The ID of the tool call.\n     */\n    id: string;\n    /**\n     * The function that the model called.\n     */\n    function: FunctionCall;\n    /**\n     * The type of the tool. Currently, only `function` is supported.\n     */\n    type: \"function\";\n    index?: number;\n};\nexport declare function isOpenAIToolCallArray(value?: unknown): value is OpenAIToolCall[];\nexport declare function _mergeDicts(\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nleft?: Record<string, any>, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nright?: Record<string, any>\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n): Record<string, any>;\nexport declare function _mergeLists<Content extends ContentBlock>(left?: Content[], right?: Content[]): Content[] | undefined;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport declare function _mergeObj<T = any>(left: T | undefined, right: T | undefined): T;\n/**\n * Represents a chunk of a message, which can be concatenated with other\n * message chunks. It includes a method `_merge_kwargs_dict()` for merging\n * additional keyword arguments from another `BaseMessageChunk` into this\n * one. It also overrides the `__add__()` method to support concatenation\n * of `BaseMessageChunk` instances.\n */\nexport declare abstract class BaseMessageChunk<TStructure extends MessageStructure = MessageStructure, TRole extends MessageType = MessageType> extends BaseMessage<TStructure, TRole> {\n    abstract concat(chunk: BaseMessageChunk): BaseMessageChunk<TStructure, TRole>;\n    static isInstance(obj: unknown): obj is BaseMessageChunk;\n}\nexport type MessageFieldWithRole = {\n    role: MessageType;\n    content: MessageContent;\n    name?: string;\n} & Record<string, unknown>;\nexport declare function _isMessageFieldWithRole(x: BaseMessageLike): x is MessageFieldWithRole;\nexport type BaseMessageLike = BaseMessage | MessageFieldWithRole | [MessageType, MessageContent] | string\n/**\n * @deprecated Specifying \"type\" is deprecated and will be removed in 0.4.0.\n */\n | ({\n    type: MessageType | \"user\" | \"assistant\" | \"placeholder\";\n} & BaseMessageFields & Record<string, unknown>) | SerializedConstructor;\n/**\n * @deprecated Use {@link BaseMessage.isInstance} instead\n */\nexport declare function isBaseMessage(messageLike?: unknown): messageLike is BaseMessage;\n/**\n * @deprecated Use {@link BaseMessageChunk.isInstance} instead\n */\nexport declare function isBaseMessageChunk(messageLike?: unknown): messageLike is BaseMessageChunk;\nexport {};\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"chat.d.cts","names":["BaseMessage","BaseMessageChunk","BaseMessageFields","$InferMessageContent","MessageStructure","ChatMessageFields","TStructure","ChatMessage","Record","ChatMessageChunk","isChatMessage","isChatMessageChunk"],"sources":["../../src/messages/chat.d.ts"],"sourcesContent":["import { BaseMessage, BaseMessageChunk, type BaseMessageFields } from \"./base.js\";\nimport { $InferMessageContent, MessageStructure } from \"./message.js\";\nexport interface ChatMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, \"generic\"> {\n    role: string;\n}\n/**\n * Represents a chat message in a conversation.\n */\nexport declare class ChatMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, \"generic\"> implements ChatMessageFields<TStructure> {\n    static lc_name(): string;\n    readonly type: \"generic\";\n    role: string;\n    static _chatMessageClass(): typeof ChatMessage;\n    constructor(content: $InferMessageContent<TStructure, \"generic\">, role: string);\n    constructor(fields: ChatMessageFields<TStructure>);\n    static isInstance(obj: unknown): obj is ChatMessage;\n    get _printableFields(): Record<string, unknown>;\n}\n/**\n * Represents a chunk of a chat message, which can be concatenated with\n * other chat message chunks.\n */\nexport declare class ChatMessageChunk<TStructure extends MessageStructure = MessageStructure> extends BaseMessageChunk<TStructure, \"generic\"> {\n    static lc_name(): string;\n    readonly type: \"generic\";\n    role: string;\n    constructor(content: $InferMessageContent<TStructure, \"generic\">, role: string);\n    constructor(fields: ChatMessageFields<TStructure>);\n    concat(chunk: ChatMessageChunk<TStructure>): this;\n    static isInstance(obj: unknown): obj is ChatMessageChunk;\n    get _printableFields(): Record<string, unknown>;\n}\n/**\n * @deprecated Use {@link ChatMessage.isInstance} instead\n */\nexport declare function isChatMessage(x: BaseMessage): x is ChatMessage;\n/**\n * @deprecated Use {@link ChatMessageChunk.isInstance} instead\n */\nexport declare function isChatMessageChunk(x: BaseMessageChunk): x is ChatMessageChunk;\n"],"mappings":";;;;UAEiBK,qCAAqCD,mBAAmBA,0BAA0BF,kBAAkBI;;AAArH;;;;AAAqHA,cAMhGC,WANgGD,CAAAA,mBAMjEF,gBANiEE,GAM9CF,gBAN8CE,CAAAA,SAMpBN,WANoBM,CAMRA,UANQA,EAAAA,SAAAA,CAAAA,YAM0BD,iBAN1BC,CAM4CA,UAN5CA,CAAAA,CAAAA;EAAU,OAA5BJ,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAiB,SAAA,IAAA,EAAA,SAAA;EAM/FK,IAAAA,EAAAA,MAAAA;EAAW,OAAA,iBAAA,CAAA,CAAA,EAAA,OAIOA,WAJP;EAAA,WAAoBH,CAAAA,OAAAA,EAK3BD,oBAL2BC,CAKNE,UALMF,EAAAA,SAAAA,CAAAA,EAAAA,IAAAA,EAAAA,MAAAA;EAAgB,WAAGA,CAAAA,MAAAA,EAM/CC,iBAN+CD,CAM7BE,UAN6BF,CAAAA;EAAgB,OAAsBE,UAAAA,CAAAA,GAAAA,EAAAA,OAAAA,CAAAA,EAAAA,GAAAA,IAOjEC,WAPiED;EAAU,IAA0CA,gBAAAA,CAAAA,CAAAA,EAQrIE,MARqIF,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;;;;;;AAOrHC,cAOvBE,gBAPuBF,CAAAA,mBAOaH,gBAPbG,GAOgCH,gBAPhCG,CAAAA,SAO0DN,gBAP1DM,CAO2ED,UAP3EC,EAAAA,SAAAA,CAAAA,CAAAA;EAAW,OAC3BC,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAM,SAR+DR,IAAAA,EAAAA,SAAAA;EAAW,IAAmCK,EAAAA,MAAAA;EAAiB,WAAA,CAAA,OAAA,EAkBvIF,oBAlBuI,CAkBlHG,UAlBkH,EAAA,SAAA,CAAA,EAAA,IAAA,EAAA,MAAA;EAc3IG,WAAAA,CAAAA,MAAAA,EAKGJ,iBALa,CAKKC,UALL,CAAA;EAAA,MAAA,CAAA,KAAA,EAMnBG,gBANmB,CAMFH,UANE,CAAA,CAAA,EAAA,IAAA;EAAA,OAAoBF,UAAAA,CAAAA,GAAAA,EAAAA,OAAAA,CAAAA,EAAAA,GAAAA,IAObK,gBAPaL;EAAgB,IAAGA,gBAAAA,CAAAA,CAAAA,EAQhDI,MARgDJ,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;;;;;AAKpDC,iBAQAK,aAAAA,CARAL,CAAAA,EAQiBL,WARjBK,CAAAA,EAAAA,CAAAA,IAQoCE,WARpCF;;;;AAGIG,iBASJG,kBAAAA,CATIH,CAAAA,EASkBP,gBATlBO,CAAAA,EAAAA,CAAAA,IAS0CC,gBAT1CD"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"chat.d.ts","names":["BaseMessage","BaseMessageChunk","BaseMessageFields","$InferMessageContent","MessageStructure","ChatMessageFields","TStructure","ChatMessage","Record","ChatMessageChunk","isChatMessage","isChatMessageChunk"],"sources":["../../src/messages/chat.d.ts"],"sourcesContent":["import { BaseMessage, BaseMessageChunk, type BaseMessageFields } from \"./base.js\";\nimport { $InferMessageContent, MessageStructure } from \"./message.js\";\nexport interface ChatMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, \"generic\"> {\n    role: string;\n}\n/**\n * Represents a chat message in a conversation.\n */\nexport declare class ChatMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, \"generic\"> implements ChatMessageFields<TStructure> {\n    static lc_name(): string;\n    readonly type: \"generic\";\n    role: string;\n    static _chatMessageClass(): typeof ChatMessage;\n    constructor(content: $InferMessageContent<TStructure, \"generic\">, role: string);\n    constructor(fields: ChatMessageFields<TStructure>);\n    static isInstance(obj: unknown): obj is ChatMessage;\n    get _printableFields(): Record<string, unknown>;\n}\n/**\n * Represents a chunk of a chat message, which can be concatenated with\n * other chat message chunks.\n */\nexport declare class ChatMessageChunk<TStructure extends MessageStructure = MessageStructure> extends BaseMessageChunk<TStructure, \"generic\"> {\n    static lc_name(): string;\n    readonly type: \"generic\";\n    role: string;\n    constructor(content: $InferMessageContent<TStructure, \"generic\">, role: string);\n    constructor(fields: ChatMessageFields<TStructure>);\n    concat(chunk: ChatMessageChunk<TStructure>): this;\n    static isInstance(obj: unknown): obj is ChatMessageChunk;\n    get _printableFields(): Record<string, unknown>;\n}\n/**\n * @deprecated Use {@link ChatMessage.isInstance} instead\n */\nexport declare function isChatMessage(x: BaseMessage): x is ChatMessage;\n/**\n * @deprecated Use {@link ChatMessageChunk.isInstance} instead\n */\nexport declare function isChatMessageChunk(x: BaseMessageChunk): x is ChatMessageChunk;\n"],"mappings":";;;;UAEiBK,qCAAqCD,mBAAmBA,0BAA0BF,kBAAkBI;;AAArH;;;;AAAqHA,cAMhGC,WANgGD,CAAAA,mBAMjEF,gBANiEE,GAM9CF,gBAN8CE,CAAAA,SAMpBN,WANoBM,CAMRA,UANQA,EAAAA,SAAAA,CAAAA,YAM0BD,iBAN1BC,CAM4CA,UAN5CA,CAAAA,CAAAA;EAAU,OAA5BJ,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAiB,SAAA,IAAA,EAAA,SAAA;EAM/FK,IAAAA,EAAAA,MAAAA;EAAW,OAAA,iBAAA,CAAA,CAAA,EAAA,OAIOA,WAJP;EAAA,WAAoBH,CAAAA,OAAAA,EAK3BD,oBAL2BC,CAKNE,UALMF,EAAAA,SAAAA,CAAAA,EAAAA,IAAAA,EAAAA,MAAAA;EAAgB,WAAGA,CAAAA,MAAAA,EAM/CC,iBAN+CD,CAM7BE,UAN6BF,CAAAA;EAAgB,OAAsBE,UAAAA,CAAAA,GAAAA,EAAAA,OAAAA,CAAAA,EAAAA,GAAAA,IAOjEC,WAPiED;EAAU,IAA0CA,gBAAAA,CAAAA,CAAAA,EAQrIE,MARqIF,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;;;;;;AAOrHC,cAOvBE,gBAPuBF,CAAAA,mBAOaH,gBAPbG,GAOgCH,gBAPhCG,CAAAA,SAO0DN,gBAP1DM,CAO2ED,UAP3EC,EAAAA,SAAAA,CAAAA,CAAAA;EAAW,OAC3BC,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAM,SAR+DR,IAAAA,EAAAA,SAAAA;EAAW,IAAmCK,EAAAA,MAAAA;EAAiB,WAAA,CAAA,OAAA,EAkBvIF,oBAlBuI,CAkBlHG,UAlBkH,EAAA,SAAA,CAAA,EAAA,IAAA,EAAA,MAAA;EAc3IG,WAAAA,CAAAA,MAAAA,EAKGJ,iBALa,CAKKC,UALL,CAAA;EAAA,MAAA,CAAA,KAAA,EAMnBG,gBANmB,CAMFH,UANE,CAAA,CAAA,EAAA,IAAA;EAAA,OAAoBF,UAAAA,CAAAA,GAAAA,EAAAA,OAAAA,CAAAA,EAAAA,GAAAA,IAObK,gBAPaL;EAAgB,IAAGA,gBAAAA,CAAAA,CAAAA,EAQhDI,MARgDJ,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;;;;;AAKpDC,iBAQAK,aAAAA,CARAL,CAAAA,EAQiBL,WARjBK,CAAAA,EAAAA,CAAAA,IAQoCE,WARpCF;;;;AAGIG,iBASJG,kBAAAA,CATIH,CAAAA,EASkBP,gBATlBO,CAAAA,EAAAA,CAAAA,IAS0CC,gBAT1CD"}

package/dist/messages/content/base.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.cts","names":["BaseContentBlock"],"sources":["../../../src/messages/content/base.d.ts"],"sourcesContent":["export interface BaseContentBlock {\n    /**\n     * Type of the content block\n     */\n    readonly type: string;\n    /**\n     * Content block identifier, which can be either\n     *  - generated by the provider (e.g., a provider-specific ID)\n     *  - generated by LangChain upon creation (a uuid prefixed with 'lc-')\n     */\n    id?: string;\n    /**\n     * Arbitrary properties\n     */\n    [key: string]: unknown;\n}\n"],"mappings":";UAAiBA,gBAAAA;EAAAA"}

package/dist/messages/content/base.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.ts","names":["BaseContentBlock"],"sources":["../../../src/messages/content/base.d.ts"],"sourcesContent":["export interface BaseContentBlock {\n    /**\n     * Type of the content block\n     */\n    readonly type: string;\n    /**\n     * Content block identifier, which can be either\n     *  - generated by the provider (e.g., a provider-specific ID)\n     *  - generated by LangChain upon creation (a uuid prefixed with 'lc-')\n     */\n    id?: string;\n    /**\n     * Arbitrary properties\n     */\n    [key: string]: unknown;\n}\n"],"mappings":";UAAiBA,gBAAAA;EAAAA"}

package/dist/messages/content/data.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"data.d.cts","names":["BaseContentBlock","ImageDetail","MessageContentText","MessageContentImageUrl","MessageContentComplex","Record","Data","BaseDataContentBlock","URLContentBlock","Base64ContentBlock","PlainTextContentBlock","IDContentBlock","DataContentBlock","isDataContentBlock","isURLContentBlock","isBase64ContentBlock","isPlainTextContentBlock","isIDContentBlock","convertToOpenAIImageBlock","parseMimeType","parseBase64DataUrl","dataUrl","asTypedArray","Uint8Array","ProviderFormatTypes","TextFormat","ImageFormat","AudioFormat","FileFormat","VideoFormat","StandardContentBlockConverter","Partial","StandardImageBlock","Formats","StandardAudioBlock","StandardFileBlock","StandardTextBlock","convertToProviderContentBlock"],"sources":["../../../src/messages/content/data.d.ts"],"sourcesContent":["import { BaseContentBlock } from \"./base.js\";\n/**\n * @deprecated\n * Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport type ImageDetail = \"auto\" | \"low\" | \"high\";\n/**\n * @deprecated\n * Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport type MessageContentText = {\n    type: \"text\";\n    text: string;\n};\n/**\n * @deprecated\n * Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport type MessageContentImageUrl = {\n    type: \"image_url\";\n    image_url: string | {\n        url: string;\n        detail?: ImageDetail;\n    };\n};\n/**\n * @deprecated\n * Use {@link ContentBlock} instead.\n */\nexport type MessageContentComplex = MessageContentText | MessageContentImageUrl\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n | (Record<string, any> & {\n    type?: \"text\" | \"image_url\" | string;\n})\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n | (Record<string, any> & {\n    type?: never;\n});\nexport type Data = never;\n// eslint-disable-next-line @typescript-eslint/no-namespace\nexport declare namespace Data {\n    /**\n     * @deprecated\n     * Use {@link ContentBlock.Multimodal.Data} instead\n     */\n    interface BaseDataContentBlock extends BaseContentBlock {\n        mime_type?: string;\n        metadata?: Record<string, unknown>;\n    }\n    /**\n     * @deprecated\n     * Use {@link ContentBlock.Multimodal.Data} instead\n     */\n    interface URLContentBlock extends BaseDataContentBlock {\n        type: \"image\" | \"audio\" | \"file\";\n        source_type: \"url\";\n        url: string;\n    }\n    /**\n     * @deprecated\n     * Use {@link ContentBlock.Multimodal.Data} instead\n     */\n    interface Base64ContentBlock extends BaseDataContentBlock {\n        type: \"image\" | \"audio\" | \"file\";\n        source_type: \"base64\";\n        data: string;\n    }\n    /**\n     * @deprecated\n     * Use {@link ContentBlock.Multimodal.Data} instead\n     */\n    interface PlainTextContentBlock extends BaseDataContentBlock {\n        type: \"file\" | \"text\";\n        source_type: \"text\";\n        text: string;\n    }\n    /**\n     * @deprecated\n     * Use {@link ContentBlock.Multimodal.Data} instead\n     */\n    interface IDContentBlock extends BaseDataContentBlock {\n        type: \"image\" | \"audio\" | \"file\";\n        source_type: \"id\";\n        id: string;\n    }\n    /**\n     * @deprecated\n     * Use {@link ContentBlock.Multimodal.Standard} instead\n     */\n    type DataContentBlock = URLContentBlock | Base64ContentBlock | PlainTextContentBlock | IDContentBlock;\n    /**\n     * @deprecated\n     * Use {@link ContentBlock.Multimodal.Standard} instead\n     */\n    type StandardImageBlock = (URLContentBlock | Base64ContentBlock | IDContentBlock) & {\n        type: \"image\";\n    };\n    /**\n     * @deprecated\n     * Use {@link ContentBlock.Multimodal.Standard} instead\n     */\n    type StandardAudioBlock = (URLContentBlock | Base64ContentBlock | IDContentBlock) & {\n        type: \"audio\";\n    };\n    /**\n     * @deprecated\n     * Use {@link ContentBlock.Multimodal.Standard} instead\n     */\n    type StandardFileBlock = (URLContentBlock | Base64ContentBlock | IDContentBlock | PlainTextContentBlock) & {\n        type: \"file\";\n    };\n    /**\n     * @deprecated\n     * Use {@link ContentBlock.Multimodal.Standard} instead\n     */\n    type StandardTextBlock = PlainTextContentBlock & {\n        type: \"text\";\n    };\n    /**\n     * @deprecated\n     * Use {@link ContentBlock.Multimodal.Data} instead\n     */\n    type DataContentBlockType = DataContentBlock[\"type\"];\n}\n/**\n * @deprecated Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport declare function isDataContentBlock(content_block: object): content_block is Data.DataContentBlock;\n/**\n * @deprecated Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport declare function isURLContentBlock(content_block: object): content_block is Data.URLContentBlock;\n/**\n * @deprecated Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport declare function isBase64ContentBlock(content_block: object): content_block is Data.Base64ContentBlock;\n/**\n * @deprecated Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport declare function isPlainTextContentBlock(content_block: object): content_block is Data.PlainTextContentBlock;\n/**\n * @deprecated Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport declare function isIDContentBlock(content_block: object): content_block is Data.IDContentBlock;\n/**\n * @deprecated Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport declare function convertToOpenAIImageBlock(content_block: Data.URLContentBlock | Data.Base64ContentBlock): {\n    type: string;\n    image_url: {\n        url: string;\n    };\n};\n/**\n * Utility function for ChatModelProviders. Parses a mime type into a type, subtype, and parameters.\n *\n * @param mime_type - The mime type to parse.\n * @returns An object containing the type, subtype, and parameters.\n *\n * @deprecated Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport declare function parseMimeType(mime_type: string): {\n    type: string;\n    subtype: string;\n    parameters: Record<string, string>;\n};\n/**\n * Utility function for ChatModelProviders. Parses a base64 data URL into a typed array or string.\n *\n * @param dataUrl - The base64 data URL to parse.\n * @param asTypedArray - Whether to return the data as a typed array.\n * @returns An object containing the parsed data and mime type, or undefined if the data URL is invalid.\n *\n * @deprecated Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport declare function parseBase64DataUrl({ dataUrl, asTypedArray }: {\n    dataUrl: string;\n    asTypedArray: true;\n}): {\n    data: Uint8Array;\n    mime_type: string;\n} | undefined;\n/**\n * Utility function for ChatModelProviders. Parses a base64 data URL into a typed array or string.\n *\n * @param dataUrl - The base64 data URL to parse.\n * @param asTypedArray - Whether to return the data as a typed array.\n * @returns The parsed data and mime type, or undefined if the data URL is invalid.\n *\n * @deprecated Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport declare function parseBase64DataUrl({ dataUrl, asTypedArray }: {\n    dataUrl: string;\n    asTypedArray?: false;\n}): {\n    data: string;\n    mime_type: string;\n} | undefined;\n/**\n * A bag of provider-specific content block types.\n *\n * Allows implementations of {@link StandardContentBlockConverter} and related to be defined only in\n * terms of the types they support. Also allows for forward compatibility as the set of known\n * standard types grows, as the set of types can be extended without breaking existing\n * implementations of the aforementioned interfaces.\n *\n * @deprecated Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport type ProviderFormatTypes<TextFormat = unknown, ImageFormat = unknown, AudioFormat = unknown, FileFormat = unknown, VideoFormat = unknown> = {\n    text: TextFormat;\n    image: ImageFormat;\n    audio: AudioFormat;\n    file: FileFormat;\n    video: VideoFormat;\n};\n/**\n * Utility interface for converting between standard and provider-specific data content blocks, to be\n * used when implementing chat model providers.\n *\n * Meant to be used with {@link convertToProviderContentBlock} and\n * {@link convertToStandardContentBlock} rather than being consumed directly.\n *\n * @deprecated Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport interface StandardContentBlockConverter<Formats extends Partial<ProviderFormatTypes>> {\n    /**\n     * The name of the provider type that corresponds to the provider-specific content block types\n     * that this converter supports.\n     */\n    providerName: string;\n    /**\n     * Convert from a standard image block to a provider's proprietary image block format.\n     * @param block - The standard image block to convert.\n     * @returns The provider image block.\n     */\n    fromStandardImageBlock?(block: Data.StandardImageBlock): Formats[\"image\"];\n    /**\n     * Convert from a standard audio block to a provider's proprietary audio block format.\n     * @param block - The standard audio block to convert.\n     * @returns The provider audio block.\n     */\n    fromStandardAudioBlock?(block: Data.StandardAudioBlock): Formats[\"audio\"];\n    /**\n     * Convert from a standard file block to a provider's proprietary file block format.\n     * @param block - The standard file block to convert.\n     * @returns The provider file block.\n     */\n    fromStandardFileBlock?(block: Data.StandardFileBlock): Formats[\"file\"];\n    /**\n     * Convert from a standard text block to a provider's proprietary text block format.\n     * @param block - The standard text block to convert.\n     * @returns The provider text block.\n     */\n    fromStandardTextBlock?(block: Data.StandardTextBlock): Formats[\"text\"];\n}\n/**\n * Convert from a standard data content block to a provider's proprietary data content block format.\n *\n * Don't override this method. Instead, override the more specific conversion methods and use this\n * method unmodified.\n *\n * @param block - The standard data content block to convert.\n * @returns The provider data content block.\n * @throws An error if the standard data content block type is not supported.\n *\n * @deprecated Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport declare function convertToProviderContentBlock<Formats extends Partial<ProviderFormatTypes>>(block: Data.DataContentBlock, converter: StandardContentBlockConverter<Formats>): Formats[keyof Formats];\n"],"mappings":"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"}

package/dist/messages/content/data.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"data.d.ts","names":["BaseContentBlock","ImageDetail","MessageContentText","MessageContentImageUrl","MessageContentComplex","Record","Data","BaseDataContentBlock","URLContentBlock","Base64ContentBlock","PlainTextContentBlock","IDContentBlock","DataContentBlock","isDataContentBlock","isURLContentBlock","isBase64ContentBlock","isPlainTextContentBlock","isIDContentBlock","convertToOpenAIImageBlock","parseMimeType","parseBase64DataUrl","dataUrl","asTypedArray","Uint8Array","ProviderFormatTypes","TextFormat","ImageFormat","AudioFormat","FileFormat","VideoFormat","StandardContentBlockConverter","Partial","StandardImageBlock","Formats","StandardAudioBlock","StandardFileBlock","StandardTextBlock","convertToProviderContentBlock"],"sources":["../../../src/messages/content/data.d.ts"],"sourcesContent":["import { BaseContentBlock } from \"./base.js\";\n/**\n * @deprecated\n * Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport type ImageDetail = \"auto\" | \"low\" | \"high\";\n/**\n * @deprecated\n * Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport type MessageContentText = {\n    type: \"text\";\n    text: string;\n};\n/**\n * @deprecated\n * Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport type MessageContentImageUrl = {\n    type: \"image_url\";\n    image_url: string | {\n        url: string;\n        detail?: ImageDetail;\n    };\n};\n/**\n * @deprecated\n * Use {@link ContentBlock} instead.\n */\nexport type MessageContentComplex = MessageContentText | MessageContentImageUrl\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n | (Record<string, any> & {\n    type?: \"text\" | \"image_url\" | string;\n})\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n | (Record<string, any> & {\n    type?: never;\n});\nexport type Data = never;\n// eslint-disable-next-line @typescript-eslint/no-namespace\nexport declare namespace Data {\n    /**\n     * @deprecated\n     * Use {@link ContentBlock.Multimodal.Data} instead\n     */\n    interface BaseDataContentBlock extends BaseContentBlock {\n        mime_type?: string;\n        metadata?: Record<string, unknown>;\n    }\n    /**\n     * @deprecated\n     * Use {@link ContentBlock.Multimodal.Data} instead\n     */\n    interface URLContentBlock extends BaseDataContentBlock {\n        type: \"image\" | \"audio\" | \"file\";\n        source_type: \"url\";\n        url: string;\n    }\n    /**\n     * @deprecated\n     * Use {@link ContentBlock.Multimodal.Data} instead\n     */\n    interface Base64ContentBlock extends BaseDataContentBlock {\n        type: \"image\" | \"audio\" | \"file\";\n        source_type: \"base64\";\n        data: string;\n    }\n    /**\n     * @deprecated\n     * Use {@link ContentBlock.Multimodal.Data} instead\n     */\n    interface PlainTextContentBlock extends BaseDataContentBlock {\n        type: \"file\" | \"text\";\n        source_type: \"text\";\n        text: string;\n    }\n    /**\n     * @deprecated\n     * Use {@link ContentBlock.Multimodal.Data} instead\n     */\n    interface IDContentBlock extends BaseDataContentBlock {\n        type: \"image\" | \"audio\" | \"file\";\n        source_type: \"id\";\n        id: string;\n    }\n    /**\n     * @deprecated\n     * Use {@link ContentBlock.Multimodal.Standard} instead\n     */\n    type DataContentBlock = URLContentBlock | Base64ContentBlock | PlainTextContentBlock | IDContentBlock;\n    /**\n     * @deprecated\n     * Use {@link ContentBlock.Multimodal.Standard} instead\n     */\n    type StandardImageBlock = (URLContentBlock | Base64ContentBlock | IDContentBlock) & {\n        type: \"image\";\n    };\n    /**\n     * @deprecated\n     * Use {@link ContentBlock.Multimodal.Standard} instead\n     */\n    type StandardAudioBlock = (URLContentBlock | Base64ContentBlock | IDContentBlock) & {\n        type: \"audio\";\n    };\n    /**\n     * @deprecated\n     * Use {@link ContentBlock.Multimodal.Standard} instead\n     */\n    type StandardFileBlock = (URLContentBlock | Base64ContentBlock | IDContentBlock | PlainTextContentBlock) & {\n        type: \"file\";\n    };\n    /**\n     * @deprecated\n     * Use {@link ContentBlock.Multimodal.Standard} instead\n     */\n    type StandardTextBlock = PlainTextContentBlock & {\n        type: \"text\";\n    };\n    /**\n     * @deprecated\n     * Use {@link ContentBlock.Multimodal.Data} instead\n     */\n    type DataContentBlockType = DataContentBlock[\"type\"];\n}\n/**\n * @deprecated Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport declare function isDataContentBlock(content_block: object): content_block is Data.DataContentBlock;\n/**\n * @deprecated Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport declare function isURLContentBlock(content_block: object): content_block is Data.URLContentBlock;\n/**\n * @deprecated Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport declare function isBase64ContentBlock(content_block: object): content_block is Data.Base64ContentBlock;\n/**\n * @deprecated Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport declare function isPlainTextContentBlock(content_block: object): content_block is Data.PlainTextContentBlock;\n/**\n * @deprecated Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport declare function isIDContentBlock(content_block: object): content_block is Data.IDContentBlock;\n/**\n * @deprecated Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport declare function convertToOpenAIImageBlock(content_block: Data.URLContentBlock | Data.Base64ContentBlock): {\n    type: string;\n    image_url: {\n        url: string;\n    };\n};\n/**\n * Utility function for ChatModelProviders. Parses a mime type into a type, subtype, and parameters.\n *\n * @param mime_type - The mime type to parse.\n * @returns An object containing the type, subtype, and parameters.\n *\n * @deprecated Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport declare function parseMimeType(mime_type: string): {\n    type: string;\n    subtype: string;\n    parameters: Record<string, string>;\n};\n/**\n * Utility function for ChatModelProviders. Parses a base64 data URL into a typed array or string.\n *\n * @param dataUrl - The base64 data URL to parse.\n * @param asTypedArray - Whether to return the data as a typed array.\n * @returns An object containing the parsed data and mime type, or undefined if the data URL is invalid.\n *\n * @deprecated Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport declare function parseBase64DataUrl({ dataUrl, asTypedArray }: {\n    dataUrl: string;\n    asTypedArray: true;\n}): {\n    data: Uint8Array;\n    mime_type: string;\n} | undefined;\n/**\n * Utility function for ChatModelProviders. Parses a base64 data URL into a typed array or string.\n *\n * @param dataUrl - The base64 data URL to parse.\n * @param asTypedArray - Whether to return the data as a typed array.\n * @returns The parsed data and mime type, or undefined if the data URL is invalid.\n *\n * @deprecated Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport declare function parseBase64DataUrl({ dataUrl, asTypedArray }: {\n    dataUrl: string;\n    asTypedArray?: false;\n}): {\n    data: string;\n    mime_type: string;\n} | undefined;\n/**\n * A bag of provider-specific content block types.\n *\n * Allows implementations of {@link StandardContentBlockConverter} and related to be defined only in\n * terms of the types they support. Also allows for forward compatibility as the set of known\n * standard types grows, as the set of types can be extended without breaking existing\n * implementations of the aforementioned interfaces.\n *\n * @deprecated Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport type ProviderFormatTypes<TextFormat = unknown, ImageFormat = unknown, AudioFormat = unknown, FileFormat = unknown, VideoFormat = unknown> = {\n    text: TextFormat;\n    image: ImageFormat;\n    audio: AudioFormat;\n    file: FileFormat;\n    video: VideoFormat;\n};\n/**\n * Utility interface for converting between standard and provider-specific data content blocks, to be\n * used when implementing chat model providers.\n *\n * Meant to be used with {@link convertToProviderContentBlock} and\n * {@link convertToStandardContentBlock} rather than being consumed directly.\n *\n * @deprecated Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport interface StandardContentBlockConverter<Formats extends Partial<ProviderFormatTypes>> {\n    /**\n     * The name of the provider type that corresponds to the provider-specific content block types\n     * that this converter supports.\n     */\n    providerName: string;\n    /**\n     * Convert from a standard image block to a provider's proprietary image block format.\n     * @param block - The standard image block to convert.\n     * @returns The provider image block.\n     */\n    fromStandardImageBlock?(block: Data.StandardImageBlock): Formats[\"image\"];\n    /**\n     * Convert from a standard audio block to a provider's proprietary audio block format.\n     * @param block - The standard audio block to convert.\n     * @returns The provider audio block.\n     */\n    fromStandardAudioBlock?(block: Data.StandardAudioBlock): Formats[\"audio\"];\n    /**\n     * Convert from a standard file block to a provider's proprietary file block format.\n     * @param block - The standard file block to convert.\n     * @returns The provider file block.\n     */\n    fromStandardFileBlock?(block: Data.StandardFileBlock): Formats[\"file\"];\n    /**\n     * Convert from a standard text block to a provider's proprietary text block format.\n     * @param block - The standard text block to convert.\n     * @returns The provider text block.\n     */\n    fromStandardTextBlock?(block: Data.StandardTextBlock): Formats[\"text\"];\n}\n/**\n * Convert from a standard data content block to a provider's proprietary data content block format.\n *\n * Don't override this method. Instead, override the more specific conversion methods and use this\n * method unmodified.\n *\n * @param block - The standard data content block to convert.\n * @returns The provider data content block.\n * @throws An error if the standard data content block type is not supported.\n *\n * @deprecated Don't use data content blocks. Use {@link ContentBlock.Multimodal.Data} instead.\n */\nexport declare function convertToProviderContentBlock<Formats extends Partial<ProviderFormatTypes>>(block: Data.DataContentBlock, converter: StandardContentBlockConverter<Formats>): Formats[keyof Formats];\n"],"mappings":"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"}

package/dist/messages/content/index.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.cts","names":["BaseContentBlock","Tools","Multimodal","Data","ContentBlock","KNOWN_BLOCK_TYPES","Citation","Array","Record","TValue","Text","Reasoning","NonStandard","Standard"],"sources":["../../../src/messages/content/index.d.ts"],"sourcesContent":["import type { BaseContentBlock } from \"./base.js\";\nimport { type Tools } from \"./tools.js\";\nimport { type Multimodal } from \"./multimodal.js\";\nimport { type Data } from \"./data.js\";\nexport interface ContentBlock extends BaseContentBlock {\n}\nexport declare const KNOWN_BLOCK_TYPES: string[];\n// eslint-disable-next-line @typescript-eslint/no-namespace\nexport declare namespace ContentBlock {\n    /**\n     * Annotation for citing data from a document.\n     */\n    export interface Citation {\n        /**\n         * Type of the content block\n         */\n        readonly type: \"citation\";\n        /**\n         * Source type for the citation.\n         */\n        source?: string;\n        /**\n         * URL of the document source\n         */\n        url?: string;\n        /**\n         * Source document title.\n         *\n         * For example, the page title for a web page or the title of a paper.\n         */\n        title?: string;\n        /**\n         * Start index of the **response text** for which the annotation applies.\n         *\n         * @see {Text}\n         */\n        startIndex?: number;\n        /**\n         * End index of the **response text** for which the annotation applies.\n         *\n         * @see {Text}\n         */\n        endIndex?: number;\n        /**\n         * Excerpt of source text being cited.\n         */\n        citedText?: string;\n    }\n    /**\n     * Text output from a LLM.\n     *\n     * This typically represents the main text content of a message, such as the response\n     * from a language model or the text of a user message.\n     */\n    export interface Text extends ContentBlock {\n        /**\n         * Type of the content block\n         */\n        readonly type: \"text\";\n        /**\n         * Block text.\n         */\n        text: string;\n        /**\n         * Index of block in aggregate response. Used during streaming.\n         */\n        index?: number;\n        /**\n         * Citations and other annotations.\n         */\n        annotations?: Array<Citation | BaseContentBlock>;\n    }\n    /**\n     * Reasoning output from a LLM.\n     */\n    export interface Reasoning extends ContentBlock {\n        /**\n         * Type of the content block\n         */\n        readonly type: \"reasoning\";\n        /**\n         * Reasoning text.\n         *\n         * Either the thought summary or the raw reasoning text itself.\n         * This is often parsed from `<think>` tags in the model's response.\n         */\n        reasoning: string;\n        /**\n         * Index of block in aggregate response. Used during streaming.\n         */\n        index?: number;\n    }\n    /**\n     * Provider-specific content block.\n     *\n     * This is used to represent content blocks that are not part of the standard LangChain content model.\n     * If a provider's non-standard output includes reasoning and tool calls, it should be\n     * the adapter's job to parse that payload and emit the corresponding standard reasoning and tool call blocks.\n     */\n    export interface NonStandard<\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    TValue extends Record<string, any> = Record<string, any>> extends ContentBlock {\n        /**\n         * Type of the content block\n         */\n        type: \"non_standard\";\n        /**\n         * Provider-specific data\n         */\n        value: TValue;\n    }\n    export { Tools };\n    export { Multimodal };\n    export { Data };\n    export type Standard = Text | Reasoning | NonStandard | Tools.Standard | Multimodal.Standard;\n}\n"],"mappings":";;;;;;UAIiBI,YAAAA,SAAqBJ;AAArBI,cAEIC,iBAFiBL,EAAAA,MAAAA,EAAgB;AAEtD;AAEyBI,kBAAAA,YAAAA,CAAY;EAAA;;;EA8DkB,OAAjCG,UAAAA,QAAAA,CAAAA;IAhBYH;;;IA+COI,SAAAA,IAAAA,EAAAA,UAAAA;IAQ1BC;;;IAGFP,MAAAA,CAAAA,EAAAA,MAAAA;IACAC;;;IACiCS,GAAAA,CAAAA,EAAAA,MAAAA;IAAcX;;AAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA5D9DG;;;;;;;;;;;;;;;;kBAgBZG,MAAMD,WAAWN;;;;;qCAKAI;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BpBI,sBAAsBA,6BAA6BJ;;;;;;;;WAQvDK;;WAEFR;WACAC;WACAC;yBACcO,OAAOC,YAAYC,cAAcX,KAAAA,CAAMY,WAAWX,UAAAA,CAAWW"}

package/dist/messages/content/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":["BaseContentBlock","Tools","Multimodal","Data","ContentBlock","KNOWN_BLOCK_TYPES","Citation","Array","Record","TValue","Text","Reasoning","NonStandard","Standard"],"sources":["../../../src/messages/content/index.d.ts"],"sourcesContent":["import type { BaseContentBlock } from \"./base.js\";\nimport { type Tools } from \"./tools.js\";\nimport { type Multimodal } from \"./multimodal.js\";\nimport { type Data } from \"./data.js\";\nexport interface ContentBlock extends BaseContentBlock {\n}\nexport declare const KNOWN_BLOCK_TYPES: string[];\n// eslint-disable-next-line @typescript-eslint/no-namespace\nexport declare namespace ContentBlock {\n    /**\n     * Annotation for citing data from a document.\n     */\n    export interface Citation {\n        /**\n         * Type of the content block\n         */\n        readonly type: \"citation\";\n        /**\n         * Source type for the citation.\n         */\n        source?: string;\n        /**\n         * URL of the document source\n         */\n        url?: string;\n        /**\n         * Source document title.\n         *\n         * For example, the page title for a web page or the title of a paper.\n         */\n        title?: string;\n        /**\n         * Start index of the **response text** for which the annotation applies.\n         *\n         * @see {Text}\n         */\n        startIndex?: number;\n        /**\n         * End index of the **response text** for which the annotation applies.\n         *\n         * @see {Text}\n         */\n        endIndex?: number;\n        /**\n         * Excerpt of source text being cited.\n         */\n        citedText?: string;\n    }\n    /**\n     * Text output from a LLM.\n     *\n     * This typically represents the main text content of a message, such as the response\n     * from a language model or the text of a user message.\n     */\n    export interface Text extends ContentBlock {\n        /**\n         * Type of the content block\n         */\n        readonly type: \"text\";\n        /**\n         * Block text.\n         */\n        text: string;\n        /**\n         * Index of block in aggregate response. Used during streaming.\n         */\n        index?: number;\n        /**\n         * Citations and other annotations.\n         */\n        annotations?: Array<Citation | BaseContentBlock>;\n    }\n    /**\n     * Reasoning output from a LLM.\n     */\n    export interface Reasoning extends ContentBlock {\n        /**\n         * Type of the content block\n         */\n        readonly type: \"reasoning\";\n        /**\n         * Reasoning text.\n         *\n         * Either the thought summary or the raw reasoning text itself.\n         * This is often parsed from `<think>` tags in the model's response.\n         */\n        reasoning: string;\n        /**\n         * Index of block in aggregate response. Used during streaming.\n         */\n        index?: number;\n    }\n    /**\n     * Provider-specific content block.\n     *\n     * This is used to represent content blocks that are not part of the standard LangChain content model.\n     * If a provider's non-standard output includes reasoning and tool calls, it should be\n     * the adapter's job to parse that payload and emit the corresponding standard reasoning and tool call blocks.\n     */\n    export interface NonStandard<\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    TValue extends Record<string, any> = Record<string, any>> extends ContentBlock {\n        /**\n         * Type of the content block\n         */\n        type: \"non_standard\";\n        /**\n         * Provider-specific data\n         */\n        value: TValue;\n    }\n    export { Tools };\n    export { Multimodal };\n    export { Data };\n    export type Standard = Text | Reasoning | NonStandard | Tools.Standard | Multimodal.Standard;\n}\n"],"mappings":";;;;;;UAIiBI,YAAAA,SAAqBJ;AAArBI,cAEIC,iBAFiBL,EAAAA,MAAAA,EAAgB;AAEtD;AAEyBI,kBAAAA,YAAAA,CAAY;EAAA;;;EA8DkB,OAAjCG,UAAAA,QAAAA,CAAAA;IAhBYH;;;IA+COI,SAAAA,IAAAA,EAAAA,UAAAA;IAQ1BC;;;IAGFP,MAAAA,CAAAA,EAAAA,MAAAA;IACAC;;;IACiCS,GAAAA,CAAAA,EAAAA,MAAAA;IAAcX;;AAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA5D9DG;;;;;;;;;;;;;;;;kBAgBZG,MAAMD,WAAWN;;;;;qCAKAI;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BpBI,sBAAsBA,6BAA6BJ;;;;;;;;WAQvDK;;WAEFR;WACAC;WACAC;yBACcO,OAAOC,YAAYC,cAAcX,KAAAA,CAAMY,WAAWX,UAAAA,CAAWW"}

package/dist/messages/content/multimodal.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"multimodal.d.cts","names":["BaseContentBlock","Multimodal","KNOWN_BLOCK_TYPES","BaseDataRecord","Uint8Array","DataRecordFileId","DataRecordUrl","DataRecordBase64","Record","DataRecord","TMetadata","Data","Image","Video","Audio","PlainText","File"],"sources":["../../../src/messages/content/multimodal.d.ts"],"sourcesContent":["import { BaseContentBlock } from \"./base.js\";\nexport type Multimodal = never;\nexport declare const KNOWN_BLOCK_TYPES: string[];\n// eslint-disable-next-line @typescript-eslint/no-namespace\nexport declare namespace Multimodal {\n    type BaseDataRecord = {\n        /**\n         * MIME type of the file.\n         *\n         * @see https://www.iana.org/assignments/media-types/media-types.xhtml#image\n         */\n        mimeType?: string | undefined;\n    };\n    type DataRecordFileId = BaseDataRecord & {\n        /**\n         * ID of the data file, e.g. from a provider's file api\n         */\n        fileId: string;\n        url?: never;\n        data?: never;\n    };\n    type DataRecordUrl = BaseDataRecord & {\n        fileId?: never;\n        /**\n         * URL of the data file\n         */\n        url: string;\n        data?: never;\n    };\n    type DataRecordBase64 = BaseDataRecord & {\n        fileId?: never;\n        url?: never;\n        /**\n         * MIME type of the file. Required for base64 encoding.\n         *\n         * @see https://www.iana.org/assignments/media-types/media-types.xhtml#image\n         */\n        mimeType: string;\n        /**\n         * Base64 encoded string or binary data of the data\n         */\n        data: string | Uint8Array;\n    };\n    type DataRecord = DataRecordFileId | DataRecordUrl | DataRecordBase64;\n    /** Content block for multimodal data */\n    type Data<TMetadata = Record<string, unknown>> = BaseContentBlock & DataRecord & {\n        /**\n         * MIME type of the file. Required for base64 encoding.\n         */\n        mimeType?: string;\n        /**\n         * Metadata of the file\n         */\n        metadata?: TMetadata;\n        /**\n         * Content block identifier for multimodal content, e.g. image, video, audio, file or plain text. This can be either:\n         *  - generated by the provider (e.g., an OpenAI block ID)\n         *  - generated by LangChain upon creation\n         */\n        id?: string;\n    };\n    /** Content block for image data */\n    type Image = Data & {\n        /** Type of the content block */\n        readonly type: \"image\";\n    };\n    /** Content block for video data */\n    type Video = Data & {\n        /** Type of the content block */\n        readonly type: \"video\";\n    };\n    /** Content block for audio data */\n    type Audio = Data & {\n        /** Type of the content block */\n        readonly type: \"audio\";\n    };\n    /** Content block for plain text data */\n    type PlainText = Data & {\n        /** Type of the content block */\n        readonly type: \"text-plain\";\n        /**\n         * Plaintext content. This is optional if the data is base64 encoded.\n         */\n        text?: string;\n        /**\n         * Title of the file, e.g. the title of a document\n         */\n        title?: string;\n        /**\n         * Context for the text, e.g. a description or a summary of the text's content\n         */\n        context?: string;\n    };\n    /** Content block for file data */\n    type File = Data & {\n        /**\n         * Non-descript multimodal content block\n         *\n         * This block is intended for files that aren't covered by existing content block types.\n         */\n        readonly type: \"file\";\n    };\n    type Standard = Image | Video | Audio | PlainText | File;\n}\n"],"mappings":";;;KACYC,UAAAA;AAAZ;AAGyBA,kBAAAA,UAAAA,CAAU;EAAA,KAAA,cAAA,GAAA;IASPE;;;;;IA8BaG,QAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAa,CAAA;EAAmB,KAE/CE,gBAAAA,GAhCEL,cAgCFK,GAAAA;IAA2BR;;;IAiBpCW,MAAAA,EAAAA,MAAAA;IAKAA,GAAAA,CAAAA,EAAAA,KAAAA;IAKAA,IAAAA,CAAAA,EAAAA,KAAAA;EAAI,CAAA;EAKI,KAiBTA,aAAAA,GAzESR,cAyETQ,GAAAA;IAQIC,MAAAA,CAAAA,EAAAA,KAAAA;IAAQC;;;IAA4BG,GAAAA,EAAAA,MAAAA;IAAI,IAAA,CAAA,EAAA,KAAA;;0BAzEhCb;;;;;;;;;;;;mBAYLC;;oBAEDC,mBAAmBC,gBAAgBC;;wBAE/BC,2BAA2BR,mBAAmBS;;;;;;;;eAQrDC;;;;;;;;;eASFC;;;;;eAKAA;;;;;eAKAA;;;;;mBAKIA;;;;;;;;;;;;;;;;;cAiBLA;;;;;;;;kBAQIC,QAAQC,QAAQC,QAAQC,YAAYC"}

package/dist/messages/content/multimodal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"multimodal.d.ts","names":["BaseContentBlock","Multimodal","KNOWN_BLOCK_TYPES","BaseDataRecord","Uint8Array","DataRecordFileId","DataRecordUrl","DataRecordBase64","Record","DataRecord","TMetadata","Data","Image","Video","Audio","PlainText","File"],"sources":["../../../src/messages/content/multimodal.d.ts"],"sourcesContent":["import { BaseContentBlock } from \"./base.js\";\nexport type Multimodal = never;\nexport declare const KNOWN_BLOCK_TYPES: string[];\n// eslint-disable-next-line @typescript-eslint/no-namespace\nexport declare namespace Multimodal {\n    type BaseDataRecord = {\n        /**\n         * MIME type of the file.\n         *\n         * @see https://www.iana.org/assignments/media-types/media-types.xhtml#image\n         */\n        mimeType?: string | undefined;\n    };\n    type DataRecordFileId = BaseDataRecord & {\n        /**\n         * ID of the data file, e.g. from a provider's file api\n         */\n        fileId: string;\n        url?: never;\n        data?: never;\n    };\n    type DataRecordUrl = BaseDataRecord & {\n        fileId?: never;\n        /**\n         * URL of the data file\n         */\n        url: string;\n        data?: never;\n    };\n    type DataRecordBase64 = BaseDataRecord & {\n        fileId?: never;\n        url?: never;\n        /**\n         * MIME type of the file. Required for base64 encoding.\n         *\n         * @see https://www.iana.org/assignments/media-types/media-types.xhtml#image\n         */\n        mimeType: string;\n        /**\n         * Base64 encoded string or binary data of the data\n         */\n        data: string | Uint8Array;\n    };\n    type DataRecord = DataRecordFileId | DataRecordUrl | DataRecordBase64;\n    /** Content block for multimodal data */\n    type Data<TMetadata = Record<string, unknown>> = BaseContentBlock & DataRecord & {\n        /**\n         * MIME type of the file. Required for base64 encoding.\n         */\n        mimeType?: string;\n        /**\n         * Metadata of the file\n         */\n        metadata?: TMetadata;\n        /**\n         * Content block identifier for multimodal content, e.g. image, video, audio, file or plain text. This can be either:\n         *  - generated by the provider (e.g., an OpenAI block ID)\n         *  - generated by LangChain upon creation\n         */\n        id?: string;\n    };\n    /** Content block for image data */\n    type Image = Data & {\n        /** Type of the content block */\n        readonly type: \"image\";\n    };\n    /** Content block for video data */\n    type Video = Data & {\n        /** Type of the content block */\n        readonly type: \"video\";\n    };\n    /** Content block for audio data */\n    type Audio = Data & {\n        /** Type of the content block */\n        readonly type: \"audio\";\n    };\n    /** Content block for plain text data */\n    type PlainText = Data & {\n        /** Type of the content block */\n        readonly type: \"text-plain\";\n        /**\n         * Plaintext content. This is optional if the data is base64 encoded.\n         */\n        text?: string;\n        /**\n         * Title of the file, e.g. the title of a document\n         */\n        title?: string;\n        /**\n         * Context for the text, e.g. a description or a summary of the text's content\n         */\n        context?: string;\n    };\n    /** Content block for file data */\n    type File = Data & {\n        /**\n         * Non-descript multimodal content block\n         *\n         * This block is intended for files that aren't covered by existing content block types.\n         */\n        readonly type: \"file\";\n    };\n    type Standard = Image | Video | Audio | PlainText | File;\n}\n"],"mappings":";;;KACYC,UAAAA;AAAZ;AAGyBA,kBAAAA,UAAAA,CAAU;EAAA,KAAA,cAAA,GAAA;IASPE;;;;;IA8BaG,QAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAa,CAAA;EAAmB,KAE/CE,gBAAAA,GAhCEL,cAgCFK,GAAAA;IAA2BR;;;IAiBpCW,MAAAA,EAAAA,MAAAA;IAKAA,GAAAA,CAAAA,EAAAA,KAAAA;IAKAA,IAAAA,CAAAA,EAAAA,KAAAA;EAAI,CAAA;EAKI,KAiBTA,aAAAA,GAzESR,cAyETQ,GAAAA;IAQIC,MAAAA,CAAAA,EAAAA,KAAAA;IAAQC;;;IAA4BG,GAAAA,EAAAA,MAAAA;IAAI,IAAA,CAAA,EAAA,KAAA;;0BAzEhCb;;;;;;;;;;;;mBAYLC;;oBAEDC,mBAAmBC,gBAAgBC;;wBAE/BC,2BAA2BR,mBAAmBS;;;;;;;;eAQrDC;;;;;;;;;eASFC;;;;;eAKAA;;;;;eAKAA;;;;;mBAKIA;;;;;;;;;;;;;;;;;cAiBLA;;;;;;;;kBAQIC,QAAQC,QAAQC,QAAQC,YAAYC"}

package/dist/messages/content/tools.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tools.d.cts","names":["BaseContentBlock","Tools","KNOWN_BLOCK_TYPES","TName","TArgs","Record","TOutput","ToolCall","ToolCallChunk","InvalidToolCall","ServerToolCall","ServerToolCallChunk","ServerToolCallResult"],"sources":["../../../src/messages/content/tools.d.ts"],"sourcesContent":["import { BaseContentBlock } from \"./base.js\";\nexport type Tools = never;\nexport declare const KNOWN_BLOCK_TYPES: string[];\n// eslint-disable-next-line @typescript-eslint/no-namespace\nexport declare namespace Tools {\n    /**\n     * Represents a request to call a tool.\n     *\n     * @example\n     * ```ts\n     * const toolCall: ToolCall = {\n     *     type: \"tool_call\",\n     *     name: \"foo\",\n     *     args: { a: 1 },\n     *     callId: \"123\"\n     * };\n     * ```\n     * This represents a request to call the tool named \"foo\" with arguments {\"a\": 1}\n     * and an identifier of \"123\".\n     */\n    interface ToolCall<TName extends string = string, TArgs = unknown> extends BaseContentBlock {\n        /**\n         * Type of the content block\n         */\n        readonly type: \"tool_call\";\n        /**\n         * The name of the tool being called\n         */\n        name: TName;\n        /**\n         * The arguments to the tool call\n         */\n        args: TArgs;\n    }\n    /** Content block to represent partial data of a tool call */\n    interface ToolCallChunk<TName extends string = string> extends BaseContentBlock {\n        /**\n         * Type of the content block\n         */\n        readonly type: \"tool_call_chunk\";\n        /**\n         * The name of the tool being called\n         */\n        name?: TName;\n        /**\n         * The arguments to the tool call\n         */\n        args?: string;\n        /**\n         * The index of the tool call chunk\n         */\n        index?: number;\n    }\n    /** Content block to represent an invalid tool call */\n    interface InvalidToolCall<TName extends string = string> extends BaseContentBlock {\n        /**\n         * Type of the content block\n         */\n        readonly type: \"invalid_tool_call\";\n        /**\n         * The name of the tool being called\n         */\n        name?: TName;\n        /**\n         * The arguments to the tool call\n         */\n        args?: string;\n        /**\n         * An error message associated with the tool call\n         */\n        error?: string;\n        /**\n         * Index of block in aggregate response\n         */\n        index?: string | number;\n    }\n    interface ServerToolCall<TName extends string = string, TArgs = unknown> extends BaseContentBlock {\n        /**\n         * Type of the content block\n         */\n        readonly type: \"server_tool_call\";\n        /**\n         * The name of the tool being called\n         */\n        name: TName;\n        /**\n         * The arguments to the tool call\n         */\n        args: TArgs;\n    }\n    interface ServerToolCallChunk<TName extends string = string> extends BaseContentBlock {\n        /**\n         * Type of the content block\n         */\n        readonly type: \"server_tool_call_chunk\";\n        /**\n         * The name of the tool being called\n         */\n        name?: TName;\n        /**\n         * The arguments to the tool call\n         */\n        args?: string;\n    }\n    interface ServerToolCallResult<TOutput = Record<string, unknown>> extends BaseContentBlock {\n        /**\n         * Type of the content block\n         */\n        readonly type: \"server_tool_call_result\";\n        /**\n         * The unique identifier of the tool call that this result corresponds to\n         */\n        toolCallId: string;\n        /**\n         * The status of the server tool call\n         */\n        status: \"success\" | \"error\";\n        /**\n         * The output of the server tool call\n         */\n        output: TOutput;\n    }\n    type Standard = ToolCall | ToolCallChunk | InvalidToolCall | ServerToolCall | ServerToolCallChunk | ServerToolCallResult;\n}\n"],"mappings":";;;KACYC,KAAAA;AAAZ;AAGyBA,kBAAAA,KAAAA,CAAK;EAAA;;;;;;;;;;;;;;;EAoHP,UAhBuDD,QAAAA,CAAAA,cAAAA,MAAAA,GAAAA,MAAAA,EAAAA,QAAAA,OAAAA,CAAAA,SApFCA,gBAoFDA,CAAAA;IAkB1DO;;;IAA6CG,SAAAA,IAAAA,EAAAA,WAAAA;IAAiBC;;AAA0C;UA9F9GR;;;;UAIAC;;;iEAGqDJ;;;;;;;;WAQpDG;;;;;;;;;;;mEAWsDH;;;;;;;;WAQtDG;;;;;;;;;;;;;;mFAcsEH;;;;;;;;UAQvEG;;;;UAIAC;;uEAE2DJ;;;;;;;;WAQ1DG;;;;;;2CAM8BE,iCAAiCL;;;;;;;;;;;;;;;;YAgB9DM;;kBAEIC,WAAWC,gBAAgBC,kBAAkBC,iBAAiBC,sBAAsBC"}

package/dist/messages/content/tools.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tools.d.ts","names":["BaseContentBlock","Tools","KNOWN_BLOCK_TYPES","TName","TArgs","Record","TOutput","ToolCall","ToolCallChunk","InvalidToolCall","ServerToolCall","ServerToolCallChunk","ServerToolCallResult"],"sources":["../../../src/messages/content/tools.d.ts"],"sourcesContent":["import { BaseContentBlock } from \"./base.js\";\nexport type Tools = never;\nexport declare const KNOWN_BLOCK_TYPES: string[];\n// eslint-disable-next-line @typescript-eslint/no-namespace\nexport declare namespace Tools {\n    /**\n     * Represents a request to call a tool.\n     *\n     * @example\n     * ```ts\n     * const toolCall: ToolCall = {\n     *     type: \"tool_call\",\n     *     name: \"foo\",\n     *     args: { a: 1 },\n     *     callId: \"123\"\n     * };\n     * ```\n     * This represents a request to call the tool named \"foo\" with arguments {\"a\": 1}\n     * and an identifier of \"123\".\n     */\n    interface ToolCall<TName extends string = string, TArgs = unknown> extends BaseContentBlock {\n        /**\n         * Type of the content block\n         */\n        readonly type: \"tool_call\";\n        /**\n         * The name of the tool being called\n         */\n        name: TName;\n        /**\n         * The arguments to the tool call\n         */\n        args: TArgs;\n    }\n    /** Content block to represent partial data of a tool call */\n    interface ToolCallChunk<TName extends string = string> extends BaseContentBlock {\n        /**\n         * Type of the content block\n         */\n        readonly type: \"tool_call_chunk\";\n        /**\n         * The name of the tool being called\n         */\n        name?: TName;\n        /**\n         * The arguments to the tool call\n         */\n        args?: string;\n        /**\n         * The index of the tool call chunk\n         */\n        index?: number;\n    }\n    /** Content block to represent an invalid tool call */\n    interface InvalidToolCall<TName extends string = string> extends BaseContentBlock {\n        /**\n         * Type of the content block\n         */\n        readonly type: \"invalid_tool_call\";\n        /**\n         * The name of the tool being called\n         */\n        name?: TName;\n        /**\n         * The arguments to the tool call\n         */\n        args?: string;\n        /**\n         * An error message associated with the tool call\n         */\n        error?: string;\n        /**\n         * Index of block in aggregate response\n         */\n        index?: string | number;\n    }\n    interface ServerToolCall<TName extends string = string, TArgs = unknown> extends BaseContentBlock {\n        /**\n         * Type of the content block\n         */\n        readonly type: \"server_tool_call\";\n        /**\n         * The name of the tool being called\n         */\n        name: TName;\n        /**\n         * The arguments to the tool call\n         */\n        args: TArgs;\n    }\n    interface ServerToolCallChunk<TName extends string = string> extends BaseContentBlock {\n        /**\n         * Type of the content block\n         */\n        readonly type: \"server_tool_call_chunk\";\n        /**\n         * The name of the tool being called\n         */\n        name?: TName;\n        /**\n         * The arguments to the tool call\n         */\n        args?: string;\n    }\n    interface ServerToolCallResult<TOutput = Record<string, unknown>> extends BaseContentBlock {\n        /**\n         * Type of the content block\n         */\n        readonly type: \"server_tool_call_result\";\n        /**\n         * The unique identifier of the tool call that this result corresponds to\n         */\n        toolCallId: string;\n        /**\n         * The status of the server tool call\n         */\n        status: \"success\" | \"error\";\n        /**\n         * The output of the server tool call\n         */\n        output: TOutput;\n    }\n    type Standard = ToolCall | ToolCallChunk | InvalidToolCall | ServerToolCall | ServerToolCallChunk | ServerToolCallResult;\n}\n"],"mappings":";;;KACYC,KAAAA;AAAZ;AAGyBA,kBAAAA,KAAAA,CAAK;EAAA;;;;;;;;;;;;;;;EAoHP,UAhBuDD,QAAAA,CAAAA,cAAAA,MAAAA,GAAAA,MAAAA,EAAAA,QAAAA,OAAAA,CAAAA,SApFCA,gBAoFDA,CAAAA;IAkB1DO;;;IAA6CG,SAAAA,IAAAA,EAAAA,WAAAA;IAAiBC;;AAA0C;UA9F9GR;;;;UAIAC;;;iEAGqDJ;;;;;;;;WAQpDG;;;;;;;;;;;mEAWsDH;;;;;;;;WAQtDG;;;;;;;;;;;;;;mFAcsEH;;;;;;;;UAQvEG;;;;UAIAC;;uEAE2DJ;;;;;;;;WAQ1DG;;;;;;2CAM8BE,iCAAiCL;;;;;;;;;;;;;;;;YAgB9DM;;kBAEIC,WAAWC,gBAAgBC,kBAAkBC,iBAAiBC,sBAAsBC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"format.d.cts","names":["BaseMessage","MessageStringFormat","convertToFormattedString"],"sources":["../../src/messages/format.d.ts"],"sourcesContent":["import { type BaseMessage } from \"./base.js\";\nexport type MessageStringFormat = \"pretty\";\nexport declare function convertToFormattedString(message: BaseMessage, format?: MessageStringFormat): string;\n"],"mappings":";AACYC,KAAAA,mBAAAA,GAAmB,QAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"format.d.ts","names":["BaseMessage","MessageStringFormat","convertToFormattedString"],"sources":["../../src/messages/format.d.ts"],"sourcesContent":["import { type BaseMessage } from \"./base.js\";\nexport type MessageStringFormat = \"pretty\";\nexport declare function convertToFormattedString(message: BaseMessage, format?: MessageStringFormat): string;\n"],"mappings":";AACYC,KAAAA,mBAAAA,GAAmB,QAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"function.d.cts","names":["BaseMessage","BaseMessageChunk","BaseMessageFields","MessageStructure","FunctionMessageFields","TStructure","FunctionMessage","FunctionMessageChunk","isFunctionMessage","isFunctionMessageChunk"],"sources":["../../src/messages/function.d.ts"],"sourcesContent":["import { BaseMessage, BaseMessageChunk, type BaseMessageFields } from \"./base.js\";\nimport { MessageStructure } from \"./message.js\";\nexport interface FunctionMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, \"function\"> {\n    name: string;\n}\n/**\n * Represents a function message in a conversation.\n */\nexport declare class FunctionMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, \"function\"> implements FunctionMessageFields<TStructure> {\n    static lc_name(): string;\n    readonly type: \"function\";\n    name: string;\n    constructor(fields: FunctionMessageFields<TStructure>);\n}\n/**\n * Represents a chunk of a function message, which can be concatenated\n * with other function message chunks.\n */\nexport declare class FunctionMessageChunk<TStructure extends MessageStructure = MessageStructure> extends BaseMessageChunk<TStructure, \"function\"> {\n    static lc_name(): string;\n    readonly type: \"function\";\n    concat(chunk: FunctionMessageChunk<TStructure>): this;\n}\nexport declare function isFunctionMessage(x: BaseMessage): x is FunctionMessage;\nexport declare function isFunctionMessageChunk(x: BaseMessageChunk): x is FunctionMessageChunk;\n"],"mappings":";;;;UAEiBI,yCAAyCD,mBAAmBA,0BAA0BD,kBAAkBG;;AAAzH;;;;AAAyHA,cAMpGC,eANoGD,CAAAA,mBAMjEF,gBANiEE,GAM9CF,gBAN8CE,CAAAA,SAMpBL,WANoBK,CAMRA,UANQA,EAAAA,UAAAA,CAAAA,YAM2BD,qBAN3BC,CAMiDA,UANjDA,CAAAA,CAAAA;EAAU,OAA5BH,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAiB,SAAA,IAAA,EAAA,UAAA;EAMnGI,IAAAA,EAAAA,MAAAA;EAAe,WAAA,CAAA,MAAA,EAIZF,qBAJY,CAIUC,UAJV,CAAA;;;;;;AAIZD,cAMHG,oBANGH,CAAAA,mBAMqCD,gBANrCC,GAMwDD,gBANxDC,CAAAA,SAMkFH,gBANlFG,CAMmGC,UANnGD,EAAAA,UAAAA,CAAAA,CAAAA;EAAqB,OAJwDJ,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAW,SAAoCI,IAAAA,EAAAA,UAAAA;EAAqB,MAAA,CAAA,KAAA,EAavJG,oBAbuJ,CAalIF,UAbkI,CAAA,CAAA,EAAA,IAAA;AAUzK;AAAyC,iBAKjBG,iBAAAA,CALiB,CAAA,EAKIR,WALJ,CAAA,EAAA,CAAA,IAKuBM,eALvB;AAAoBH,iBAMrCM,sBAAAA,CANqCN,CAAAA,EAMXF,gBANWE,CAAAA,EAAAA,CAAAA,IAMaI,oBANbJ"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"function.d.ts","names":["BaseMessage","BaseMessageChunk","BaseMessageFields","MessageStructure","FunctionMessageFields","TStructure","FunctionMessage","FunctionMessageChunk","isFunctionMessage","isFunctionMessageChunk"],"sources":["../../src/messages/function.d.ts"],"sourcesContent":["import { BaseMessage, BaseMessageChunk, type BaseMessageFields } from \"./base.js\";\nimport { MessageStructure } from \"./message.js\";\nexport interface FunctionMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, \"function\"> {\n    name: string;\n}\n/**\n * Represents a function message in a conversation.\n */\nexport declare class FunctionMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, \"function\"> implements FunctionMessageFields<TStructure> {\n    static lc_name(): string;\n    readonly type: \"function\";\n    name: string;\n    constructor(fields: FunctionMessageFields<TStructure>);\n}\n/**\n * Represents a chunk of a function message, which can be concatenated\n * with other function message chunks.\n */\nexport declare class FunctionMessageChunk<TStructure extends MessageStructure = MessageStructure> extends BaseMessageChunk<TStructure, \"function\"> {\n    static lc_name(): string;\n    readonly type: \"function\";\n    concat(chunk: FunctionMessageChunk<TStructure>): this;\n}\nexport declare function isFunctionMessage(x: BaseMessage): x is FunctionMessage;\nexport declare function isFunctionMessageChunk(x: BaseMessageChunk): x is FunctionMessageChunk;\n"],"mappings":";;;;UAEiBI,yCAAyCD,mBAAmBA,0BAA0BD,kBAAkBG;;AAAzH;;;;AAAyHA,cAMpGC,eANoGD,CAAAA,mBAMjEF,gBANiEE,GAM9CF,gBAN8CE,CAAAA,SAMpBL,WANoBK,CAMRA,UANQA,EAAAA,UAAAA,CAAAA,YAM2BD,qBAN3BC,CAMiDA,UANjDA,CAAAA,CAAAA;EAAU,OAA5BH,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAiB,SAAA,IAAA,EAAA,UAAA;EAMnGI,IAAAA,EAAAA,MAAAA;EAAe,WAAA,CAAA,MAAA,EAIZF,qBAJY,CAIUC,UAJV,CAAA;;;;;;AAIZD,cAMHG,oBANGH,CAAAA,mBAMqCD,gBANrCC,GAMwDD,gBANxDC,CAAAA,SAMkFH,gBANlFG,CAMmGC,UANnGD,EAAAA,UAAAA,CAAAA,CAAAA;EAAqB,OAJwDJ,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAW,SAAoCI,IAAAA,EAAAA,UAAAA;EAAqB,MAAA,CAAA,KAAA,EAavJG,oBAbuJ,CAalIF,UAbkI,CAAA,CAAA,EAAA,IAAA;AAUzK;AAAyC,iBAKjBG,iBAAAA,CALiB,CAAA,EAKIR,WALJ,CAAA,EAAA,CAAA,IAKuBM,eALvB;AAAoBH,iBAMrCM,sBAAAA,CANqCN,CAAAA,EAMXF,gBANWE,CAAAA,EAAAA,CAAAA,IAMaI,oBANbJ"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"human.d.cts","names":["BaseMessage","BaseMessageChunk","BaseMessageFields","$InferMessageContent","MessageStructure","HumanMessageFields","TStructure","HumanMessage","HumanMessageChunk","isHumanMessage","isHumanMessageChunk"],"sources":["../../src/messages/human.d.ts"],"sourcesContent":["import { BaseMessage, BaseMessageChunk, type BaseMessageFields } from \"./base.js\";\nimport type { $InferMessageContent, MessageStructure } from \"./message.js\";\nexport interface HumanMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, \"human\"> {\n}\n/**\n * Represents a human message in a conversation.\n */\nexport declare class HumanMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, \"human\"> {\n    static lc_name(): string;\n    readonly type: \"human\";\n    constructor(fields: $InferMessageContent<TStructure, \"human\"> | HumanMessageFields<TStructure>);\n    static isInstance(obj: unknown): obj is HumanMessage;\n}\n/**\n * Represents a chunk of a human message, which can be concatenated with\n * other human message chunks.\n */\nexport declare class HumanMessageChunk<TStructure extends MessageStructure = MessageStructure> extends BaseMessageChunk<TStructure, \"human\"> {\n    static lc_name(): string;\n    readonly type: \"human\";\n    constructor(fields: $InferMessageContent<TStructure, \"human\"> | HumanMessageFields<TStructure>);\n    concat(chunk: HumanMessageChunk<TStructure>): this;\n    static isInstance(obj: unknown): obj is HumanMessageChunk;\n}\n/**\n * @deprecated Use {@link HumanMessage.isInstance} instead\n */\nexport declare function isHumanMessage<TStructure extends MessageStructure>(x: BaseMessage): x is HumanMessage<TStructure>;\n/**\n * @deprecated Use {@link HumanMessageChunk.isInstance} instead\n */\nexport declare function isHumanMessageChunk<TStructure extends MessageStructure>(x: BaseMessageChunk): x is HumanMessageChunk<TStructure>;\n"],"mappings":";;;;UAEiBK,sCAAsCD,mBAAmBA,0BAA0BF,kBAAkBI;AAAtH;;;AAA0EF,cAKrDG,YALqDH,CAAAA,mBAKrBA,gBALqBA,GAKFA,gBALEA,CAAAA,SAKwBJ,WALxBI,CAKoCE,UALpCF,EAAAA,OAAAA,CAAAA,CAAAA;EAAgB,OAA4BE,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAU,SAA5BJ,IAAAA,EAAAA,OAAAA;EAAiB,WAAA,CAAA,MAAA,EAQ7FC,oBAR6F,CAQxEG,UARwE,EAAA,OAAA,CAAA,GAQjDD,kBARiD,CAQ9BC,UAR8B,CAAA;EAKhGC,OAAAA,UAAY,CAAA,GAAA,EAAA,OAAA,CAAA,EAAA,GAAA,IAIWA,YAJX;;;;;;AAGTJ,cAOHK,iBAPGL,CAAAA,mBAOkCC,gBAPlCD,GAOqDC,gBAPrDD,CAAAA,SAO+EF,gBAP/EE,CAOgGG,UAPhGH,EAAAA,OAAAA,CAAAA,CAAAA;EAAoB,OAA2CG,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAU,SAA7BD,IAAAA,EAAAA,OAAAA;EAAkB,WAC1CE,CAAAA,MAAAA,EASpBJ,oBAToBI,CASCD,UATDC,EAAAA,OAAAA,CAAAA,GASwBF,kBATxBE,CAS2CD,UAT3CC,CAAAA;EAAY,MAJ0CP,CAAAA,KAAAA,EAchFQ,iBAdgFR,CAc9DM,UAd8DN,CAAAA,CAAAA,EAAAA,IAAAA;EAAW,OAAA,UAAA,CAAA,GAAA,EAAA,OAAA,CAAA,EAAA,GAAA,IAejEQ,iBAfiE;AAU7G;;;;AAAwHF,iBAUhGG,cAVgGH,CAAAA,mBAU9DF,gBAV8DE,CAAAA,CAAAA,CAAAA,EAUzCN,WAVyCM,CAAAA,EAAAA,CAAAA,IAUtBC,YAVsBD,CAUTA,UAVSA,CAAAA;;;;AAGpDD,iBAW5CK,mBAX4CL,CAAAA,mBAWLD,gBAXKC,CAAAA,CAAAA,CAAAA,EAWgBJ,gBAXhBI,CAAAA,EAAAA,CAAAA,IAWwCG,iBAXxCH,CAW0DC,UAX1DD,CAAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"human.d.ts","names":["BaseMessage","BaseMessageChunk","BaseMessageFields","$InferMessageContent","MessageStructure","HumanMessageFields","TStructure","HumanMessage","HumanMessageChunk","isHumanMessage","isHumanMessageChunk"],"sources":["../../src/messages/human.d.ts"],"sourcesContent":["import { BaseMessage, BaseMessageChunk, type BaseMessageFields } from \"./base.js\";\nimport type { $InferMessageContent, MessageStructure } from \"./message.js\";\nexport interface HumanMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, \"human\"> {\n}\n/**\n * Represents a human message in a conversation.\n */\nexport declare class HumanMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, \"human\"> {\n    static lc_name(): string;\n    readonly type: \"human\";\n    constructor(fields: $InferMessageContent<TStructure, \"human\"> | HumanMessageFields<TStructure>);\n    static isInstance(obj: unknown): obj is HumanMessage;\n}\n/**\n * Represents a chunk of a human message, which can be concatenated with\n * other human message chunks.\n */\nexport declare class HumanMessageChunk<TStructure extends MessageStructure = MessageStructure> extends BaseMessageChunk<TStructure, \"human\"> {\n    static lc_name(): string;\n    readonly type: \"human\";\n    constructor(fields: $InferMessageContent<TStructure, \"human\"> | HumanMessageFields<TStructure>);\n    concat(chunk: HumanMessageChunk<TStructure>): this;\n    static isInstance(obj: unknown): obj is HumanMessageChunk;\n}\n/**\n * @deprecated Use {@link HumanMessage.isInstance} instead\n */\nexport declare function isHumanMessage<TStructure extends MessageStructure>(x: BaseMessage): x is HumanMessage<TStructure>;\n/**\n * @deprecated Use {@link HumanMessageChunk.isInstance} instead\n */\nexport declare function isHumanMessageChunk<TStructure extends MessageStructure>(x: BaseMessageChunk): x is HumanMessageChunk<TStructure>;\n"],"mappings":";;;;UAEiBK,sCAAsCD,mBAAmBA,0BAA0BF,kBAAkBI;AAAtH;;;AAA0EF,cAKrDG,YALqDH,CAAAA,mBAKrBA,gBALqBA,GAKFA,gBALEA,CAAAA,SAKwBJ,WALxBI,CAKoCE,UALpCF,EAAAA,OAAAA,CAAAA,CAAAA;EAAgB,OAA4BE,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAU,SAA5BJ,IAAAA,EAAAA,OAAAA;EAAiB,WAAA,CAAA,MAAA,EAQ7FC,oBAR6F,CAQxEG,UARwE,EAAA,OAAA,CAAA,GAQjDD,kBARiD,CAQ9BC,UAR8B,CAAA;EAKhGC,OAAAA,UAAY,CAAA,GAAA,EAAA,OAAA,CAAA,EAAA,GAAA,IAIWA,YAJX;;;;;;AAGTJ,cAOHK,iBAPGL,CAAAA,mBAOkCC,gBAPlCD,GAOqDC,gBAPrDD,CAAAA,SAO+EF,gBAP/EE,CAOgGG,UAPhGH,EAAAA,OAAAA,CAAAA,CAAAA;EAAoB,OAA2CG,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAU,SAA7BD,IAAAA,EAAAA,OAAAA;EAAkB,WAC1CE,CAAAA,MAAAA,EASpBJ,oBAToBI,CASCD,UATDC,EAAAA,OAAAA,CAAAA,GASwBF,kBATxBE,CAS2CD,UAT3CC,CAAAA;EAAY,MAJ0CP,CAAAA,KAAAA,EAchFQ,iBAdgFR,CAc9DM,UAd8DN,CAAAA,CAAAA,EAAAA,IAAAA;EAAW,OAAA,UAAA,CAAA,GAAA,EAAA,OAAA,CAAA,EAAA,GAAA,IAejEQ,iBAfiE;AAU7G;;;;AAAwHF,iBAUhGG,cAVgGH,CAAAA,mBAU9DF,gBAV8DE,CAAAA,CAAAA,CAAAA,EAUzCN,WAVyCM,CAAAA,EAAAA,CAAAA,IAUtBC,YAVsBD,CAUTA,UAVSA,CAAAA;;;;AAGpDD,iBAW5CK,mBAX4CL,CAAAA,mBAWLD,gBAXKC,CAAAA,CAAAA,CAAAA,EAWgBJ,gBAXhBI,CAAAA,EAAAA,CAAAA,IAWwCG,iBAXxCH,CAW0DC,UAX1DD,CAAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"message.d.cts","names":["ContentBlock","ResponseMetadata","UsageMetadata","$MergeDiscriminatedUnion","$MergeObjects","MessageType","NonNullable","MessageOutputVersion","MessageToolDefinition","TInput","TOutput","MessageToolSet","$MessageToolCallBlock","MessageStructure","TStructure","K","Tools","ToolCall","Partial","Record","$NormalizeMessageOutputVersion","T","Extract","$MergeOutputVersion","U","TV","UV","Exclude","$MergeContentDefinition","$MergeMessageStructure","StandardMessageStructure","Text","$NormalizedMessageStructure","$InferMessageContentBlocks","S","C","PropertyKey","TRole","$InferMessageContent","Array","$InferMessageProperties","P","Omit","$InferMessageProperty","$InferResponseMetadata","Message","isMessage"],"sources":["../../src/messages/message.d.ts"],"sourcesContent":["import type { ContentBlock } from \"./content/index.js\";\nimport type { ResponseMetadata, UsageMetadata } from \"./metadata.js\";\nimport type { $MergeDiscriminatedUnion, $MergeObjects } from \"./utils.js\";\n/**\n * Represents the possible types of messages in the system.\n * Includes standard message types (\"ai\", \"human\", \"tool\", \"system\")\n * and allows for custom string types that are non-null.\n *\n * @example\n * ```ts\n * // Standard message types\n * const messageType1: MessageType = \"ai\";\n * const messageType2: MessageType = \"human\";\n *\n * // Custom message type\n * const messageType3: MessageType = \"custom_type\";\n * ```\n */\nexport type MessageType = \"ai\" | \"human\" | \"tool\" | \"system\" | (string & NonNullable<unknown>);\n/**\n * Represents the output version format for message content.\n *\n * This type determines how the content field is structured in a message:\n * - \"v0\": Content is represented as a simple string or array of content blocks\n *   - provides backward compatibility with simpler content representations\n * - \"v1\": Content follows the structured ContentBlock format with typed discriminated unions\n *   - enables full type safety and structured content block handling\n *\n * @example\n * ```ts\n * // v0 format - simple content representation\n * const v0Message: Message<{ outputVersion: \"v0\", content: ... }> = {\n *   type: \"human\",\n *   content: \"Hello world\" // string | Array<ContentBlock | ContentBlock.Text>\n * };\n *\n * // v1 format - structured content blocks\n * const v1Message: Message<{ outputVersion: \"v1\", content: ... }> = {\n *   type: \"human\",\n *   content: [\n *     { type: \"text\", text: \"Hello world\" },\n *     { type: \"image\", image_url: \"...\" }\n *   ] // Array<ContentBlock | ...> (determined by the structure)\n * };\n * ```\n */\nexport type MessageOutputVersion = \"v0\" | \"v1\";\n/**\n * Represents the input and output types of a tool that can be used in messages.\n *\n * @template TInput - The type of input the tool accepts.\n * @template TOutput - The type of output the tool produces.\n *\n * @example\n * ```ts\n * // Tool that takes a string input and returns a number\n * interface StringToNumberTool extends MessageToolDefinition<string, number> {\n *   input: string;\n *   output: number;\n * }\n * ```\n */\nexport interface MessageToolDefinition<TInput = unknown, TOutput = unknown> {\n    input: TInput;\n    output: TOutput;\n}\n/**\n * Represents a structured set of tools by mapping tool names to definitions\n * that can be used in messages.\n *\n * @example\n * ```ts\n * interface MyToolSet extends MessageToolSet {\n *   calculator: MessageToolDefinition<\n *     { operation: string; numbers: number[] },\n *     number\n *   >;\n *   translator: MessageToolDefinition<\n *     { text: string; targetLanguage: string },\n *     string\n *   >;\n * }\n * ```\n */\nexport interface MessageToolSet {\n    [key: string]: MessageToolDefinition;\n}\n/**\n * Represents a tool call block within a message structure by mapping tool names to their\n * corresponding tool call formats, including the input arguments and an optional identifier.\n *\n * @template TStructure - A message structure type that may contain tool definitions\n *\n * @example\n * ```ts\n * // Given a message structure with a calculator tool:\n * interface MyStructure extends MessageStructure {\n *   tools: {\n *     calculator: MessageToolDefinition<{ operation: string, numbers: number[] }, number>\n *   }\n * }\n *\n * // The tool call block would be:\n * type CalcToolCall = $MessageToolCallBlock<MyStructure>;\n * // Resolves to:\n * // {\n * //   type: \"tool_call\";\n * //   name: \"calculator\";\n * //   args: { operation: string, numbers: number[] };\n * //   id?: string;\n * // }\n * ```\n */\nexport type $MessageToolCallBlock<TStructure extends MessageStructure> = TStructure[\"tools\"] extends MessageToolSet ? {\n    [K in keyof TStructure[\"tools\"]]: K extends string ? TStructure[\"tools\"][K] extends MessageToolDefinition ? ContentBlock.Tools.ToolCall<K, TStructure[\"tools\"][K][\"input\"]> : never : never;\n}[keyof TStructure[\"tools\"]] : never;\n/**\n * Core interface that defines the structure of messages.\n *\n * @example\n * ```ts\n * // Basic message structure with just content blocks\n * interface SimpleMessageStructure extends MessageStructure {\n *   content: {\n *     human: ContentBlock.Text;\n *     // allows for text + reasoning blocks in ai messages\n *     ai: ContentBlock.Text | ContentBlock.Reasoning;\n *   }\n * }\n *\n * // Message structure with tools and properties\n * interface AdvancedMessageStructure extends MessageStructure {\n *   tools: {\n *     calculator: MessageToolDefinition<\n *       { operation: string; numbers: number[] },\n *       number\n *     >;\n *   };\n *   content: {\n *     // allows for text + image blocks in human messages\n *     human: ContentBlock.Text | ContentBlock.Multimodal.Image;\n *     // only allows for text blocks in ai messages\n *     ai: ContentBlock.Text;\n *   };\n *   properties: {\n *     // pins properties to ai messages\n *     ai: {\n *       response_metadata: {\n *         confidence: number;\n *         model: string;\n *       };\n *     };\n *   }\n * }\n *\n * // Using with $MergeMessageStructure to combine structures\n * // The resulting type when passed into BaseMessage will have a calculator tool,\n * // allow for text + image blocks in human messages,\n * // and text + reasoning blocks + additional arbitrary properties in ai messages.\n * type CombinedStructure = $MergeMessageStructure<\n *   SimpleMessageStructure,\n *   AdvancedMessageStructure\n * >;\n *\n * // Using in a Message object\n * const message: Message<CombinedStructure> = {\n *   id: \"msg-123\",\n *   type: \"human\",\n *   content: [\n *     { type: \"text\", text: \"Hello!\" }\n *     { type: \"image\", mimeType: \"image/jpeg\", url: \"https://example.com/image.jpg\" }\n *     // this block will throw an error because it's not defined in the structure\n *     { type: \"reasoning\", reasoning: \"The answer is 42\" }\n *   ]\n * };\n * ```\n */\nexport interface MessageStructure {\n    /**\n     * Optional output version for the message structure.\n     * If not provided, defaults to \"v0\".\n     */\n    readonly outputVersion?: MessageOutputVersion;\n    /**\n     * Optional set of tool definitions that can be used in messages.\n     * Each tool is defined with input/output types and can be referenced in tool messages.\n     */\n    readonly tools?: MessageToolSet;\n    /**\n     * Optional mapping of message types to their allowed content blocks.\n     * Each message type can specify what content block types it supports (text, images, etc).\n     */\n    readonly content?: Partial<{\n        [key in MessageType]: ContentBlock;\n    }>;\n    /**\n     * Optional mapping of message types to arbitrary property objects.\n     * Allows attaching custom metadata or other information to specific message types.\n     */\n    readonly properties?: Partial<{\n        [key in MessageType]: Record<string, unknown>;\n    }>;\n}\n/**\n * Normalizes an arbitrary type to a message output version or undefined.\n * Accepts unknown and narrows to a valid MessageOutputVersion if present.\n */\ntype $NormalizeMessageOutputVersion<T> = Extract<T, MessageOutputVersion> | undefined;\n/**\n * Merges two output version types from message structures.\n *\n * This utility type determines the resulting output version when combining two message structures.\n * The merge logic follows these rules:\n *\n * - If both T and U are undefined, defaults to \"v0\" for backwards compatibility\n * - If T is undefined but U is defined, uses U's version\n * - If U is undefined but T is defined, uses T's version\n * - If both T and U are defined, U takes precedence (later structure wins)\n *\n * @template T - The output version from the first message structure\n * @template U - The output version from the second message structure\n *\n * @example\n * ```ts\n * // Both undefined - defaults to \"v0\"\n * type Result1 = $MergeOutputVersion<undefined, undefined>; // \"v0\"\n *\n * // One defined - uses the defined version\n * type Result2 = $MergeOutputVersion<undefined, \"v1\">; // \"v1\"\n * type Result3 = $MergeOutputVersion<\"v0\", undefined>; // \"v0\"\n *\n * // Both defined - second takes precedence\n * type Result4 = $MergeOutputVersion<\"v0\", \"v1\">; // \"v1\"\n * ```\n */\nexport type $MergeOutputVersion<T, U> = $NormalizeMessageOutputVersion<T> extends infer TV ? $NormalizeMessageOutputVersion<U> extends infer UV ? [TV, UV] extends [undefined, undefined] ? \"v0\" : [TV] extends [undefined] ? Exclude<UV, undefined> : [UV] extends [undefined] ? Exclude<TV, undefined> : UV : never : never;\n/**\n * Merges two content definition objects from message structures.\n *\n * This utility type combines content definitions from two message structures, handling\n * the merging of content block types for each message type. The merge logic follows\n * these rules:\n *\n * - For keys that exist in both T and U: Merges the content blocks using discriminated\n *   union merging based on the \"type\" property. This allows combining different content\n *   block types (e.g., text + image) for the same message type.\n * - For keys that exist only in T: Uses T's content definition as-is\n * - For keys that exist only in U: Uses U's content definition as-is\n *\n * @template T - The content definition from the first message structure\n * @template U - The content definition from the second message structure\n *\n * @example\n * ```ts\n * // T allows text content for human messages\n * type ContentA = {\n *   human: ContentBlock.Text;\n * };\n *\n * // U allows image content for human messages and text for AI messages\n * type ContentB = {\n *   human: ContentBlock.Multimodal.Image;\n *   ai: ContentBlock.Text;\n * };\n *\n * // Merged result allows both text and images for human messages, text for AI\n * type Merged = $MergeContentDefinition<ContentA, ContentB>;\n * // Result: {\n * //   human: ContentBlock.Text | ContentBlock.Multimodal.Image;\n * //   ai: ContentBlock.Text;\n * // }\n * ```\n */\nexport type $MergeContentDefinition<T, U> = {\n    [K in keyof T | keyof U as Extract<(K extends keyof T ? T[K] : never) | (K extends keyof U ? U[K] : never), ContentBlock> extends never ? never : K]: K extends keyof T ? K extends keyof U ? $MergeDiscriminatedUnion<Extract<T[K], ContentBlock>, Extract<U[K], ContentBlock>, \"type\"> : Extract<T[K], ContentBlock> : K extends keyof U ? Extract<U[K], ContentBlock> : never;\n};\n/**\n * Merges two message structures A and B into a combined structure.\n * This is a type utility that handles merging of tools, content blocks, and properties\n * from two message structures. The resulting type is usable as its own message structure.\n *\n * @example\n * ```ts\n * // Structure A allows text in human messages and has a confidence property on AI messages\n * interface StructureA extends MessageStructure {\n *   content: {\n *     human: ContentBlock.Text;\n *   };\n *   properties: {\n *     ai: { confidence: number };\n *   }\n * }\n *\n * // Structure B allows images in human messages and has a model property on AI messages\n * interface StructureB extends MessageStructure {\n *   content: {\n *     human: ContentBlock.Multimodal.Image;\n *   };\n *   properties: {\n *     ai: { model: string };\n *   }\n * }\n *\n * // Merged structure allows both text and images in human messages\n * // AI messages have both confidence and model properties\n * type Merged = $MergeMessageStructure<StructureA, StructureB>;\n * ```\n *\n * @template A - First message structure to merge\n * @template B - Second message structure to merge (takes precedence over A)\n */\nexport type $MergeMessageStructure<T extends MessageStructure, U extends MessageStructure> = {\n    outputVersion: $MergeOutputVersion<T[\"outputVersion\"], U[\"outputVersion\"]>;\n    tools: $MergeObjects<T[\"tools\"], U[\"tools\"]>;\n    content: $MergeContentDefinition<T[\"content\"], U[\"content\"]>;\n    properties: $MergeObjects<T[\"properties\"], U[\"properties\"]>;\n};\n/**\n * Standard message structured used to define the most basic message structure that's\n * used throughout the library.\n *\n * This is also the message structure that's used when a message structure is not provided.\n */\nexport interface StandardMessageStructure extends MessageStructure {\n    content: {\n        /** Text content for AI messages */\n        ai: ContentBlock.Text;\n        /** Text content for human messages */\n        human: ContentBlock.Text;\n        /** Text content for system messages */\n        system: ContentBlock.Text;\n        /** Text content for tool messages */\n        tool: ContentBlock.Text;\n    };\n    properties: {\n        /** Properties specific to AI messages */\n        ai: {\n            /** Metadata about the AI model response */\n            response_metadata: ResponseMetadata;\n            /** Usage statistics for the AI response */\n            usage_metadata: UsageMetadata;\n        };\n        human: {\n            /** Metadata about the human message */\n            response_metadata: Record<string, unknown>;\n        };\n        system: {\n            /** Metadata about the system message */\n            response_metadata: Record<string, unknown>;\n        };\n        tool: {\n            /** Metadata about the tool message */\n            response_metadata: Record<string, unknown>;\n        };\n    };\n}\n/**\n * Takes a message structure type T and normalizes it by merging it with the standard message structure.\n * If T is already a standard message structure, returns T unchanged.\n *\n * This ensures that any custom message structure includes all the standard message structure fields\n * by default while allowing overrides and extensions.\n *\n * @template T - The message structure type to normalize, must extend MessageStructure\n * @returns Either T if it's already a standard structure, or the merged result of T with standard structure\n */\nexport type $NormalizedMessageStructure<T extends MessageStructure> = T extends StandardMessageStructure ? T : $MergeMessageStructure<StandardMessageStructure, T>;\n/**\n * Infers the content blocks for a specific message type in a message structure.\n *\n * This utility type extracts the content block type that corresponds to a given message type\n * from the message structure's content definition.\n *\n * @template TStructure - The message structure to infer content from\n * @template TRole - The message role/type to get content for (e.g., \"ai\", \"human\", \"system\", \"tool\")\n * @returns The content block type for the specified type, or never if its not defined in the structure\n *\n * @example\n * ```ts\n * interface MyStructure extends MessageStructure {\n *   content: {\n *     human: ContentBlock.Text;\n *     ai: ContentBlock.Text | ContentBlock.ToolCall;\n *   };\n * }\n *\n * type HumanContent = $InferMessageContentBlocks<MyStructure, \"human\">;\n * // HumanContent = ContentBlock.Text\n *\n * type AIContent = $InferMessageContentBlocks<MyStructure, \"ai\">;\n * // AIContent = ContentBlock.Text | ContentBlock.ToolCall\n * ```\n */\nexport type $InferMessageContentBlocks<TStructure extends MessageStructure, TRole extends MessageType> = $NormalizedMessageStructure<TStructure> extends infer S ? S extends MessageStructure ? S[\"content\"] extends infer C ? C extends Record<PropertyKey, ContentBlock> ? TRole extends keyof C ? [$MessageToolCallBlock<TStructure>] extends [never] ? C[TRole] : $MergeDiscriminatedUnion<NonNullable<C[TRole]>, $MessageToolCallBlock<TStructure>, \"type\"> : never : never : never : never : never;\n/**\n * Infers the content type for a specific message type from a message structure.\n *\n * This utility type determines the appropriate content type based on the message structure's\n * output version and the specified message type. The content type varies depending on the\n * output version (see {@link MessageOutputVersion})\n *\n * @template TStructure - The message structure to infer content from\n * @template TRole - The message role/type to get content for (e.g., \"ai\", \"human\", \"system\", \"tool\")\n * @returns The content type for the specified role based on the output version\n *\n * @example\n * ```ts\n * interface MyStructure extends MessageStructure {\n *   outputVersion: \"v0\";\n *   content: {\n *     human: ContentBlock.Text;\n *     ai: ContentBlock.Text | ContentBlock.ToolCall;\n *   };\n * }\n *\n * type HumanContentV0 = $InferMessageContent<MyStructure, \"human\">;\n * // HumanContentV0 = string | Array<ContentBlock | ContentBlock.Text>\n *\n * interface MyStructureV1 extends MessageStructure {\n *   outputVersion: \"v1\";\n *   content: {\n *     human: ContentBlock.Text;\n *     ai: ContentBlock.Text | ContentBlock.Reasoning;\n *   };\n * }\n *\n * type HumanContentV1 = $InferMessageContent<MyStructureV1, \"human\">;\n * // HumanContentV1 = ContentBlock.Text\n *\n * type AIContentV1 = $InferMessageContent<MyStructureV1, \"ai\">;\n * // AIContentV1 = ContentBlock.Text | ContentBlock.Reasoning\n * ```\n */\nexport type $InferMessageContent<TStructure extends MessageStructure, TRole extends MessageType> = TStructure[\"outputVersion\"] extends \"v1\" ? Array<$InferMessageContentBlocks<TStructure, TRole>> : string | Array<ContentBlock | ContentBlock.Text>;\n/**\n * Infers the properties for a specific message type from a message structure.\n *\n * This utility type extracts the properties object that corresponds to a given message type\n * from the message structure's properties definition, and excludes the reserved\n * \"content\" and \"type\" properties to avoid conflicts with the core message structure.\n *\n * If the specified type is not defined in the message structure's properties, it returns\n * a generic Record<string, unknown> type to allow for arbitrary properties.\n *\n * @template TStructure - The message structure to infer properties from\n * @template TRole - The message type/role to get properties for (e.g., \"ai\", \"human\", \"system\", \"tool\")\n * @returns The properties object type for the specified type, excluding \"content\" and \"type\"\n *\n * @example\n * ```ts\n * interface MyStructure extends MessageStructure {\n *   properties: {\n *     ai: {\n *       response_metadata: { model: string };\n *       usage_metadata: { tokens: number };\n *       content: string; // This will be omitted\n *       type: string;    // This will be omitted\n *     };\n *     human: { metadata: Record<string, unknown> };\n *   };\n * }\n *\n * type AIProperties = $InferMessageProperties<MyStructure, \"ai\">;\n * // AIProperties = { response_metadata: { model: string }; usage_metadata: { tokens: number } }\n *\n * type HumanProperties = $InferMessageProperties<MyStructure, \"human\">;\n * // HumanProperties = { metadata: Record<string, unknown> }\n *\n * type SystemProperties = $InferMessageProperties<MyStructure, \"system\">;\n * // SystemProperties = Record<string, unknown> (fallback for undefined role)\n * ```\n */\nexport type $InferMessageProperties<TStructure extends MessageStructure, TRole extends MessageType> = $NormalizedMessageStructure<TStructure> extends infer S ? S extends MessageStructure ? S[\"properties\"] extends infer P | undefined ? P extends Record<PropertyKey, unknown> ? TRole extends keyof P ? Omit<P[TRole], \"content\" | \"type\"> : Record<string, unknown> : Record<string, unknown> : Record<string, unknown> : never : never;\n/**\n * Infers the type of a specific property for a message type from a message structure.\n *\n * This utility type extracts the type of a single property by name from the properties\n * object that corresponds to a given message type. If the specified property key does\n * not exist in the type's properties, it returns `never`.\n *\n * @template TStructure - The message structure to infer the property from\n * @template TRole - The message type/role to get the property for (e.g., \"ai\", \"human\", \"system\", \"tool\")\n * @template K - The property key to extract the type for\n * @returns The type of the specified property, or `never` if the property doesn't exist\n *\n * @example\n * ```ts\n * interface MyStructure extends MessageStructure {\n *   properties: {\n *     ai: {\n *       response_metadata: { model: string; temperature: number };\n *       usage_metadata: { input_tokens: number; output_tokens: number };\n *     };\n *     human: { metadata: Record<string, unknown> };\n *   };\n * }\n *\n * type ResponseMetadata = $InferMessageProperty<MyStructure, \"ai\", \"response_metadata\">;\n * // ResponseMetadata = { model: string; temperature: number }\n *\n * type UsageMetadata = $InferMessageProperty<MyStructure, \"ai\", \"usage_metadata\">;\n * // UsageMetadata = { input_tokens: number; output_tokens: number }\n *\n * type NonExistentProperty = $InferMessageProperty<MyStructure, \"ai\", \"nonExistent\">;\n * // NonExistentProperty = Record<string, unknown>\n *\n * type HumanMetadata = $InferMessageProperty<MyStructure, \"human\", \"metadata\">;\n * // HumanMetadata = Record<string, unknown>\n * ```\n */\nexport type $InferMessageProperty<TStructure extends MessageStructure, TRole extends MessageType, K extends string> = K extends keyof $InferMessageProperties<TStructure, TRole> ? $InferMessageProperties<TStructure, TRole>[K] : never;\n/**\n * Infers the response metadata type for a specific message type from a message structure.\n *\n * This utility type extracts the `response_metadata` property type for a given message type.\n *\n * @template TStructure - The message structure to infer the response metadata from\n * @template TRole - The message type/role to get the response metadata for (e.g., \"ai\", \"human\", \"system\", \"tool\")\n * @returns The type of the response_metadata property, or `Record<string, unknown>` as fallback\n *\n * @example\n * ```ts\n * interface MyStructure extends MessageStructure {\n *   properties: {\n *     ai: {\n *       response_metadata: { model: string; temperature: number; tokens: number };\n *     };\n *     human: { metadata: Record<string, unknown> };\n *   };\n * }\n *\n * type AIResponseMetadata = $InferResponseMetadata<MyStructure, \"ai\">;\n * // AIResponseMetadata = { model: string; temperature: number; tokens: number }\n *\n * type HumanResponseMetadata = $InferResponseMetadata<MyStructure, \"human\">;\n * // HumanResponseMetadata = Record<string, unknown> (fallback since not defined)\n * ```\n */\nexport type $InferResponseMetadata<TStructure extends MessageStructure, TRole extends MessageType> = $InferMessageProperty<TStructure, TRole, \"response_metadata\"> extends infer P ? [P] extends [never] ? Record<string, unknown> : P : never;\n/**\n * Represents a message object that organizes context for an LLM.\n *\n * @example\n * ```ts\n * // Basic message with text content\n * const message: Message = {\n *   id: \"msg-123\",\n *   name: \"user\",\n *   type: \"human\",\n *   content: [{ type: \"text\", text: \"Hello!\" }]\n * };\n *\n * // Basic ai message interface extension\n * interface MyMessage extends Message<StandardMessageStructure, \"ai\"> {\n *   // Additional AI-specific properties can be added here\n * }\n *`\n * // Custom message structure\n * interface CustomStructure extends MessageStructure {\n *   content: {\n *     ai: ContentBlock.Text | ContentBlock.ToolCall<\"search\", { query: string }>;\n *     human: ContentBlock.Text | ContentBlock.Multimodal.Image;\n *   };\n * }\n *\n * // Create a message with custom structure\n * const message: Message<CustomStructure> = {\n *   id: \"msg-123\",\n *   name: \"user\",\n *   type: \"ai\",\n *   content: [\n *     { type: \"text\", text: \"Hello!\" },\n *     {\n *       type: \"tool_call\",\n *       name: \"search\",\n *       args: { query: \"What is the capital of France?\" }\n *     }\n *   ]\n * };\n * ```\n */\nexport interface Message<TStructure extends MessageStructure = StandardMessageStructure, TRole extends MessageType = MessageType> {\n    /** The message type/role */\n    readonly type: TRole;\n    /** Unique identifier for this message */\n    id?: string;\n    /** Optional name/identifier for the entity that created this message */\n    name?: string;\n    /** Array of content blocks that make up the message content */\n    content: $InferMessageContent<TStructure, TRole>;\n    /** Metadata about the message */\n    response_metadata?: Partial<$InferResponseMetadata<TStructure, TRole>>;\n}\n/**\n * Type guard to check if a value is a valid Message object.\n *\n * @param message - The value to check\n * @returns true if the value is a valid Message object, false otherwise\n */\nexport declare function isMessage(message: unknown): message is Message;\nexport {};\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"message.d.ts","names":["ContentBlock","ResponseMetadata","UsageMetadata","$MergeDiscriminatedUnion","$MergeObjects","MessageType","NonNullable","MessageOutputVersion","MessageToolDefinition","TInput","TOutput","MessageToolSet","$MessageToolCallBlock","MessageStructure","TStructure","K","Tools","ToolCall","Partial","Record","$NormalizeMessageOutputVersion","T","Extract","$MergeOutputVersion","U","TV","UV","Exclude","$MergeContentDefinition","$MergeMessageStructure","StandardMessageStructure","Text","$NormalizedMessageStructure","$InferMessageContentBlocks","S","C","PropertyKey","TRole","$InferMessageContent","Array","$InferMessageProperties","P","Omit","$InferMessageProperty","$InferResponseMetadata","Message","isMessage"],"sources":["../../src/messages/message.d.ts"],"sourcesContent":["import type { ContentBlock } from \"./content/index.js\";\nimport type { ResponseMetadata, UsageMetadata } from \"./metadata.js\";\nimport type { $MergeDiscriminatedUnion, $MergeObjects } from \"./utils.js\";\n/**\n * Represents the possible types of messages in the system.\n * Includes standard message types (\"ai\", \"human\", \"tool\", \"system\")\n * and allows for custom string types that are non-null.\n *\n * @example\n * ```ts\n * // Standard message types\n * const messageType1: MessageType = \"ai\";\n * const messageType2: MessageType = \"human\";\n *\n * // Custom message type\n * const messageType3: MessageType = \"custom_type\";\n * ```\n */\nexport type MessageType = \"ai\" | \"human\" | \"tool\" | \"system\" | (string & NonNullable<unknown>);\n/**\n * Represents the output version format for message content.\n *\n * This type determines how the content field is structured in a message:\n * - \"v0\": Content is represented as a simple string or array of content blocks\n *   - provides backward compatibility with simpler content representations\n * - \"v1\": Content follows the structured ContentBlock format with typed discriminated unions\n *   - enables full type safety and structured content block handling\n *\n * @example\n * ```ts\n * // v0 format - simple content representation\n * const v0Message: Message<{ outputVersion: \"v0\", content: ... }> = {\n *   type: \"human\",\n *   content: \"Hello world\" // string | Array<ContentBlock | ContentBlock.Text>\n * };\n *\n * // v1 format - structured content blocks\n * const v1Message: Message<{ outputVersion: \"v1\", content: ... }> = {\n *   type: \"human\",\n *   content: [\n *     { type: \"text\", text: \"Hello world\" },\n *     { type: \"image\", image_url: \"...\" }\n *   ] // Array<ContentBlock | ...> (determined by the structure)\n * };\n * ```\n */\nexport type MessageOutputVersion = \"v0\" | \"v1\";\n/**\n * Represents the input and output types of a tool that can be used in messages.\n *\n * @template TInput - The type of input the tool accepts.\n * @template TOutput - The type of output the tool produces.\n *\n * @example\n * ```ts\n * // Tool that takes a string input and returns a number\n * interface StringToNumberTool extends MessageToolDefinition<string, number> {\n *   input: string;\n *   output: number;\n * }\n * ```\n */\nexport interface MessageToolDefinition<TInput = unknown, TOutput = unknown> {\n    input: TInput;\n    output: TOutput;\n}\n/**\n * Represents a structured set of tools by mapping tool names to definitions\n * that can be used in messages.\n *\n * @example\n * ```ts\n * interface MyToolSet extends MessageToolSet {\n *   calculator: MessageToolDefinition<\n *     { operation: string; numbers: number[] },\n *     number\n *   >;\n *   translator: MessageToolDefinition<\n *     { text: string; targetLanguage: string },\n *     string\n *   >;\n * }\n * ```\n */\nexport interface MessageToolSet {\n    [key: string]: MessageToolDefinition;\n}\n/**\n * Represents a tool call block within a message structure by mapping tool names to their\n * corresponding tool call formats, including the input arguments and an optional identifier.\n *\n * @template TStructure - A message structure type that may contain tool definitions\n *\n * @example\n * ```ts\n * // Given a message structure with a calculator tool:\n * interface MyStructure extends MessageStructure {\n *   tools: {\n *     calculator: MessageToolDefinition<{ operation: string, numbers: number[] }, number>\n *   }\n * }\n *\n * // The tool call block would be:\n * type CalcToolCall = $MessageToolCallBlock<MyStructure>;\n * // Resolves to:\n * // {\n * //   type: \"tool_call\";\n * //   name: \"calculator\";\n * //   args: { operation: string, numbers: number[] };\n * //   id?: string;\n * // }\n * ```\n */\nexport type $MessageToolCallBlock<TStructure extends MessageStructure> = TStructure[\"tools\"] extends MessageToolSet ? {\n    [K in keyof TStructure[\"tools\"]]: K extends string ? TStructure[\"tools\"][K] extends MessageToolDefinition ? ContentBlock.Tools.ToolCall<K, TStructure[\"tools\"][K][\"input\"]> : never : never;\n}[keyof TStructure[\"tools\"]] : never;\n/**\n * Core interface that defines the structure of messages.\n *\n * @example\n * ```ts\n * // Basic message structure with just content blocks\n * interface SimpleMessageStructure extends MessageStructure {\n *   content: {\n *     human: ContentBlock.Text;\n *     // allows for text + reasoning blocks in ai messages\n *     ai: ContentBlock.Text | ContentBlock.Reasoning;\n *   }\n * }\n *\n * // Message structure with tools and properties\n * interface AdvancedMessageStructure extends MessageStructure {\n *   tools: {\n *     calculator: MessageToolDefinition<\n *       { operation: string; numbers: number[] },\n *       number\n *     >;\n *   };\n *   content: {\n *     // allows for text + image blocks in human messages\n *     human: ContentBlock.Text | ContentBlock.Multimodal.Image;\n *     // only allows for text blocks in ai messages\n *     ai: ContentBlock.Text;\n *   };\n *   properties: {\n *     // pins properties to ai messages\n *     ai: {\n *       response_metadata: {\n *         confidence: number;\n *         model: string;\n *       };\n *     };\n *   }\n * }\n *\n * // Using with $MergeMessageStructure to combine structures\n * // The resulting type when passed into BaseMessage will have a calculator tool,\n * // allow for text + image blocks in human messages,\n * // and text + reasoning blocks + additional arbitrary properties in ai messages.\n * type CombinedStructure = $MergeMessageStructure<\n *   SimpleMessageStructure,\n *   AdvancedMessageStructure\n * >;\n *\n * // Using in a Message object\n * const message: Message<CombinedStructure> = {\n *   id: \"msg-123\",\n *   type: \"human\",\n *   content: [\n *     { type: \"text\", text: \"Hello!\" }\n *     { type: \"image\", mimeType: \"image/jpeg\", url: \"https://example.com/image.jpg\" }\n *     // this block will throw an error because it's not defined in the structure\n *     { type: \"reasoning\", reasoning: \"The answer is 42\" }\n *   ]\n * };\n * ```\n */\nexport interface MessageStructure {\n    /**\n     * Optional output version for the message structure.\n     * If not provided, defaults to \"v0\".\n     */\n    readonly outputVersion?: MessageOutputVersion;\n    /**\n     * Optional set of tool definitions that can be used in messages.\n     * Each tool is defined with input/output types and can be referenced in tool messages.\n     */\n    readonly tools?: MessageToolSet;\n    /**\n     * Optional mapping of message types to their allowed content blocks.\n     * Each message type can specify what content block types it supports (text, images, etc).\n     */\n    readonly content?: Partial<{\n        [key in MessageType]: ContentBlock;\n    }>;\n    /**\n     * Optional mapping of message types to arbitrary property objects.\n     * Allows attaching custom metadata or other information to specific message types.\n     */\n    readonly properties?: Partial<{\n        [key in MessageType]: Record<string, unknown>;\n    }>;\n}\n/**\n * Normalizes an arbitrary type to a message output version or undefined.\n * Accepts unknown and narrows to a valid MessageOutputVersion if present.\n */\ntype $NormalizeMessageOutputVersion<T> = Extract<T, MessageOutputVersion> | undefined;\n/**\n * Merges two output version types from message structures.\n *\n * This utility type determines the resulting output version when combining two message structures.\n * The merge logic follows these rules:\n *\n * - If both T and U are undefined, defaults to \"v0\" for backwards compatibility\n * - If T is undefined but U is defined, uses U's version\n * - If U is undefined but T is defined, uses T's version\n * - If both T and U are defined, U takes precedence (later structure wins)\n *\n * @template T - The output version from the first message structure\n * @template U - The output version from the second message structure\n *\n * @example\n * ```ts\n * // Both undefined - defaults to \"v0\"\n * type Result1 = $MergeOutputVersion<undefined, undefined>; // \"v0\"\n *\n * // One defined - uses the defined version\n * type Result2 = $MergeOutputVersion<undefined, \"v1\">; // \"v1\"\n * type Result3 = $MergeOutputVersion<\"v0\", undefined>; // \"v0\"\n *\n * // Both defined - second takes precedence\n * type Result4 = $MergeOutputVersion<\"v0\", \"v1\">; // \"v1\"\n * ```\n */\nexport type $MergeOutputVersion<T, U> = $NormalizeMessageOutputVersion<T> extends infer TV ? $NormalizeMessageOutputVersion<U> extends infer UV ? [TV, UV] extends [undefined, undefined] ? \"v0\" : [TV] extends [undefined] ? Exclude<UV, undefined> : [UV] extends [undefined] ? Exclude<TV, undefined> : UV : never : never;\n/**\n * Merges two content definition objects from message structures.\n *\n * This utility type combines content definitions from two message structures, handling\n * the merging of content block types for each message type. The merge logic follows\n * these rules:\n *\n * - For keys that exist in both T and U: Merges the content blocks using discriminated\n *   union merging based on the \"type\" property. This allows combining different content\n *   block types (e.g., text + image) for the same message type.\n * - For keys that exist only in T: Uses T's content definition as-is\n * - For keys that exist only in U: Uses U's content definition as-is\n *\n * @template T - The content definition from the first message structure\n * @template U - The content definition from the second message structure\n *\n * @example\n * ```ts\n * // T allows text content for human messages\n * type ContentA = {\n *   human: ContentBlock.Text;\n * };\n *\n * // U allows image content for human messages and text for AI messages\n * type ContentB = {\n *   human: ContentBlock.Multimodal.Image;\n *   ai: ContentBlock.Text;\n * };\n *\n * // Merged result allows both text and images for human messages, text for AI\n * type Merged = $MergeContentDefinition<ContentA, ContentB>;\n * // Result: {\n * //   human: ContentBlock.Text | ContentBlock.Multimodal.Image;\n * //   ai: ContentBlock.Text;\n * // }\n * ```\n */\nexport type $MergeContentDefinition<T, U> = {\n    [K in keyof T | keyof U as Extract<(K extends keyof T ? T[K] : never) | (K extends keyof U ? U[K] : never), ContentBlock> extends never ? never : K]: K extends keyof T ? K extends keyof U ? $MergeDiscriminatedUnion<Extract<T[K], ContentBlock>, Extract<U[K], ContentBlock>, \"type\"> : Extract<T[K], ContentBlock> : K extends keyof U ? Extract<U[K], ContentBlock> : never;\n};\n/**\n * Merges two message structures A and B into a combined structure.\n * This is a type utility that handles merging of tools, content blocks, and properties\n * from two message structures. The resulting type is usable as its own message structure.\n *\n * @example\n * ```ts\n * // Structure A allows text in human messages and has a confidence property on AI messages\n * interface StructureA extends MessageStructure {\n *   content: {\n *     human: ContentBlock.Text;\n *   };\n *   properties: {\n *     ai: { confidence: number };\n *   }\n * }\n *\n * // Structure B allows images in human messages and has a model property on AI messages\n * interface StructureB extends MessageStructure {\n *   content: {\n *     human: ContentBlock.Multimodal.Image;\n *   };\n *   properties: {\n *     ai: { model: string };\n *   }\n * }\n *\n * // Merged structure allows both text and images in human messages\n * // AI messages have both confidence and model properties\n * type Merged = $MergeMessageStructure<StructureA, StructureB>;\n * ```\n *\n * @template A - First message structure to merge\n * @template B - Second message structure to merge (takes precedence over A)\n */\nexport type $MergeMessageStructure<T extends MessageStructure, U extends MessageStructure> = {\n    outputVersion: $MergeOutputVersion<T[\"outputVersion\"], U[\"outputVersion\"]>;\n    tools: $MergeObjects<T[\"tools\"], U[\"tools\"]>;\n    content: $MergeContentDefinition<T[\"content\"], U[\"content\"]>;\n    properties: $MergeObjects<T[\"properties\"], U[\"properties\"]>;\n};\n/**\n * Standard message structured used to define the most basic message structure that's\n * used throughout the library.\n *\n * This is also the message structure that's used when a message structure is not provided.\n */\nexport interface StandardMessageStructure extends MessageStructure {\n    content: {\n        /** Text content for AI messages */\n        ai: ContentBlock.Text;\n        /** Text content for human messages */\n        human: ContentBlock.Text;\n        /** Text content for system messages */\n        system: ContentBlock.Text;\n        /** Text content for tool messages */\n        tool: ContentBlock.Text;\n    };\n    properties: {\n        /** Properties specific to AI messages */\n        ai: {\n            /** Metadata about the AI model response */\n            response_metadata: ResponseMetadata;\n            /** Usage statistics for the AI response */\n            usage_metadata: UsageMetadata;\n        };\n        human: {\n            /** Metadata about the human message */\n            response_metadata: Record<string, unknown>;\n        };\n        system: {\n            /** Metadata about the system message */\n            response_metadata: Record<string, unknown>;\n        };\n        tool: {\n            /** Metadata about the tool message */\n            response_metadata: Record<string, unknown>;\n        };\n    };\n}\n/**\n * Takes a message structure type T and normalizes it by merging it with the standard message structure.\n * If T is already a standard message structure, returns T unchanged.\n *\n * This ensures that any custom message structure includes all the standard message structure fields\n * by default while allowing overrides and extensions.\n *\n * @template T - The message structure type to normalize, must extend MessageStructure\n * @returns Either T if it's already a standard structure, or the merged result of T with standard structure\n */\nexport type $NormalizedMessageStructure<T extends MessageStructure> = T extends StandardMessageStructure ? T : $MergeMessageStructure<StandardMessageStructure, T>;\n/**\n * Infers the content blocks for a specific message type in a message structure.\n *\n * This utility type extracts the content block type that corresponds to a given message type\n * from the message structure's content definition.\n *\n * @template TStructure - The message structure to infer content from\n * @template TRole - The message role/type to get content for (e.g., \"ai\", \"human\", \"system\", \"tool\")\n * @returns The content block type for the specified type, or never if its not defined in the structure\n *\n * @example\n * ```ts\n * interface MyStructure extends MessageStructure {\n *   content: {\n *     human: ContentBlock.Text;\n *     ai: ContentBlock.Text | ContentBlock.ToolCall;\n *   };\n * }\n *\n * type HumanContent = $InferMessageContentBlocks<MyStructure, \"human\">;\n * // HumanContent = ContentBlock.Text\n *\n * type AIContent = $InferMessageContentBlocks<MyStructure, \"ai\">;\n * // AIContent = ContentBlock.Text | ContentBlock.ToolCall\n * ```\n */\nexport type $InferMessageContentBlocks<TStructure extends MessageStructure, TRole extends MessageType> = $NormalizedMessageStructure<TStructure> extends infer S ? S extends MessageStructure ? S[\"content\"] extends infer C ? C extends Record<PropertyKey, ContentBlock> ? TRole extends keyof C ? [$MessageToolCallBlock<TStructure>] extends [never] ? C[TRole] : $MergeDiscriminatedUnion<NonNullable<C[TRole]>, $MessageToolCallBlock<TStructure>, \"type\"> : never : never : never : never : never;\n/**\n * Infers the content type for a specific message type from a message structure.\n *\n * This utility type determines the appropriate content type based on the message structure's\n * output version and the specified message type. The content type varies depending on the\n * output version (see {@link MessageOutputVersion})\n *\n * @template TStructure - The message structure to infer content from\n * @template TRole - The message role/type to get content for (e.g., \"ai\", \"human\", \"system\", \"tool\")\n * @returns The content type for the specified role based on the output version\n *\n * @example\n * ```ts\n * interface MyStructure extends MessageStructure {\n *   outputVersion: \"v0\";\n *   content: {\n *     human: ContentBlock.Text;\n *     ai: ContentBlock.Text | ContentBlock.ToolCall;\n *   };\n * }\n *\n * type HumanContentV0 = $InferMessageContent<MyStructure, \"human\">;\n * // HumanContentV0 = string | Array<ContentBlock | ContentBlock.Text>\n *\n * interface MyStructureV1 extends MessageStructure {\n *   outputVersion: \"v1\";\n *   content: {\n *     human: ContentBlock.Text;\n *     ai: ContentBlock.Text | ContentBlock.Reasoning;\n *   };\n * }\n *\n * type HumanContentV1 = $InferMessageContent<MyStructureV1, \"human\">;\n * // HumanContentV1 = ContentBlock.Text\n *\n * type AIContentV1 = $InferMessageContent<MyStructureV1, \"ai\">;\n * // AIContentV1 = ContentBlock.Text | ContentBlock.Reasoning\n * ```\n */\nexport type $InferMessageContent<TStructure extends MessageStructure, TRole extends MessageType> = TStructure[\"outputVersion\"] extends \"v1\" ? Array<$InferMessageContentBlocks<TStructure, TRole>> : string | Array<ContentBlock | ContentBlock.Text>;\n/**\n * Infers the properties for a specific message type from a message structure.\n *\n * This utility type extracts the properties object that corresponds to a given message type\n * from the message structure's properties definition, and excludes the reserved\n * \"content\" and \"type\" properties to avoid conflicts with the core message structure.\n *\n * If the specified type is not defined in the message structure's properties, it returns\n * a generic Record<string, unknown> type to allow for arbitrary properties.\n *\n * @template TStructure - The message structure to infer properties from\n * @template TRole - The message type/role to get properties for (e.g., \"ai\", \"human\", \"system\", \"tool\")\n * @returns The properties object type for the specified type, excluding \"content\" and \"type\"\n *\n * @example\n * ```ts\n * interface MyStructure extends MessageStructure {\n *   properties: {\n *     ai: {\n *       response_metadata: { model: string };\n *       usage_metadata: { tokens: number };\n *       content: string; // This will be omitted\n *       type: string;    // This will be omitted\n *     };\n *     human: { metadata: Record<string, unknown> };\n *   };\n * }\n *\n * type AIProperties = $InferMessageProperties<MyStructure, \"ai\">;\n * // AIProperties = { response_metadata: { model: string }; usage_metadata: { tokens: number } }\n *\n * type HumanProperties = $InferMessageProperties<MyStructure, \"human\">;\n * // HumanProperties = { metadata: Record<string, unknown> }\n *\n * type SystemProperties = $InferMessageProperties<MyStructure, \"system\">;\n * // SystemProperties = Record<string, unknown> (fallback for undefined role)\n * ```\n */\nexport type $InferMessageProperties<TStructure extends MessageStructure, TRole extends MessageType> = $NormalizedMessageStructure<TStructure> extends infer S ? S extends MessageStructure ? S[\"properties\"] extends infer P | undefined ? P extends Record<PropertyKey, unknown> ? TRole extends keyof P ? Omit<P[TRole], \"content\" | \"type\"> : Record<string, unknown> : Record<string, unknown> : Record<string, unknown> : never : never;\n/**\n * Infers the type of a specific property for a message type from a message structure.\n *\n * This utility type extracts the type of a single property by name from the properties\n * object that corresponds to a given message type. If the specified property key does\n * not exist in the type's properties, it returns `never`.\n *\n * @template TStructure - The message structure to infer the property from\n * @template TRole - The message type/role to get the property for (e.g., \"ai\", \"human\", \"system\", \"tool\")\n * @template K - The property key to extract the type for\n * @returns The type of the specified property, or `never` if the property doesn't exist\n *\n * @example\n * ```ts\n * interface MyStructure extends MessageStructure {\n *   properties: {\n *     ai: {\n *       response_metadata: { model: string; temperature: number };\n *       usage_metadata: { input_tokens: number; output_tokens: number };\n *     };\n *     human: { metadata: Record<string, unknown> };\n *   };\n * }\n *\n * type ResponseMetadata = $InferMessageProperty<MyStructure, \"ai\", \"response_metadata\">;\n * // ResponseMetadata = { model: string; temperature: number }\n *\n * type UsageMetadata = $InferMessageProperty<MyStructure, \"ai\", \"usage_metadata\">;\n * // UsageMetadata = { input_tokens: number; output_tokens: number }\n *\n * type NonExistentProperty = $InferMessageProperty<MyStructure, \"ai\", \"nonExistent\">;\n * // NonExistentProperty = Record<string, unknown>\n *\n * type HumanMetadata = $InferMessageProperty<MyStructure, \"human\", \"metadata\">;\n * // HumanMetadata = Record<string, unknown>\n * ```\n */\nexport type $InferMessageProperty<TStructure extends MessageStructure, TRole extends MessageType, K extends string> = K extends keyof $InferMessageProperties<TStructure, TRole> ? $InferMessageProperties<TStructure, TRole>[K] : never;\n/**\n * Infers the response metadata type for a specific message type from a message structure.\n *\n * This utility type extracts the `response_metadata` property type for a given message type.\n *\n * @template TStructure - The message structure to infer the response metadata from\n * @template TRole - The message type/role to get the response metadata for (e.g., \"ai\", \"human\", \"system\", \"tool\")\n * @returns The type of the response_metadata property, or `Record<string, unknown>` as fallback\n *\n * @example\n * ```ts\n * interface MyStructure extends MessageStructure {\n *   properties: {\n *     ai: {\n *       response_metadata: { model: string; temperature: number; tokens: number };\n *     };\n *     human: { metadata: Record<string, unknown> };\n *   };\n * }\n *\n * type AIResponseMetadata = $InferResponseMetadata<MyStructure, \"ai\">;\n * // AIResponseMetadata = { model: string; temperature: number; tokens: number }\n *\n * type HumanResponseMetadata = $InferResponseMetadata<MyStructure, \"human\">;\n * // HumanResponseMetadata = Record<string, unknown> (fallback since not defined)\n * ```\n */\nexport type $InferResponseMetadata<TStructure extends MessageStructure, TRole extends MessageType> = $InferMessageProperty<TStructure, TRole, \"response_metadata\"> extends infer P ? [P] extends [never] ? Record<string, unknown> : P : never;\n/**\n * Represents a message object that organizes context for an LLM.\n *\n * @example\n * ```ts\n * // Basic message with text content\n * const message: Message = {\n *   id: \"msg-123\",\n *   name: \"user\",\n *   type: \"human\",\n *   content: [{ type: \"text\", text: \"Hello!\" }]\n * };\n *\n * // Basic ai message interface extension\n * interface MyMessage extends Message<StandardMessageStructure, \"ai\"> {\n *   // Additional AI-specific properties can be added here\n * }\n *`\n * // Custom message structure\n * interface CustomStructure extends MessageStructure {\n *   content: {\n *     ai: ContentBlock.Text | ContentBlock.ToolCall<\"search\", { query: string }>;\n *     human: ContentBlock.Text | ContentBlock.Multimodal.Image;\n *   };\n * }\n *\n * // Create a message with custom structure\n * const message: Message<CustomStructure> = {\n *   id: \"msg-123\",\n *   name: \"user\",\n *   type: \"ai\",\n *   content: [\n *     { type: \"text\", text: \"Hello!\" },\n *     {\n *       type: \"tool_call\",\n *       name: \"search\",\n *       args: { query: \"What is the capital of France?\" }\n *     }\n *   ]\n * };\n * ```\n */\nexport interface Message<TStructure extends MessageStructure = StandardMessageStructure, TRole extends MessageType = MessageType> {\n    /** The message type/role */\n    readonly type: TRole;\n    /** Unique identifier for this message */\n    id?: string;\n    /** Optional name/identifier for the entity that created this message */\n    name?: string;\n    /** Array of content blocks that make up the message content */\n    content: $InferMessageContent<TStructure, TRole>;\n    /** Metadata about the message */\n    response_metadata?: Partial<$InferResponseMetadata<TStructure, TRole>>;\n}\n/**\n * Type guard to check if a value is a valid Message object.\n *\n * @param message - The value to check\n * @returns true if the value is a valid Message object, false otherwise\n */\nexport declare function isMessage(message: unknown): message is Message;\nexport {};\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"metadata.d.cts","names":["MessageOutputVersion","ResponseMetadata","mergeResponseMetadata","ModalitiesTokenDetails","InputTokenDetails","OutputTokenDetails","UsageMetadata","mergeUsageMetadata"],"sources":["../../src/messages/metadata.d.ts"],"sourcesContent":["import type { MessageOutputVersion } from \"./message.js\";\nexport type ResponseMetadata = {\n    model_provider?: string;\n    model_name?: string;\n    output_version?: MessageOutputVersion;\n    [key: string]: unknown;\n};\nexport declare function mergeResponseMetadata(a?: ResponseMetadata, b?: ResponseMetadata): ResponseMetadata;\nexport type ModalitiesTokenDetails = {\n    /**\n     * Text tokens.\n     * Does not need to be reported, but some models will do so.\n     */\n    text?: number;\n    /**\n     * Image (non-video) tokens.\n     */\n    image?: number;\n    /**\n     * Audio tokens.\n     */\n    audio?: number;\n    /**\n     * Video tokens.\n     */\n    video?: number;\n    /**\n     * Document tokens.\n     * e.g. PDF\n     */\n    document?: number;\n};\n/**\n * Breakdown of input token counts.\n *\n * Does not *need* to sum to full input token count. Does *not* need to have all keys.\n */\nexport type InputTokenDetails = ModalitiesTokenDetails & {\n    /**\n     * Input tokens that were cached and there was a cache hit.\n     *\n     * Since there was a cache hit, the tokens were read from the cache.\n     * More precisely, the model state given these tokens was read from the cache.\n     */\n    cache_read?: number;\n    /**\n     * Input tokens that were cached and there was a cache miss.\n     *\n     * Since there was a cache miss, the cache was created from these tokens.\n     */\n    cache_creation?: number;\n};\n/**\n * Breakdown of output token counts.\n *\n * Does *not* need to sum to full output token count. Does *not* need to have all keys.\n */\nexport type OutputTokenDetails = ModalitiesTokenDetails & {\n    /**\n     * Reasoning output tokens.\n     *\n     * Tokens generated by the model in a chain of thought process (i.e. by\n     * OpenAI's o1 models) that are not returned as part of model output.\n     */\n    reasoning?: number;\n};\n/**\n * Usage metadata for a message, such as token counts.\n */\nexport type UsageMetadata = {\n    /**\n     * Count of input (or prompt) tokens. Sum of all input token types.\n     */\n    input_tokens: number;\n    /**\n     * Count of output (or completion) tokens. Sum of all output token types.\n     */\n    output_tokens: number;\n    /**\n     * Total token count. Sum of input_tokens + output_tokens.\n     */\n    total_tokens: number;\n    /**\n     * Breakdown of input token counts.\n     *\n     * Does *not* need to sum to full input token count. Does *not* need to have all keys.\n     */\n    input_token_details?: InputTokenDetails;\n    /**\n     * Breakdown of output token counts.\n     *\n     * Does *not* need to sum to full output token count. Does *not* need to have all keys.\n     */\n    output_token_details?: OutputTokenDetails;\n};\nexport declare function mergeUsageMetadata(a?: UsageMetadata, b?: UsageMetadata): UsageMetadata;\n"],"mappings":";;;KACYC,gBAAAA;;EAAAA,UAAAA,CAAAA,EAAAA,MAAgB;EAMJC,cAAAA,CAAAA,EAHHF,oBAGwB;EAAA,CAAA,GAAA,EAAA,MAAA,CAAA,EAAA,OAAA;CAAA;AAA2BC,iBAAhDC,qBAAAA,CAAgDD,CAAAA,CAAAA,EAAtBA,gBAAsBA,EAAAA,CAAAA,CAAAA,EAAAA,gBAAAA,CAAAA,EAAmBA,gBAAnBA;AAAmBA,KAC/EE,sBAAAA,GAD+EF;EAAgB;AAC3G;AA6BA;AAoBA;EAYYK,IAAAA,CAAAA,EAAAA,MAAAA;EAAa;;;EAwBoB,KAAA,CAAA,EAAA,MAAA;EAErBC;;;EAAoC,KAAMD,CAAAA,EAAAA,MAAAA;EAAa;AAAgB;;;;;;;;;;;;;;KA1DnFF,iBAAAA,GAAoBD;;;;;;;;;;;;;;;;;;;;KAoBpBE,kBAAAA,GAAqBF;;;;;;;;;;;;KAYrBG,aAAAA;;;;;;;;;;;;;;;;;;wBAkBcF;;;;;;yBAMCC;;iBAEHE,kBAAAA,KAAuBD,mBAAmBA,gBAAgBA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"metadata.d.ts","names":["MessageOutputVersion","ResponseMetadata","mergeResponseMetadata","ModalitiesTokenDetails","InputTokenDetails","OutputTokenDetails","UsageMetadata","mergeUsageMetadata"],"sources":["../../src/messages/metadata.d.ts"],"sourcesContent":["import type { MessageOutputVersion } from \"./message.js\";\nexport type ResponseMetadata = {\n    model_provider?: string;\n    model_name?: string;\n    output_version?: MessageOutputVersion;\n    [key: string]: unknown;\n};\nexport declare function mergeResponseMetadata(a?: ResponseMetadata, b?: ResponseMetadata): ResponseMetadata;\nexport type ModalitiesTokenDetails = {\n    /**\n     * Text tokens.\n     * Does not need to be reported, but some models will do so.\n     */\n    text?: number;\n    /**\n     * Image (non-video) tokens.\n     */\n    image?: number;\n    /**\n     * Audio tokens.\n     */\n    audio?: number;\n    /**\n     * Video tokens.\n     */\n    video?: number;\n    /**\n     * Document tokens.\n     * e.g. PDF\n     */\n    document?: number;\n};\n/**\n * Breakdown of input token counts.\n *\n * Does not *need* to sum to full input token count. Does *not* need to have all keys.\n */\nexport type InputTokenDetails = ModalitiesTokenDetails & {\n    /**\n     * Input tokens that were cached and there was a cache hit.\n     *\n     * Since there was a cache hit, the tokens were read from the cache.\n     * More precisely, the model state given these tokens was read from the cache.\n     */\n    cache_read?: number;\n    /**\n     * Input tokens that were cached and there was a cache miss.\n     *\n     * Since there was a cache miss, the cache was created from these tokens.\n     */\n    cache_creation?: number;\n};\n/**\n * Breakdown of output token counts.\n *\n * Does *not* need to sum to full output token count. Does *not* need to have all keys.\n */\nexport type OutputTokenDetails = ModalitiesTokenDetails & {\n    /**\n     * Reasoning output tokens.\n     *\n     * Tokens generated by the model in a chain of thought process (i.e. by\n     * OpenAI's o1 models) that are not returned as part of model output.\n     */\n    reasoning?: number;\n};\n/**\n * Usage metadata for a message, such as token counts.\n */\nexport type UsageMetadata = {\n    /**\n     * Count of input (or prompt) tokens. Sum of all input token types.\n     */\n    input_tokens: number;\n    /**\n     * Count of output (or completion) tokens. Sum of all output token types.\n     */\n    output_tokens: number;\n    /**\n     * Total token count. Sum of input_tokens + output_tokens.\n     */\n    total_tokens: number;\n    /**\n     * Breakdown of input token counts.\n     *\n     * Does *not* need to sum to full input token count. Does *not* need to have all keys.\n     */\n    input_token_details?: InputTokenDetails;\n    /**\n     * Breakdown of output token counts.\n     *\n     * Does *not* need to sum to full output token count. Does *not* need to have all keys.\n     */\n    output_token_details?: OutputTokenDetails;\n};\nexport declare function mergeUsageMetadata(a?: UsageMetadata, b?: UsageMetadata): UsageMetadata;\n"],"mappings":";;;KACYC,gBAAAA;;EAAAA,UAAAA,CAAAA,EAAAA,MAAgB;EAMJC,cAAAA,CAAAA,EAHHF,oBAGwB;EAAA,CAAA,GAAA,EAAA,MAAA,CAAA,EAAA,OAAA;CAAA;AAA2BC,iBAAhDC,qBAAAA,CAAgDD,CAAAA,CAAAA,EAAtBA,gBAAsBA,EAAAA,CAAAA,CAAAA,EAAAA,gBAAAA,CAAAA,EAAmBA,gBAAnBA;AAAmBA,KAC/EE,sBAAAA,GAD+EF;EAAgB;AAC3G;AA6BA;AAoBA;EAYYK,IAAAA,CAAAA,EAAAA,MAAAA;EAAa;;;EAwBoB,KAAA,CAAA,EAAA,MAAA;EAErBC;;;EAAoC,KAAMD,CAAAA,EAAAA,MAAAA;EAAa;AAAgB;;;;;;;;;;;;;;KA1DnFF,iBAAAA,GAAoBD;;;;;;;;;;;;;;;;;;;;KAoBpBE,kBAAAA,GAAqBF;;;;;;;;;;;;KAYrBG,aAAAA;;;;;;;;;;;;;;;;;;wBAkBcF;;;;;;yBAMCC;;iBAEHE,kBAAAA,KAAuBD,mBAAmBA,gBAAgBA"}