@langchain/core 1.1.4 → 1.1.5-dev-1765432861398

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

@@ -0,0 +1 @@
+{"version":3,"file":"message.d.cts","names":["ContentBlock","ResponseMetadata","UsageMetadata","$MergeDiscriminatedUnion","$MergeObjects","MessageType","NonNullable","MessageOutputVersion","MessageToolDefinition","TInput","TOutput","MessageToolSet","$MessageToolCallBlock","TStructure","MessageStructure","K","Tools","ToolCall","Partial","Record","$NormalizeMessageOutputVersion","T","Extract","$MergeOutputVersion","U","TV","UV","Exclude","$MergeContentDefinition","$MergeMessageStructure","StandardMessageStructure","Text","$NormalizedMessageStructure","$InferMessageContentBlocks","TRole","S","C","PropertyKey","$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//# sourceMappingURL=message.d.ts.map"],"mappings":"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"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"message.d.ts","names":["ContentBlock","ResponseMetadata","UsageMetadata","$MergeDiscriminatedUnion","$MergeObjects","MessageType","NonNullable","MessageOutputVersion","MessageToolDefinition","TInput","TOutput","MessageToolSet","$MessageToolCallBlock","TStructure","MessageStructure","K","Tools","ToolCall","Partial","Record","$NormalizeMessageOutputVersion","T","Extract","$MergeOutputVersion","U","TV","UV","Exclude","$MergeContentDefinition","$MergeMessageStructure","StandardMessageStructure","Text","$NormalizedMessageStructure","$InferMessageContentBlocks","TRole","S","C","PropertyKey","$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//# sourceMappingURL=message.d.ts.map"],"mappings":"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"}

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

@@ -0,0 +1 @@
+{"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//# sourceMappingURL=metadata.d.ts.map"],"mappings":";;;KACYC,gBAAAA;;EAAAA,UAAAA,CAAAA,EAAAA,MAAgB;EAMJC,cAAAA,CAAAA,EAHHF,oBAGwB;EAAKC,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EAAAA,OAAAA;CAAsBA;AAAmBA,iBAAnEC,qBAAAA,CAAmED,CAAAA,CAAAA,EAAzCA,gBAAyCA,EAAAA,CAAAA,CAAAA,EAAnBA,gBAAmBA,CAAAA,EAAAA,gBAAAA;AAAgB,KAC/FE,sBAAAA,GAD+F;EAC/FA;AA6BZ;AAoBA;AAYA;EA0BwBI,IAAAA,CAAAA,EAAAA,MAAAA;EAAuBD;;;EAAgD,KAAA,CAAA,EAAA,MAAA;;;;;;;;;;;;;;;;;;;;KA1DnFF,iBAAAA,GAAoBD;;;;;;;;;;;;;;;;;;;;KAoBpBE,kBAAAA,GAAqBF;;;;;;;;;;;;KAYrBG,aAAAA;;;;;;;;;;;;;;;;;;wBAkBcF;;;;;;yBAMCC;;iBAEHE,kBAAAA,KAAuBD,mBAAmBA,gBAAgBA"}

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

@@ -0,0 +1 @@
+{"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//# sourceMappingURL=metadata.d.ts.map"],"mappings":";;;KACYC,gBAAAA;;EAAAA,UAAAA,CAAAA,EAAAA,MAAgB;EAMJC,cAAAA,CAAAA,EAHHF,oBAGwB;EAAKC,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EAAAA,OAAAA;CAAsBA;AAAmBA,iBAAnEC,qBAAAA,CAAmED,CAAAA,CAAAA,EAAzCA,gBAAyCA,EAAAA,CAAAA,CAAAA,EAAnBA,gBAAmBA,CAAAA,EAAAA,gBAAAA;AAAgB,KAC/FE,sBAAAA,GAD+F;EAC/FA;AA6BZ;AAoBA;AAYA;EA0BwBI,IAAAA,CAAAA,EAAAA,MAAAA;EAAuBD;;;EAAgD,KAAA,CAAA,EAAA,MAAA;;;;;;;;;;;;;;;;;;;;KA1DnFF,iBAAAA,GAAoBD;;;;;;;;;;;;;;;;;;;;KAoBpBE,kBAAAA,GAAqBF;;;;;;;;;;;;KAYrBG,aAAAA;;;;;;;;;;;;;;;;;;wBAkBcF;;;;;;yBAMCC;;iBAEHE,kBAAAA,KAAuBD,mBAAmBA,gBAAgBA"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"modifier.d.cts","names":["BaseMessage","BaseMessageFields","MessageStructure","RemoveMessageFields","TStructure","Omit","RemoveMessage","Record"],"sources":["../../src/messages/modifier.d.ts"],"sourcesContent":["import { BaseMessage, BaseMessageFields } from \"./base.js\";\nimport { MessageStructure } from \"./message.js\";\nexport interface RemoveMessageFields<TStructure extends MessageStructure = MessageStructure> extends Omit<BaseMessageFields<TStructure, \"remove\">, \"content\"> {\n    /**\n     * The ID of the message to remove.\n     */\n    id: string;\n}\n/**\n * Message responsible for deleting other messages.\n */\nexport declare class RemoveMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, \"remove\"> {\n    readonly type: \"remove\";\n    /**\n     * The ID of the message to remove.\n     */\n    id: string;\n    constructor(fields: RemoveMessageFields<TStructure>);\n    get _printableFields(): Record<string, unknown>;\n    static isInstance(obj: unknown): obj is RemoveMessage;\n}\n//# sourceMappingURL=modifier.d.ts.map"],"mappings":";;;;UAEiBG,uCAAuCD,mBAAmBA,0BAA0BG,KAAKJ,kBAAkBG;;AAA5H;;EAA2EF,EAAAA,EAAAA,MAAAA;;;;AAA8B;AASpFI,cAAAA,aAAaF,CAAAA,mBAAoBF,gBAApB,GAAuCA,gBAAvC,CAAA,SAAiEF,WAAjE,CAA6EI,UAA7E,EAAA,QAAA,CAAA,CAAA;EAAoBF,SAAAA,IAAAA,EAAAA,QAAAA;EAAmBA;;;EAMjDC,EAAAA,EAAAA,MAAAA;EACII,WAAAA,CAAAA,MAAAA,EADJJ,mBACII,CADgBH,UAChBG,CAAAA;EACgBD,IAAAA,gBAAAA,CAAAA,CAAAA,EADhBC,MACgBD,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;EARuDN,OAAAA,UAAAA,CAAAA,GAAAA,EAAAA,OAAAA,CAAAA,EAAAA,GAAAA,IAQvDM,aARuDN;AAAW"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"modifier.d.ts","names":["BaseMessage","BaseMessageFields","MessageStructure","RemoveMessageFields","TStructure","Omit","RemoveMessage","Record"],"sources":["../../src/messages/modifier.d.ts"],"sourcesContent":["import { BaseMessage, BaseMessageFields } from \"./base.js\";\nimport { MessageStructure } from \"./message.js\";\nexport interface RemoveMessageFields<TStructure extends MessageStructure = MessageStructure> extends Omit<BaseMessageFields<TStructure, \"remove\">, \"content\"> {\n    /**\n     * The ID of the message to remove.\n     */\n    id: string;\n}\n/**\n * Message responsible for deleting other messages.\n */\nexport declare class RemoveMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, \"remove\"> {\n    readonly type: \"remove\";\n    /**\n     * The ID of the message to remove.\n     */\n    id: string;\n    constructor(fields: RemoveMessageFields<TStructure>);\n    get _printableFields(): Record<string, unknown>;\n    static isInstance(obj: unknown): obj is RemoveMessage;\n}\n//# sourceMappingURL=modifier.d.ts.map"],"mappings":";;;;UAEiBG,uCAAuCD,mBAAmBA,0BAA0BG,KAAKJ,kBAAkBG;;AAA5H;;EAA2EF,EAAAA,EAAAA,MAAAA;;;;AAA8B;AASpFI,cAAAA,aAAaF,CAAAA,mBAAoBF,gBAApB,GAAuCA,gBAAvC,CAAA,SAAiEF,WAAjE,CAA6EI,UAA7E,EAAA,QAAA,CAAA,CAAA;EAAoBF,SAAAA,IAAAA,EAAAA,QAAAA;EAAmBA;;;EAMjDC,EAAAA,EAAAA,MAAAA;EACII,WAAAA,CAAAA,MAAAA,EADJJ,mBACII,CADgBH,UAChBG,CAAAA;EACgBD,IAAAA,gBAAAA,CAAAA,CAAAA,EADhBC,MACgBD,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;EARuDN,OAAAA,UAAAA,CAAAA,GAAAA,EAAAA,OAAAA,CAAAA,EAAAA,GAAAA,IAQvDM,aARuDN;AAAW"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"system.d.cts","names":["BaseMessage","BaseMessageChunk","BaseMessageFields","$InferMessageContent","MessageStructure","SystemMessageFields","TStructure","SystemMessage","SystemMessageChunk","isSystemMessage","isSystemMessageChunk"],"sources":["../../src/messages/system.d.ts"],"sourcesContent":["import { BaseMessage, BaseMessageChunk, type BaseMessageFields } from \"./base.js\";\nimport { $InferMessageContent, MessageStructure } from \"./message.js\";\nexport interface SystemMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, \"system\"> {\n}\n/**\n * Represents a system message in a conversation.\n */\nexport declare class SystemMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, \"system\"> {\n    static lc_name(): string;\n    readonly type: \"system\";\n    constructor(fields: $InferMessageContent<TStructure, \"system\"> | SystemMessageFields<TStructure>);\n    /**\n     * Concatenates a string or another system message with the current system message.\n     * @param chunk - The chunk to concatenate with the system message.\n     * @returns A new system message with the concatenated content.\n     */\n    concat(chunk: string | SystemMessage): SystemMessage<TStructure>;\n    static isInstance(obj: unknown): obj is SystemMessage;\n}\n/**\n * Represents a chunk of a system message, which can be concatenated with\n * other system message chunks.\n */\nexport declare class SystemMessageChunk<TStructure extends MessageStructure = MessageStructure> extends BaseMessageChunk<TStructure, \"system\"> {\n    static lc_name(): string;\n    readonly type: \"system\";\n    constructor(fields: $InferMessageContent<TStructure, \"system\"> | SystemMessageFields<TStructure>);\n    concat(chunk: SystemMessageChunk<TStructure>): this;\n    static isInstance(obj: unknown): obj is SystemMessageChunk;\n}\n/**\n * @deprecated Use {@link SystemMessage.isInstance} instead\n */\nexport declare function isSystemMessage<TStructure extends MessageStructure>(x: BaseMessage): x is SystemMessage<TStructure>;\n/**\n * @deprecated Use {@link SystemMessageChunk.isInstance} instead\n */\nexport declare function isSystemMessageChunk<TStructure extends MessageStructure>(x: BaseMessageChunk): x is SystemMessageChunk<TStructure>;\n//# sourceMappingURL=system.d.ts.map"],"mappings":";;;;UAEiBK,uCAAuCD,mBAAmBA,0BAA0BF,kBAAkBI;AAAvH;;;AAAuHA,cAKlGC,aALkGD,CAAAA,mBAKjEF,gBALiEE,GAK9CF,gBAL8CE,CAAAA,SAKpBN,WALoBM,CAKRA,UALQA,EAAAA,QAAAA,CAAAA,CAAAA;EAAlBJ,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAiB,SAAA,IAAA,EAAA,QAAA;EAKjGK,WAAAA,CAAAA,MAAa,EAGVJ,oBAHU,CAGWG,UAHX,EAAA,QAAA,CAAA,GAGmCD,mBAHnC,CAGuDC,UAHvD,CAAA;EAAoBF;;;;;EAGmCE,MAAAA,CAAAA,KAAAA,EAAAA,MAAAA,GAM9DC,aAN8DD,CAAAA,EAM9CC,aAN8CD,CAMhCA,UANgCA,CAAAA;EAApBD,OAAAA,UAAAA,CAAAA,GAAAA,EAAAA,OAAAA,CAAAA,EAAAA,GAAAA,IAOzBE,aAPyBF;;;;;;AAHyC,cAgBzFG,kBAhByF,CAAA,mBAgBnDJ,gBAhBmD,GAgBhCA,gBAhBgC,CAAA,SAgBNH,gBAhBM,CAgBWK,UAhBX,EAAA,QAAA,CAAA,CAAA;EAgBzFE,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAkB;EAAoBJ,SAAAA,IAAAA,EAAAA,QAAAA;EAAmBA,WAAAA,CAAAA,MAAAA,EAGtDD,oBAHsDC,CAGjCE,UAHiCF,EAAAA,QAAAA,CAAAA,GAGTC,mBAHSD,CAGWE,UAHXF,CAAAA;EAA2CE,MAAAA,CAAAA,KAAAA,EAIvGE,kBAJuGF,CAIpFA,UAJoFA,CAAAA,CAAAA,EAAAA,IAAAA;EAG5EA,OAAAA,UAAAA,CAAAA,GAAAA,EAAAA,OAAAA,CAAAA,EAAAA,GAAAA,IAEDE,kBAFCF;;;;;AAC3BE,iBAMMC,eANND,CAAAA,mBAMyCJ,gBANzCI,CAAAA,CAAAA,CAAAA,EAM8DR,WAN9DQ,CAAAA,EAAAA,CAAAA,IAMiFD,aANjFC,CAM+FF,UAN/FE,CAAAA;;;AAJsG;AAUhGC,iBAIAC,oBAJe,CAAA,mBAIyBN,gBAJzB,CAAA,CAAA,CAAA,EAI8CH,gBAJ9C,CAAA,EAAA,CAAA,IAIsEO,kBAJtE,CAIyFF,UAJzF,CAAA"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"system.d.ts","names":["BaseMessage","BaseMessageChunk","BaseMessageFields","$InferMessageContent","MessageStructure","SystemMessageFields","TStructure","SystemMessage","SystemMessageChunk","isSystemMessage","isSystemMessageChunk"],"sources":["../../src/messages/system.d.ts"],"sourcesContent":["import { BaseMessage, BaseMessageChunk, type BaseMessageFields } from \"./base.js\";\nimport { $InferMessageContent, MessageStructure } from \"./message.js\";\nexport interface SystemMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, \"system\"> {\n}\n/**\n * Represents a system message in a conversation.\n */\nexport declare class SystemMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, \"system\"> {\n    static lc_name(): string;\n    readonly type: \"system\";\n    constructor(fields: $InferMessageContent<TStructure, \"system\"> | SystemMessageFields<TStructure>);\n    /**\n     * Concatenates a string or another system message with the current system message.\n     * @param chunk - The chunk to concatenate with the system message.\n     * @returns A new system message with the concatenated content.\n     */\n    concat(chunk: string | SystemMessage): SystemMessage<TStructure>;\n    static isInstance(obj: unknown): obj is SystemMessage;\n}\n/**\n * Represents a chunk of a system message, which can be concatenated with\n * other system message chunks.\n */\nexport declare class SystemMessageChunk<TStructure extends MessageStructure = MessageStructure> extends BaseMessageChunk<TStructure, \"system\"> {\n    static lc_name(): string;\n    readonly type: \"system\";\n    constructor(fields: $InferMessageContent<TStructure, \"system\"> | SystemMessageFields<TStructure>);\n    concat(chunk: SystemMessageChunk<TStructure>): this;\n    static isInstance(obj: unknown): obj is SystemMessageChunk;\n}\n/**\n * @deprecated Use {@link SystemMessage.isInstance} instead\n */\nexport declare function isSystemMessage<TStructure extends MessageStructure>(x: BaseMessage): x is SystemMessage<TStructure>;\n/**\n * @deprecated Use {@link SystemMessageChunk.isInstance} instead\n */\nexport declare function isSystemMessageChunk<TStructure extends MessageStructure>(x: BaseMessageChunk): x is SystemMessageChunk<TStructure>;\n//# sourceMappingURL=system.d.ts.map"],"mappings":";;;;UAEiBK,uCAAuCD,mBAAmBA,0BAA0BF,kBAAkBI;AAAvH;;;AAAuHA,cAKlGC,aALkGD,CAAAA,mBAKjEF,gBALiEE,GAK9CF,gBAL8CE,CAAAA,SAKpBN,WALoBM,CAKRA,UALQA,EAAAA,QAAAA,CAAAA,CAAAA;EAAlBJ,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAiB,SAAA,IAAA,EAAA,QAAA;EAKjGK,WAAAA,CAAAA,MAAa,EAGVJ,oBAHU,CAGWG,UAHX,EAAA,QAAA,CAAA,GAGmCD,mBAHnC,CAGuDC,UAHvD,CAAA;EAAoBF;;;;;EAGmCE,MAAAA,CAAAA,KAAAA,EAAAA,MAAAA,GAM9DC,aAN8DD,CAAAA,EAM9CC,aAN8CD,CAMhCA,UANgCA,CAAAA;EAApBD,OAAAA,UAAAA,CAAAA,GAAAA,EAAAA,OAAAA,CAAAA,EAAAA,GAAAA,IAOzBE,aAPyBF;;;;;;AAHyC,cAgBzFG,kBAhByF,CAAA,mBAgBnDJ,gBAhBmD,GAgBhCA,gBAhBgC,CAAA,SAgBNH,gBAhBM,CAgBWK,UAhBX,EAAA,QAAA,CAAA,CAAA;EAgBzFE,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAkB;EAAoBJ,SAAAA,IAAAA,EAAAA,QAAAA;EAAmBA,WAAAA,CAAAA,MAAAA,EAGtDD,oBAHsDC,CAGjCE,UAHiCF,EAAAA,QAAAA,CAAAA,GAGTC,mBAHSD,CAGWE,UAHXF,CAAAA;EAA2CE,MAAAA,CAAAA,KAAAA,EAIvGE,kBAJuGF,CAIpFA,UAJoFA,CAAAA,CAAAA,EAAAA,IAAAA;EAG5EA,OAAAA,UAAAA,CAAAA,GAAAA,EAAAA,OAAAA,CAAAA,EAAAA,GAAAA,IAEDE,kBAFCF;;;;;AAC3BE,iBAMMC,eANND,CAAAA,mBAMyCJ,gBANzCI,CAAAA,CAAAA,CAAAA,EAM8DR,WAN9DQ,CAAAA,EAAAA,CAAAA,IAMiFD,aANjFC,CAM+FF,UAN/FE,CAAAA;;;AAJsG;AAUhGC,iBAIAC,oBAJe,CAAA,mBAIyBN,gBAJzB,CAAA,CAAA,CAAA,EAI8CH,gBAJ9C,CAAA,EAAA,CAAA,IAIsEO,kBAJtE,CAIyFF,UAJzF,CAAA"}

package/dist/messages/tool.d.cts

@@ -10,7 +10,6 @@ interface ToolMessageFields<TStructure extends MessageStructure = MessageStructu
    * a subset of the full tool output is being passed as message content but the full
    * output is needed in other parts of the code.
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   artifact?: any;
   tool_call_id: string;
   status?: "success" | "error";
@@ -49,7 +48,6 @@ declare class ToolMessage<TStructure extends MessageStructure = MessageStructure
    * a subset of the full tool output is being passed as message content but the full
    * output is needed in other parts of the code.
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   artifact?: any;
   constructor(fields: $InferMessageContent<TStructure, "tool"> | ToolMessageFields, tool_call_id: string, name?: string);
   constructor(fields: ToolMessageFields<TStructure>);
@@ -75,16 +73,13 @@ declare class ToolMessageChunk<TStructure extends MessageStructure = MessageStru
    * a subset of the full tool output is being passed as message content but the full
    * output is needed in other parts of the code.
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   artifact?: any;
   constructor(fields: ToolMessageFields<TStructure>);
   static lc_name(): string;
   concat(chunk: ToolMessageChunk<TStructure>): this;
   get _printableFields(): Record<string, unknown>;
 }
-interface ToolCall<TName extends string = string,
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-TArgs extends Record<string, any> = Record<string, any>> {
+interface ToolCall<TName extends string = string, TArgs extends Record<string, any> = Record<string, any>> {
   readonly type?: "tool_call";
   /**
    * If provided, an identifier associated with the tool call
@@ -187,9 +182,7 @@ interface InvalidToolCall<TName extends string = string> {
    */
   index?: string | number;
 }
-declare function defaultToolCallParser(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-rawToolCalls: Record<string, any>[]): [ToolCall[], InvalidToolCall[]];
+declare function defaultToolCallParser(rawToolCalls: Record<string, any>[]): [ToolCall[], InvalidToolCall[]];
 /**
  * @deprecated Use {@link ToolMessage.isInstance} instead
  */

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.cts","names":["BaseMessage","BaseMessageChunk","BaseMessageFields","$InferMessageContent","MessageStructure","ToolMessageFields","TStructure","Record","DirectToolOutput","isDirectToolOutput","ToolMessage","ToolMessageChunk","ToolCall","TName","TArgs","ToolCallChunk","InvalidToolCall","defaultToolCallParser","isToolMessage","isToolMessageChunk"],"sources":["../../src/messages/tool.d.ts"],"sourcesContent":["import { BaseMessage, BaseMessageChunk, type BaseMessageFields } from \"./base.js\";\nimport { $InferMessageContent, MessageStructure } from \"./message.js\";\nexport interface ToolMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, \"tool\"> {\n    /**\n     * Artifact of the Tool execution which is not meant to be sent to the model.\n     *\n     * Should only be specified if it is different from the message content, e.g. if only\n     * a subset of the full tool output is being passed as message content but the full\n     * output is needed in other parts of the code.\n     */\n    artifact?: any;\n    tool_call_id: string;\n    status?: \"success\" | \"error\";\n    metadata?: Record<string, unknown>;\n}\n/**\n * Marker parameter for objects that tools can return directly.\n *\n * If a custom BaseTool is invoked with a ToolCall and the output of custom code is\n * not an instance of DirectToolOutput, the output will automatically be coerced to\n * a string and wrapped in a ToolMessage.\n */\nexport interface DirectToolOutput {\n    readonly lc_direct_tool_output: true;\n}\nexport declare function isDirectToolOutput(x: unknown): x is DirectToolOutput;\n/**\n * Represents a tool message in a conversation.\n */\nexport declare class ToolMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, \"tool\"> implements DirectToolOutput {\n    static lc_name(): string;\n    get lc_aliases(): Record<string, string>;\n    lc_direct_tool_output: true;\n    readonly type: \"tool\";\n    /**\n     * Status of the tool invocation.\n     * @version 0.2.19\n     */\n    status?: \"success\" | \"error\";\n    tool_call_id: string;\n    metadata?: Record<string, unknown>;\n    /**\n     * Artifact of the Tool execution which is not meant to be sent to the model.\n     *\n     * Should only be specified if it is different from the message content, e.g. if only\n     * a subset of the full tool output is being passed as message content but the full\n     * output is needed in other parts of the code.\n     */\n    artifact?: any;\n    constructor(fields: $InferMessageContent<TStructure, \"tool\"> | ToolMessageFields, tool_call_id: string, name?: string);\n    constructor(fields: ToolMessageFields<TStructure>);\n    static isInstance(message: unknown): message is ToolMessage;\n    get _printableFields(): Record<string, unknown>;\n}\n/**\n * Represents a chunk of a tool message, which can be concatenated\n * with other tool message chunks.\n */\nexport declare class ToolMessageChunk<TStructure extends MessageStructure = MessageStructure> extends BaseMessageChunk<TStructure, \"tool\"> {\n    readonly type: \"tool\";\n    tool_call_id: string;\n    /**\n     * Status of the tool invocation.\n     * @version 0.2.19\n     */\n    status?: \"success\" | \"error\";\n    /**\n     * Artifact of the Tool execution which is not meant to be sent to the model.\n     *\n     * Should only be specified if it is different from the message content, e.g. if only\n     * a subset of the full tool output is being passed as message content but the full\n     * output is needed in other parts of the code.\n     */\n    artifact?: any;\n    constructor(fields: ToolMessageFields<TStructure>);\n    static lc_name(): string;\n    concat(chunk: ToolMessageChunk<TStructure>): this;\n    get _printableFields(): Record<string, unknown>;\n}\nexport interface ToolCall<TName extends string = string, TArgs extends Record<string, any> = Record<string, any>> {\n    readonly type?: \"tool_call\";\n    /**\n     * If provided, an identifier associated with the tool call\n     */\n    id?: string;\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/**\n * A chunk of a tool call (e.g., as part of a stream).\n * When merging ToolCallChunks (e.g., via AIMessageChunk.__add__),\n * all string attributes are concatenated. Chunks are only merged if their\n * values of `index` are equal and not None.\n *\n * @example\n * ```ts\n * const leftChunks = [\n *   {\n *     name: \"foo\",\n *     args: '{\"a\":',\n *     index: 0\n *   }\n * ];\n *\n * const leftAIMessageChunk = new AIMessageChunk({\n *   content: \"\",\n *   tool_call_chunks: leftChunks\n * });\n *\n * const rightChunks = [\n *   {\n *     name: undefined,\n *     args: '1}',\n *     index: 0\n *   }\n * ];\n *\n * const rightAIMessageChunk = new AIMessageChunk({\n *   content: \"\",\n *   tool_call_chunks: rightChunks\n * });\n *\n * const result = leftAIMessageChunk.concat(rightAIMessageChunk);\n * // result.tool_call_chunks is equal to:\n * // [\n * //   {\n * //     name: \"foo\",\n * //     args: '{\"a\":1}'\n * //     index: 0\n * //   }\n * // ]\n * ```\n */\nexport interface ToolCallChunk<TName extends string = string> {\n    readonly type?: \"tool_call_chunk\";\n    /**\n     * If provided, a substring of an identifier for the tool call\n     */\n    id?: string;\n    /**\n     * If provided, a substring of the name of the tool to be called\n     */\n    name?: TName;\n    /**\n     * If provided, a JSON substring of the arguments to the tool call\n     */\n    args?: string;\n    /**\n     * If provided, the index of the tool call in a sequence\n     */\n    index?: number;\n}\nexport interface InvalidToolCall<TName extends string = string> {\n    readonly type?: \"invalid_tool_call\";\n    /**\n     * If provided, an identifier associated with the tool call\n     */\n    id?: string;\n    /**\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}\nexport declare function defaultToolCallParser(rawToolCalls: Record<string, any>[]): [ToolCall[], InvalidToolCall[]];\n/**\n * @deprecated Use {@link ToolMessage.isInstance} instead\n */\nexport declare function isToolMessage(x: unknown): x is ToolMessage;\n/**\n * @deprecated Use {@link ToolMessageChunk.isInstance} instead\n */\nexport declare function isToolMessageChunk(x: BaseMessageChunk): x is ToolMessageChunk;\n//# sourceMappingURL=tool.d.ts.map"],"mappings":";;;;UAEiBK,qCAAqCD,mBAAmBA,0BAA0BF,kBAAkBI;;AAArH;;;;;;EAAoH,QAAA,CAAA,EAAA,GAAA;EAoBnGE,YAAAA,EAAAA,MAAgB;EAGTC,MAAAA,CAAAA,EAAAA,SAAAA,GAAkB,OAAA;EAIrBC,QAAAA,CAAAA,EAhBNH,MAgBiB,CAAA,MAAAD,EAAAA,OAAAA,CAAAA;;;;;;;;;AAqBUA,UA5BzBE,gBAAAA,CA4ByBF;EAAlBD,SAAAA,qBAAAA,EAAAA,IAAAA;;AAEIE,iBA3BJE,kBAAAA,CA2BIF,CAAAA,EAAAA,OAAAA,CAAAA,EAAAA,CAAAA,IA3BiCC,gBA2BjCD;;;AAvBgI;AA6BvII,cA7BAD,WA6BgBJ,CAAAA,mBA7BeF,gBA6Bf,GA7BkCA,gBA6BlC,CAAA,SA7B4DJ,WA6B5D,CA7BwEM,UA6BxE,EAAA,MAAA,CAAA,YA7BuGE,gBA6BvG,CAAA;EAAoBJ,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAmBA,IAAAA,UAAAA,CAAAA,CAAAA,EA3BtDG,MA2BsDH,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAA2CE,qBAAAA,EAAAA,IAAAA;EAgB7EA,SAAAA,IAAAA,EAAAA,MAAAA;EAAlBD;;;;EAhB8EJ,MAAAA,CAAAA,EAAAA,SAAAA,GAAAA,OAAAA;EAAgB,YAAA,EAAA,MAAA;EAqBrGW,QAAAA,CAAAA,EAvCFL,MAuCU,CAAAM,MAAAA,EAAAC,OAAAA,CAAAA;EAA8CP;;;;AAaxD;AA+Cf;AAmBA;EAwBwBU,QAAAA,CAAAA,EAAAA,GAAAA;EAAoCV,WAAAA,CAAAA,MAAAA,EArIpCJ,oBAqIoCI,CArIfD,UAqIeC,EAAAA,MAAAA,CAAAA,GArIOF,iBAqIPE,EAAAA,YAAAA,EAAAA,MAAAA,EAAAA,IAAAA,CAAAA,EAAAA,MAAAA;EAAyBK,WAAAA,CAAAA,MAAAA,EApI7DP,iBAoI6DO,CApI3CN,UAoI2CM,CAAAA;EAAYI,OAAAA,UAAAA,CAAAA,OAAAA,EAAAA,OAAAA,CAAAA,EAAAA,OAAAA,IAnI7CN,WAmI6CM;EAAe,IAAA,gBAAA,CAAA,CAAA,EAlIpFT,MAkIoF,CAAA,MAAA,EAAA,OAAA,CAAA;AAIhH;AAIA;;;;cApIqBI,oCAAoCP,mBAAmBA,0BAA0BH,iBAAiBK;;;;;;;;;;;;;;;;sBAgB/FD,kBAAkBC;;gBAExBK,iBAAiBL;0BACPC;;UAEXK,sDAAsDL,sBAAsBA;;;;;;;;;QASnFM;;;;QAIAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA+COC;;;;;;;;;SASNF;;;;;;;;;;UAUMG;;;;;;;;;;SAUNH;;;;;;;;;;;;;;iBAcaI,qBAAAA,eAAoCV,yBAAyBK,YAAYI;;;;iBAIzEE,aAAAA,mBAAgCR;;;;iBAIhCS,kBAAAA,IAAsBlB,wBAAwBU"}

package/dist/messages/tool.d.ts

@@ -10,7 +10,6 @@ interface ToolMessageFields<TStructure extends MessageStructure = MessageStructu
    * a subset of the full tool output is being passed as message content but the full
    * output is needed in other parts of the code.
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   artifact?: any;
   tool_call_id: string;
   status?: "success" | "error";
@@ -49,7 +48,6 @@ declare class ToolMessage<TStructure extends MessageStructure = MessageStructure
    * a subset of the full tool output is being passed as message content but the full
    * output is needed in other parts of the code.
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   artifact?: any;
   constructor(fields: $InferMessageContent<TStructure, "tool"> | ToolMessageFields, tool_call_id: string, name?: string);
   constructor(fields: ToolMessageFields<TStructure>);
@@ -75,16 +73,13 @@ declare class ToolMessageChunk<TStructure extends MessageStructure = MessageStru
    * a subset of the full tool output is being passed as message content but the full
    * output is needed in other parts of the code.
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   artifact?: any;
   constructor(fields: ToolMessageFields<TStructure>);
   static lc_name(): string;
   concat(chunk: ToolMessageChunk<TStructure>): this;
   get _printableFields(): Record<string, unknown>;
 }
-interface ToolCall<TName extends string = string,
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-TArgs extends Record<string, any> = Record<string, any>> {
+interface ToolCall<TName extends string = string, TArgs extends Record<string, any> = Record<string, any>> {
   readonly type?: "tool_call";
   /**
    * If provided, an identifier associated with the tool call
@@ -187,9 +182,7 @@ interface InvalidToolCall<TName extends string = string> {
    */
   index?: string | number;
 }
-declare function defaultToolCallParser(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-rawToolCalls: Record<string, any>[]): [ToolCall[], InvalidToolCall[]];
+declare function defaultToolCallParser(rawToolCalls: Record<string, any>[]): [ToolCall[], InvalidToolCall[]];
 /**
  * @deprecated Use {@link ToolMessage.isInstance} instead
  */

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","names":["BaseMessage","BaseMessageChunk","BaseMessageFields","$InferMessageContent","MessageStructure","ToolMessageFields","TStructure","Record","DirectToolOutput","isDirectToolOutput","ToolMessage","ToolMessageChunk","ToolCall","TName","TArgs","ToolCallChunk","InvalidToolCall","defaultToolCallParser","isToolMessage","isToolMessageChunk"],"sources":["../../src/messages/tool.d.ts"],"sourcesContent":["import { BaseMessage, BaseMessageChunk, type BaseMessageFields } from \"./base.js\";\nimport { $InferMessageContent, MessageStructure } from \"./message.js\";\nexport interface ToolMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, \"tool\"> {\n    /**\n     * Artifact of the Tool execution which is not meant to be sent to the model.\n     *\n     * Should only be specified if it is different from the message content, e.g. if only\n     * a subset of the full tool output is being passed as message content but the full\n     * output is needed in other parts of the code.\n     */\n    artifact?: any;\n    tool_call_id: string;\n    status?: \"success\" | \"error\";\n    metadata?: Record<string, unknown>;\n}\n/**\n * Marker parameter for objects that tools can return directly.\n *\n * If a custom BaseTool is invoked with a ToolCall and the output of custom code is\n * not an instance of DirectToolOutput, the output will automatically be coerced to\n * a string and wrapped in a ToolMessage.\n */\nexport interface DirectToolOutput {\n    readonly lc_direct_tool_output: true;\n}\nexport declare function isDirectToolOutput(x: unknown): x is DirectToolOutput;\n/**\n * Represents a tool message in a conversation.\n */\nexport declare class ToolMessage<TStructure extends MessageStructure = MessageStructure> extends BaseMessage<TStructure, \"tool\"> implements DirectToolOutput {\n    static lc_name(): string;\n    get lc_aliases(): Record<string, string>;\n    lc_direct_tool_output: true;\n    readonly type: \"tool\";\n    /**\n     * Status of the tool invocation.\n     * @version 0.2.19\n     */\n    status?: \"success\" | \"error\";\n    tool_call_id: string;\n    metadata?: Record<string, unknown>;\n    /**\n     * Artifact of the Tool execution which is not meant to be sent to the model.\n     *\n     * Should only be specified if it is different from the message content, e.g. if only\n     * a subset of the full tool output is being passed as message content but the full\n     * output is needed in other parts of the code.\n     */\n    artifact?: any;\n    constructor(fields: $InferMessageContent<TStructure, \"tool\"> | ToolMessageFields, tool_call_id: string, name?: string);\n    constructor(fields: ToolMessageFields<TStructure>);\n    static isInstance(message: unknown): message is ToolMessage;\n    get _printableFields(): Record<string, unknown>;\n}\n/**\n * Represents a chunk of a tool message, which can be concatenated\n * with other tool message chunks.\n */\nexport declare class ToolMessageChunk<TStructure extends MessageStructure = MessageStructure> extends BaseMessageChunk<TStructure, \"tool\"> {\n    readonly type: \"tool\";\n    tool_call_id: string;\n    /**\n     * Status of the tool invocation.\n     * @version 0.2.19\n     */\n    status?: \"success\" | \"error\";\n    /**\n     * Artifact of the Tool execution which is not meant to be sent to the model.\n     *\n     * Should only be specified if it is different from the message content, e.g. if only\n     * a subset of the full tool output is being passed as message content but the full\n     * output is needed in other parts of the code.\n     */\n    artifact?: any;\n    constructor(fields: ToolMessageFields<TStructure>);\n    static lc_name(): string;\n    concat(chunk: ToolMessageChunk<TStructure>): this;\n    get _printableFields(): Record<string, unknown>;\n}\nexport interface ToolCall<TName extends string = string, TArgs extends Record<string, any> = Record<string, any>> {\n    readonly type?: \"tool_call\";\n    /**\n     * If provided, an identifier associated with the tool call\n     */\n    id?: string;\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/**\n * A chunk of a tool call (e.g., as part of a stream).\n * When merging ToolCallChunks (e.g., via AIMessageChunk.__add__),\n * all string attributes are concatenated. Chunks are only merged if their\n * values of `index` are equal and not None.\n *\n * @example\n * ```ts\n * const leftChunks = [\n *   {\n *     name: \"foo\",\n *     args: '{\"a\":',\n *     index: 0\n *   }\n * ];\n *\n * const leftAIMessageChunk = new AIMessageChunk({\n *   content: \"\",\n *   tool_call_chunks: leftChunks\n * });\n *\n * const rightChunks = [\n *   {\n *     name: undefined,\n *     args: '1}',\n *     index: 0\n *   }\n * ];\n *\n * const rightAIMessageChunk = new AIMessageChunk({\n *   content: \"\",\n *   tool_call_chunks: rightChunks\n * });\n *\n * const result = leftAIMessageChunk.concat(rightAIMessageChunk);\n * // result.tool_call_chunks is equal to:\n * // [\n * //   {\n * //     name: \"foo\",\n * //     args: '{\"a\":1}'\n * //     index: 0\n * //   }\n * // ]\n * ```\n */\nexport interface ToolCallChunk<TName extends string = string> {\n    readonly type?: \"tool_call_chunk\";\n    /**\n     * If provided, a substring of an identifier for the tool call\n     */\n    id?: string;\n    /**\n     * If provided, a substring of the name of the tool to be called\n     */\n    name?: TName;\n    /**\n     * If provided, a JSON substring of the arguments to the tool call\n     */\n    args?: string;\n    /**\n     * If provided, the index of the tool call in a sequence\n     */\n    index?: number;\n}\nexport interface InvalidToolCall<TName extends string = string> {\n    readonly type?: \"invalid_tool_call\";\n    /**\n     * If provided, an identifier associated with the tool call\n     */\n    id?: string;\n    /**\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}\nexport declare function defaultToolCallParser(rawToolCalls: Record<string, any>[]): [ToolCall[], InvalidToolCall[]];\n/**\n * @deprecated Use {@link ToolMessage.isInstance} instead\n */\nexport declare function isToolMessage(x: unknown): x is ToolMessage;\n/**\n * @deprecated Use {@link ToolMessageChunk.isInstance} instead\n */\nexport declare function isToolMessageChunk(x: BaseMessageChunk): x is ToolMessageChunk;\n//# sourceMappingURL=tool.d.ts.map"],"mappings":";;;;UAEiBK,qCAAqCD,mBAAmBA,0BAA0BF,kBAAkBI;;AAArH;;;;;;EAAoH,QAAA,CAAA,EAAA,GAAA;EAoBnGE,YAAAA,EAAAA,MAAgB;EAGTC,MAAAA,CAAAA,EAAAA,SAAAA,GAAkB,OAAA;EAIrBC,QAAAA,CAAAA,EAhBNH,MAgBiB,CAAA,MAAAD,EAAAA,OAAAA,CAAAA;;;;;;;;;AAqBUA,UA5BzBE,gBAAAA,CA4ByBF;EAAlBD,SAAAA,qBAAAA,EAAAA,IAAAA;;AAEIE,iBA3BJE,kBAAAA,CA2BIF,CAAAA,EAAAA,OAAAA,CAAAA,EAAAA,CAAAA,IA3BiCC,gBA2BjCD;;;AAvBgI;AA6BvII,cA7BAD,WA6BgBJ,CAAAA,mBA7BeF,gBA6Bf,GA7BkCA,gBA6BlC,CAAA,SA7B4DJ,WA6B5D,CA7BwEM,UA6BxE,EAAA,MAAA,CAAA,YA7BuGE,gBA6BvG,CAAA;EAAoBJ,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAmBA,IAAAA,UAAAA,CAAAA,CAAAA,EA3BtDG,MA2BsDH,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAA2CE,qBAAAA,EAAAA,IAAAA;EAgB7EA,SAAAA,IAAAA,EAAAA,MAAAA;EAAlBD;;;;EAhB8EJ,MAAAA,CAAAA,EAAAA,SAAAA,GAAAA,OAAAA;EAAgB,YAAA,EAAA,MAAA;EAqBrGW,QAAAA,CAAAA,EAvCFL,MAuCU,CAAAM,MAAAA,EAAAC,OAAAA,CAAAA;EAA8CP;;;;AAaxD;AA+Cf;AAmBA;EAwBwBU,QAAAA,CAAAA,EAAAA,GAAAA;EAAoCV,WAAAA,CAAAA,MAAAA,EArIpCJ,oBAqIoCI,CArIfD,UAqIeC,EAAAA,MAAAA,CAAAA,GArIOF,iBAqIPE,EAAAA,YAAAA,EAAAA,MAAAA,EAAAA,IAAAA,CAAAA,EAAAA,MAAAA;EAAyBK,WAAAA,CAAAA,MAAAA,EApI7DP,iBAoI6DO,CApI3CN,UAoI2CM,CAAAA;EAAYI,OAAAA,UAAAA,CAAAA,OAAAA,EAAAA,OAAAA,CAAAA,EAAAA,OAAAA,IAnI7CN,WAmI6CM;EAAe,IAAA,gBAAA,CAAA,CAAA,EAlIpFT,MAkIoF,CAAA,MAAA,EAAA,OAAA,CAAA;AAIhH;AAIA;;;;cApIqBI,oCAAoCP,mBAAmBA,0BAA0BH,iBAAiBK;;;;;;;;;;;;;;;;sBAgB/FD,kBAAkBC;;gBAExBK,iBAAiBL;0BACPC;;UAEXK,sDAAsDL,sBAAsBA;;;;;;;;;QASnFM;;;;QAIAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA+COC;;;;;;;;;SASNF;;;;;;;;;;UAUMG;;;;;;;;;;SAUNH;;;;;;;;;;;;;;iBAcaI,qBAAAA,eAAoCV,yBAAyBK,YAAYI;;;;iBAIzEE,aAAAA,mBAAgCR;;;;iBAIhCS,kBAAAA,IAAsBlB,wBAAwBU"}

package/dist/messages/transformers.d.cts

@@ -14,7 +14,6 @@ import { RemoveMessage } from "./modifier.cjs";
 //#region src/messages/transformers.d.ts
 type MessageUnion = typeof HumanMessage | typeof AIMessage | typeof SystemMessage | typeof ChatMessage | typeof FunctionMessage | typeof ToolMessage | typeof RemoveMessage;
 type MessageChunkUnion = typeof HumanMessageChunk | typeof AIMessageChunk | typeof SystemMessageChunk | typeof FunctionMessageChunk | typeof ToolMessageChunk | typeof ChatMessageChunk | typeof RemoveMessage;
-// RemoveMessage does not have a chunk class.
 type MessageTypeOrClass = MessageType | MessageUnion | MessageChunkUnion;
 interface FilterMessagesFields {
   /**
@@ -145,8 +144,6 @@ declare function filterMessages(messages: BaseMessage[], options?: FilterMessage
  */
 declare function mergeMessageRuns(): Runnable<BaseMessage[], BaseMessage[]>;
 declare function mergeMessageRuns(messages: BaseMessage[]): BaseMessage[];
-// Since we can not import from `@langchain/textsplitters` we need
-// to reconstruct the interface here.
 interface _TextSplitterInterface extends BaseDocumentTransformer {
   splitText(text: string): Promise<string[]>;
 }

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

@@ -0,0 +1 @@
+{"version":3,"file":"transformers.d.cts","names":["BaseDocumentTransformer","BaseLanguageModel","Runnable","AIMessage","AIMessageChunk","BaseMessage","ChatMessage","ChatMessageChunk","FunctionMessage","FunctionMessageChunk","HumanMessage","HumanMessageChunk","MessageType","RemoveMessage","SystemMessage","SystemMessageChunk","ToolMessage","ToolMessageChunk","MessageUnion","MessageChunkUnion","MessageTypeOrClass","FilterMessagesFields","filterMessages","mergeMessageRuns","_TextSplitterInterface","Promise","TrimMessagesFields","trimMessages","defaultTextSplitter"],"sources":["../../src/messages/transformers.d.ts"],"sourcesContent":["import { BaseDocumentTransformer } from \"../documents/transformers.js\";\nimport { BaseLanguageModel } from \"../language_models/base.js\";\nimport { Runnable } from \"../runnables/base.js\";\nimport { AIMessage, AIMessageChunk } from \"./ai.js\";\nimport { BaseMessage } from \"./base.js\";\nimport { ChatMessage, ChatMessageChunk } from \"./chat.js\";\nimport { FunctionMessage, FunctionMessageChunk } from \"./function.js\";\nimport { HumanMessage, HumanMessageChunk } from \"./human.js\";\nimport { MessageType } from \"./message.js\";\nimport { RemoveMessage } from \"./modifier.js\";\nimport { SystemMessage, SystemMessageChunk } from \"./system.js\";\nimport { ToolMessage, ToolMessageChunk } from \"./tool.js\";\nexport type MessageUnion = typeof HumanMessage | typeof AIMessage | typeof SystemMessage | typeof ChatMessage | typeof FunctionMessage | typeof ToolMessage | typeof RemoveMessage;\nexport type MessageChunkUnion = typeof HumanMessageChunk | typeof AIMessageChunk | typeof SystemMessageChunk | typeof FunctionMessageChunk | typeof ToolMessageChunk | typeof ChatMessageChunk | typeof RemoveMessage;\nexport type MessageTypeOrClass = MessageType | MessageUnion | MessageChunkUnion;\nexport interface FilterMessagesFields {\n    /**\n     * @param {string[] | undefined} includeNames Message names to include.\n     */\n    includeNames?: string[];\n    /**\n     * @param {string[] | undefined} excludeNames Messages names to exclude.\n     */\n    excludeNames?: string[];\n    /**\n     * @param {(MessageType | BaseMessage)[] | undefined} includeTypes Message types to include. Can be specified as string names (e.g.\n     *     \"system\", \"human\", \"ai\", ...) or as BaseMessage classes (e.g.\n     *     SystemMessage, HumanMessage, AIMessage, ...).\n     */\n    includeTypes?: MessageTypeOrClass[];\n    /**\n     * @param {(MessageType | BaseMessage)[] | undefined} excludeTypes Message types to exclude. Can be specified as string names (e.g.\n     *     \"system\", \"human\", \"ai\", ...) or as BaseMessage classes (e.g.\n     *     SystemMessage, HumanMessage, AIMessage, ...).\n     */\n    excludeTypes?: MessageTypeOrClass[];\n    /**\n     * @param {string[] | undefined} includeIds Message IDs to include.\n     */\n    includeIds?: string[];\n    /**\n     * @param {string[] | undefined} excludeIds Message IDs to exclude.\n     */\n    excludeIds?: string[];\n}\n/**\n * Filter messages based on name, type or id.\n *\n * @param {BaseMessage[] | FilterMessagesFields} messagesOrOptions - Either an array of BaseMessage objects to filter or the filtering options. If an array is provided, the `options` parameter should also be supplied. If filtering options are provided, a RunnableLambda is returned.\n * @param {FilterMessagesFields} [options] - Optional filtering options. Should only be provided if `messagesOrOptions` is an array of BaseMessage objects.\n * @returns A list of Messages that meets at least one of the include conditions and none\n *     of the exclude conditions, or a RunnableLambda which does the same. If no include conditions are specified then\n *     anything that is not explicitly excluded will be included.\n * @throws {Error} If two incompatible arguments are provided.\n *\n * @example\n * ```typescript\n * import { filterMessages, AIMessage, HumanMessage, SystemMessage } from \"@langchain/core/messages\";\n *\n * const messages = [\n *   new SystemMessage(\"you're a good assistant.\"),\n *   new HumanMessage({ content: \"what's your name\", id: \"foo\", name: \"example_user\" }),\n *   new AIMessage({ content: \"steve-o\", id: \"bar\", name: \"example_assistant\" }),\n *   new HumanMessage({ content: \"what's your favorite color\", id: \"baz\" }),\n *   new AIMessage({ content: \"silicon blue\" , id: \"blah\" }),\n * ];\n *\n * filterMessages(messages, {\n *   includeNames: [\"example_user\", \"example_assistant\"],\n *   includeTypes: [\"system\"],\n *   excludeIds: [\"bar\"],\n * });\n * ```\n *\n * The above example would return:\n * ```typescript\n * [\n *   new SystemMessage(\"you're a good assistant.\"),\n *   new HumanMessage({ content: \"what's your name\", id: \"foo\", name: \"example_user\" }),\n * ]\n * ```\n */\nexport declare function filterMessages(options?: FilterMessagesFields): Runnable<BaseMessage[], BaseMessage[]>;\nexport declare function filterMessages(messages: BaseMessage[], options?: FilterMessagesFields): BaseMessage[];\n/**\n * Merge consecutive Messages of the same type.\n *\n * **NOTE**: ToolMessages are not merged, as each has a distinct tool call id that\n * can't be merged.\n *\n * @param {BaseMessage[] | undefined} messages Sequence of Message-like objects to merge. Optional. If not provided, a RunnableLambda is returned.\n * @returns List of BaseMessages with consecutive runs of message types merged into single\n *     messages, or a RunnableLambda which returns a list of BaseMessages If two messages being merged both have string contents, the merged\n *     content is a concatenation of the two strings with a new-line separator. If at\n *     least one of the messages has a list of content blocks, the merged content is a\n *     list of content blocks.\n *\n * @example\n * ```typescript\n * import { mergeMessageRuns, AIMessage, HumanMessage, SystemMessage, ToolCall } from \"@langchain/core/messages\";\n *\n * const messages = [\n *   new SystemMessage(\"you're a good assistant.\"),\n *   new HumanMessage({ content: \"what's your favorite color\", id: \"foo\" }),\n *   new HumanMessage({ content: \"wait your favorite food\", id: \"bar\" }),\n *   new AIMessage({\n *     content: \"my favorite colo\",\n *     tool_calls: [{ name: \"blah_tool\", args: { x: 2 }, id: \"123\" }],\n *     id: \"baz\",\n *   }),\n *   new AIMessage({\n *     content: [{ type: \"text\", text: \"my favorite dish is lasagna\" }],\n *     tool_calls: [{ name: \"blah_tool\", args: { x: -10 }, id: \"456\" }],\n *     id: \"blur\",\n *   }),\n * ];\n *\n * mergeMessageRuns(messages);\n * ```\n *\n * The above example would return:\n * ```typescript\n * [\n *   new SystemMessage(\"you're a good assistant.\"),\n *   new HumanMessage({\n *     content: \"what's your favorite colorwait your favorite food\",\n *     id: \"foo\",\n *   }),\n *   new AIMessage({\n *     content: [\n *       { type: \"text\", text: \"my favorite colo\" },\n *       { type: \"text\", text: \"my favorite dish is lasagna\" },\n *     ],\n *     tool_calls: [\n *       { name: \"blah_tool\", args: { x: 2 }, id: \"123\" },\n *       { name: \"blah_tool\", args: { x: -10 }, id: \"456\" },\n *     ],\n *     id: \"baz\",\n *   }),\n * ]\n * ```\n */\nexport declare function mergeMessageRuns(): Runnable<BaseMessage[], BaseMessage[]>;\nexport declare function mergeMessageRuns(messages: BaseMessage[]): BaseMessage[];\ninterface _TextSplitterInterface extends BaseDocumentTransformer {\n    splitText(text: string): Promise<string[]>;\n}\nexport interface TrimMessagesFields {\n    /**\n     * @param {number} maxTokens Max token count of trimmed messages.\n     */\n    maxTokens: number;\n    /**\n     * @param {((messages: BaseMessage[]) => number) | ((messages: BaseMessage[]) => Promise<number>) | BaseLanguageModel} tokenCounter\n     * Function or LLM for counting tokens in an array of `BaseMessage`s.\n     * If a `BaseLanguageModel` is passed in then `BaseLanguageModel.getNumTokens()` will be used.\n     */\n    tokenCounter: ((messages: BaseMessage[]) => number) | ((messages: BaseMessage[]) => Promise<number>) | BaseLanguageModel;\n    /**\n     * @param {\"first\" | \"last\"} [strategy=\"last\"] Strategy for trimming.\n     * - \"first\": Keep the first <= n_count tokens of the messages.\n     * - \"last\": Keep the last <= n_count tokens of the messages.\n     * @default \"last\"\n     */\n    strategy?: \"first\" | \"last\";\n    /**\n     * @param {boolean} [allowPartial=false] Whether to split a message if only part of the message can be included.\n     * If `strategy: \"last\"` then the last partial contents of a message are included.\n     * If `strategy: \"first\"` then the first partial contents of a message are included.\n     * @default false\n     */\n    allowPartial?: boolean;\n    /**\n     * @param {MessageTypeOrClass | MessageTypeOrClass[]} [endOn] The message type to end on.\n     * If specified then every message after the last occurrence of this type is ignored.\n     * If `strategy === \"last\"` then this is done before we attempt to get the last `maxTokens`.\n     * If `strategy === \"first\"` then this is done after we get the first `maxTokens`.\n     * Can be specified as string names (e.g. \"system\", \"human\", \"ai\", ...) or as `BaseMessage` classes\n     * (e.g. `SystemMessage`, `HumanMessage`, `AIMessage`, ...). Can be a single type or an array of types.\n     */\n    endOn?: MessageTypeOrClass | MessageTypeOrClass[];\n    /**\n     * @param {MessageTypeOrClass | MessageTypeOrClass[]} [startOn] The message type to start on.\n     * Should only be specified if `strategy: \"last\"`. If specified then every message before the first occurrence\n     * of this type is ignored. This is done after we trim the initial messages to the last `maxTokens`.\n     * Does not apply to a `SystemMessage` at index 0 if `includeSystem: true`.\n     * Can be specified as string names (e.g. \"system\", \"human\", \"ai\", ...) or as `BaseMessage` classes\n     * (e.g. `SystemMessage`, `HumanMessage`, `AIMessage`, ...). Can be a single type or an array of types.\n     */\n    startOn?: MessageTypeOrClass | MessageTypeOrClass[];\n    /**\n     * @param {boolean} [includeSystem=false] Whether to keep the `SystemMessage` if there is one at index 0.\n     * Should only be specified if `strategy: \"last\"`.\n     * @default false\n     */\n    includeSystem?: boolean;\n    /**\n     * @param {((text: string) => string[]) | BaseDocumentTransformer} [textSplitter] Function or `BaseDocumentTransformer` for\n     * splitting the string contents of a message. Only used if `allowPartial: true`.\n     * If `strategy: \"last\"` then the last split tokens from a partial message will be included.\n     * If `strategy: \"first\"` then the first split tokens from a partial message will be included.\n     * Token splitter assumes that separators are kept, so that split contents can be directly concatenated\n     * to recreate the original text. Defaults to splitting on newlines.\n     */\n    textSplitter?: ((text: string) => string[]) | ((text: string) => Promise<string[]>) | _TextSplitterInterface;\n}\n/**\n * Trim messages to be below a token count.\n *\n * @param {BaseMessage[]} messages Array of `BaseMessage` instances to trim.\n * @param {TrimMessagesFields} options Trimming options.\n * @returns An array of trimmed `BaseMessage`s or a `Runnable` that takes a sequence of `BaseMessage`-like objects and returns\n *     an array of trimmed `BaseMessage`s.\n * @throws {Error} If two incompatible arguments are specified or an unrecognized `strategy` is specified.\n *\n * @example\n * ```typescript\n * import { trimMessages, AIMessage, BaseMessage, HumanMessage, SystemMessage } from \"@langchain/core/messages\";\n *\n * const messages = [\n *   new SystemMessage(\"This is a 4 token text. The full message is 10 tokens.\"),\n *   new HumanMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"first\",\n *   }),\n *   new AIMessage({\n *     content: [\n *       { type: \"text\", text: \"This is the FIRST 4 token block.\" },\n *       { type: \"text\", text: \"This is the SECOND 4 token block.\" },\n *     ],\n *     id: \"second\",\n *   }),\n *   new HumanMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"third\",\n *   }),\n *   new AIMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"fourth\",\n *   }),\n * ];\n *\n * function dummyTokenCounter(messages: BaseMessage[]): number {\n *   // treat each message like it adds 3 default tokens at the beginning\n *   // of the message and at the end of the message. 3 + 4 + 3 = 10 tokens\n *   // per message.\n *\n *   const defaultContentLen = 4;\n *   const defaultMsgPrefixLen = 3;\n *   const defaultMsgSuffixLen = 3;\n *\n *   let count = 0;\n *   for (const msg of messages) {\n *     if (typeof msg.content === \"string\") {\n *       count += defaultMsgPrefixLen + defaultContentLen + defaultMsgSuffixLen;\n *     }\n *     if (Array.isArray(msg.content)) {\n *       count +=\n *         defaultMsgPrefixLen +\n *         msg.content.length * defaultContentLen +\n *         defaultMsgSuffixLen;\n *     }\n *   }\n *   return count;\n * }\n * ```\n *\n * First 30 tokens, not allowing partial messages:\n * ```typescript\n * await trimMessages(messages, {\n *   maxTokens: 30,\n *   tokenCounter: dummyTokenCounter,\n *   strategy: \"first\",\n * });\n * ```\n *\n * Output:\n * ```typescript\n * [\n *   new SystemMessage(\n *     \"This is a 4 token text. The full message is 10 tokens.\"\n *   ),\n *   new HumanMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"first\",\n *   }),\n * ]\n * ```\n *\n * First 30 tokens, allowing partial messages:\n * ```typescript\n * await trimMessages(messages, {\n *   maxTokens: 30,\n *   tokenCounter: dummyTokenCounter,\n *   strategy: \"first\",\n *   allowPartial: true,\n * });\n * ```\n *\n * Output:\n * ```typescript\n * [\n *   new SystemMessage(\n *     \"This is a 4 token text. The full message is 10 tokens.\"\n *   ),\n *   new HumanMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"first\",\n *   }),\n *   new AIMessage({\n *     content: [{ type: \"text\", text: \"This is the FIRST 4 token block.\" }],\n *     id: \"second\",\n *   }),\n * ]\n * ```\n *\n * First 30 tokens, allowing partial messages, have to end on HumanMessage:\n * ```typescript\n * await trimMessages(messages, {\n *   maxTokens: 30,\n *   tokenCounter: dummyTokenCounter,\n *   strategy: \"first\",\n *   allowPartial: true,\n *   endOn: \"human\",\n * });\n * ```\n *\n * Output:\n * ```typescript\n * [\n *   new SystemMessage(\n *     \"This is a 4 token text. The full message is 10 tokens.\"\n *   ),\n *   new HumanMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"first\",\n *   }),\n * ]\n * ```\n *\n * Last 30 tokens, including system message, not allowing partial messages:\n * ```typescript\n * await trimMessages(messages, {\n *   maxTokens: 30,\n *   includeSystem: true,\n *   tokenCounter: dummyTokenCounter,\n *   strategy: \"last\",\n * });\n * ```\n *\n * Output:\n * ```typescript\n * [\n *   new SystemMessage(\n *     \"This is a 4 token text. The full message is 10 tokens.\"\n *   ),\n *   new HumanMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"third\",\n *   }),\n *   new AIMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"fourth\",\n *   }),\n * ]\n * ```\n *\n * Last 40 tokens, including system message, allowing partial messages:\n * ```typescript\n * await trimMessages(messages, {\n *   maxTokens: 40,\n *   tokenCounter: dummyTokenCounter,\n *   strategy: \"last\",\n *   allowPartial: true,\n *   includeSystem: true,\n * });\n * ```\n *\n * Output:\n * ```typescript\n * [\n *   new SystemMessage(\n *     \"This is a 4 token text. The full message is 10 tokens.\"\n *   ),\n *   new AIMessage({\n *     content: [{ type: \"text\", text: \"This is the FIRST 4 token block.\" }],\n *     id: \"second\",\n *   }),\n *   new HumanMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"third\",\n *   }),\n *   new AIMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"fourth\",\n *   }),\n * ]\n * ```\n *\n * Last 30 tokens, including system message, allowing partial messages, end on HumanMessage:\n * ```typescript\n * await trimMessages(messages, {\n *   maxTokens: 30,\n *   tokenCounter: dummyTokenCounter,\n *   strategy: \"last\",\n *   endOn: \"human\",\n *   includeSystem: true,\n *   allowPartial: true,\n * });\n * ```\n *\n * Output:\n * ```typescript\n * [\n *   new SystemMessage(\n *     \"This is a 4 token text. The full message is 10 tokens.\"\n *   ),\n *   new AIMessage({\n *     content: [{ type: \"text\", text: \"This is the FIRST 4 token block.\" }],\n *     id: \"second\",\n *   }),\n *   new HumanMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"third\",\n *   }),\n * ]\n * ```\n *\n * Last 40 tokens, including system message, allowing partial messages, start on HumanMessage:\n * ```typescript\n * await trimMessages(messages, {\n *   maxTokens: 40,\n *   tokenCounter: dummyTokenCounter,\n *   strategy: \"last\",\n *   includeSystem: true,\n *   allowPartial: true,\n *   startOn: \"human\",\n * });\n * ```\n *\n * Output:\n * ```typescript\n * [\n *   new SystemMessage(\n *     \"This is a 4 token text. The full message is 10 tokens.\"\n *   ),\n *   new HumanMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"third\",\n *   }),\n *   new AIMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"fourth\",\n *   }),\n * ]\n * ```\n */\nexport declare function trimMessages(options: TrimMessagesFields): Runnable<BaseMessage[], BaseMessage[]>;\nexport declare function trimMessages(messages: BaseMessage[], options: TrimMessagesFields): Promise<BaseMessage[]>;\n/**\n * The default text splitter function that splits text by newlines.\n *\n * @param {string} text\n * @returns A promise that resolves to an array of strings split by newlines.\n */\nexport declare function defaultTextSplitter(text: string): Promise<string[]>;\nexport {};\n//# sourceMappingURL=transformers.d.ts.map"],"mappings":";;;;;;;;;;;;;;KAYYkB,YAAAA,UAAsBR,sBAAsBP,mBAAmBW,uBAAuBR,qBAAqBE,yBAAyBQ,qBAAqBH;KACzJM,iBAAAA,UAA2BR,2BAA2BP,wBAAwBW,4BAA4BN,8BAA8BQ,0BAA0BV,0BAA0BM;AAD5LK,KAEAE,kBAAAA,GAAqBR,WAFT,GAEuBM,YAFvB,GAEsCC,iBAFtC;AAAUT,UAGjBW,oBAAAA,CAHiBX;EAAsBP;;;EAA+DK,YAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAyBQ;;AAAkC;EACtKG,YAAAA,CAAAA,EAAAA,MAAiB,EAAA;EAAUR;;;;;EAAuIJ,YAAAA,CAAAA,EAgB3Ja,kBAhB2Jb,EAAAA;EAA0BM;AAAa;AACrN;;;EAA8DM,YAAAA,CAAAA,EAqB3CC,kBArB2CD,EAAAA;EAAiB;AAC/E;AAmEA;EAAiDE,UAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAgChB;;;EAAD,UAAA,CAAA,EAAA,MAAA,EAAA;AAChF;;;;AAA4G;AA2D5G;;;;AAAoD;AACpD;AAAiF;AAIjF;;;;;;;;;;;AAyDgH;AA6PhH;;;;;AAA2E;AAC3E;;;;;AAAmG;AAOnG;;iBA/XwBiB,cAAAA,WAAyBD,uBAAuBnB,SAASG,eAAeA;iBACxEiB,cAAAA,WAAyBjB,yBAAyBgB,uBAAuBhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2DzEkB,gBAAAA,CAAAA,GAAoBrB,SAASG,eAAeA;iBAC5CkB,gBAAAA,WAA2BlB,gBAAgBA;UACzDmB,sBAAAA,SAA+BxB;2BACZyB;;UAEZC,kBAAAA;;;;;;;;;;4BAUarB,wCAAwCA,kBAAkBoB,mBAAmBxB;;;;;;;;;;;;;;;;;;;;;;;UAuB/FmB,qBAAqBA;;;;;;;;;YASnBA,qBAAqBA;;;;;;;;;;;;;;;mEAekCK,qBAAqBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6PlEG,YAAAA,UAAsBD,qBAAqBxB,SAASG,eAAeA;iBACnEsB,YAAAA,WAAuBtB,wBAAwBqB,qBAAqBD,QAAQpB;;;;;;;iBAO5EuB,mBAAAA,gBAAmCH"}

package/dist/messages/transformers.d.ts

@@ -14,7 +14,6 @@ import { RemoveMessage } from "./modifier.js";
 //#region src/messages/transformers.d.ts
 type MessageUnion = typeof HumanMessage | typeof AIMessage | typeof SystemMessage | typeof ChatMessage | typeof FunctionMessage | typeof ToolMessage | typeof RemoveMessage;
 type MessageChunkUnion = typeof HumanMessageChunk | typeof AIMessageChunk | typeof SystemMessageChunk | typeof FunctionMessageChunk | typeof ToolMessageChunk | typeof ChatMessageChunk | typeof RemoveMessage;
-// RemoveMessage does not have a chunk class.
 type MessageTypeOrClass = MessageType | MessageUnion | MessageChunkUnion;
 interface FilterMessagesFields {
   /**
@@ -145,8 +144,6 @@ declare function filterMessages(messages: BaseMessage[], options?: FilterMessage
  */
 declare function mergeMessageRuns(): Runnable<BaseMessage[], BaseMessage[]>;
 declare function mergeMessageRuns(messages: BaseMessage[]): BaseMessage[];
-// Since we can not import from `@langchain/textsplitters` we need
-// to reconstruct the interface here.
 interface _TextSplitterInterface extends BaseDocumentTransformer {
   splitText(text: string): Promise<string[]>;
 }

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

@@ -0,0 +1 @@
+{"version":3,"file":"transformers.d.ts","names":["BaseDocumentTransformer","BaseLanguageModel","Runnable","AIMessage","AIMessageChunk","BaseMessage","ChatMessage","ChatMessageChunk","FunctionMessage","FunctionMessageChunk","HumanMessage","HumanMessageChunk","MessageType","RemoveMessage","SystemMessage","SystemMessageChunk","ToolMessage","ToolMessageChunk","MessageUnion","MessageChunkUnion","MessageTypeOrClass","FilterMessagesFields","filterMessages","mergeMessageRuns","_TextSplitterInterface","Promise","TrimMessagesFields","trimMessages","defaultTextSplitter"],"sources":["../../src/messages/transformers.d.ts"],"sourcesContent":["import { BaseDocumentTransformer } from \"../documents/transformers.js\";\nimport { BaseLanguageModel } from \"../language_models/base.js\";\nimport { Runnable } from \"../runnables/base.js\";\nimport { AIMessage, AIMessageChunk } from \"./ai.js\";\nimport { BaseMessage } from \"./base.js\";\nimport { ChatMessage, ChatMessageChunk } from \"./chat.js\";\nimport { FunctionMessage, FunctionMessageChunk } from \"./function.js\";\nimport { HumanMessage, HumanMessageChunk } from \"./human.js\";\nimport { MessageType } from \"./message.js\";\nimport { RemoveMessage } from \"./modifier.js\";\nimport { SystemMessage, SystemMessageChunk } from \"./system.js\";\nimport { ToolMessage, ToolMessageChunk } from \"./tool.js\";\nexport type MessageUnion = typeof HumanMessage | typeof AIMessage | typeof SystemMessage | typeof ChatMessage | typeof FunctionMessage | typeof ToolMessage | typeof RemoveMessage;\nexport type MessageChunkUnion = typeof HumanMessageChunk | typeof AIMessageChunk | typeof SystemMessageChunk | typeof FunctionMessageChunk | typeof ToolMessageChunk | typeof ChatMessageChunk | typeof RemoveMessage;\nexport type MessageTypeOrClass = MessageType | MessageUnion | MessageChunkUnion;\nexport interface FilterMessagesFields {\n    /**\n     * @param {string[] | undefined} includeNames Message names to include.\n     */\n    includeNames?: string[];\n    /**\n     * @param {string[] | undefined} excludeNames Messages names to exclude.\n     */\n    excludeNames?: string[];\n    /**\n     * @param {(MessageType | BaseMessage)[] | undefined} includeTypes Message types to include. Can be specified as string names (e.g.\n     *     \"system\", \"human\", \"ai\", ...) or as BaseMessage classes (e.g.\n     *     SystemMessage, HumanMessage, AIMessage, ...).\n     */\n    includeTypes?: MessageTypeOrClass[];\n    /**\n     * @param {(MessageType | BaseMessage)[] | undefined} excludeTypes Message types to exclude. Can be specified as string names (e.g.\n     *     \"system\", \"human\", \"ai\", ...) or as BaseMessage classes (e.g.\n     *     SystemMessage, HumanMessage, AIMessage, ...).\n     */\n    excludeTypes?: MessageTypeOrClass[];\n    /**\n     * @param {string[] | undefined} includeIds Message IDs to include.\n     */\n    includeIds?: string[];\n    /**\n     * @param {string[] | undefined} excludeIds Message IDs to exclude.\n     */\n    excludeIds?: string[];\n}\n/**\n * Filter messages based on name, type or id.\n *\n * @param {BaseMessage[] | FilterMessagesFields} messagesOrOptions - Either an array of BaseMessage objects to filter or the filtering options. If an array is provided, the `options` parameter should also be supplied. If filtering options are provided, a RunnableLambda is returned.\n * @param {FilterMessagesFields} [options] - Optional filtering options. Should only be provided if `messagesOrOptions` is an array of BaseMessage objects.\n * @returns A list of Messages that meets at least one of the include conditions and none\n *     of the exclude conditions, or a RunnableLambda which does the same. If no include conditions are specified then\n *     anything that is not explicitly excluded will be included.\n * @throws {Error} If two incompatible arguments are provided.\n *\n * @example\n * ```typescript\n * import { filterMessages, AIMessage, HumanMessage, SystemMessage } from \"@langchain/core/messages\";\n *\n * const messages = [\n *   new SystemMessage(\"you're a good assistant.\"),\n *   new HumanMessage({ content: \"what's your name\", id: \"foo\", name: \"example_user\" }),\n *   new AIMessage({ content: \"steve-o\", id: \"bar\", name: \"example_assistant\" }),\n *   new HumanMessage({ content: \"what's your favorite color\", id: \"baz\" }),\n *   new AIMessage({ content: \"silicon blue\" , id: \"blah\" }),\n * ];\n *\n * filterMessages(messages, {\n *   includeNames: [\"example_user\", \"example_assistant\"],\n *   includeTypes: [\"system\"],\n *   excludeIds: [\"bar\"],\n * });\n * ```\n *\n * The above example would return:\n * ```typescript\n * [\n *   new SystemMessage(\"you're a good assistant.\"),\n *   new HumanMessage({ content: \"what's your name\", id: \"foo\", name: \"example_user\" }),\n * ]\n * ```\n */\nexport declare function filterMessages(options?: FilterMessagesFields): Runnable<BaseMessage[], BaseMessage[]>;\nexport declare function filterMessages(messages: BaseMessage[], options?: FilterMessagesFields): BaseMessage[];\n/**\n * Merge consecutive Messages of the same type.\n *\n * **NOTE**: ToolMessages are not merged, as each has a distinct tool call id that\n * can't be merged.\n *\n * @param {BaseMessage[] | undefined} messages Sequence of Message-like objects to merge. Optional. If not provided, a RunnableLambda is returned.\n * @returns List of BaseMessages with consecutive runs of message types merged into single\n *     messages, or a RunnableLambda which returns a list of BaseMessages If two messages being merged both have string contents, the merged\n *     content is a concatenation of the two strings with a new-line separator. If at\n *     least one of the messages has a list of content blocks, the merged content is a\n *     list of content blocks.\n *\n * @example\n * ```typescript\n * import { mergeMessageRuns, AIMessage, HumanMessage, SystemMessage, ToolCall } from \"@langchain/core/messages\";\n *\n * const messages = [\n *   new SystemMessage(\"you're a good assistant.\"),\n *   new HumanMessage({ content: \"what's your favorite color\", id: \"foo\" }),\n *   new HumanMessage({ content: \"wait your favorite food\", id: \"bar\" }),\n *   new AIMessage({\n *     content: \"my favorite colo\",\n *     tool_calls: [{ name: \"blah_tool\", args: { x: 2 }, id: \"123\" }],\n *     id: \"baz\",\n *   }),\n *   new AIMessage({\n *     content: [{ type: \"text\", text: \"my favorite dish is lasagna\" }],\n *     tool_calls: [{ name: \"blah_tool\", args: { x: -10 }, id: \"456\" }],\n *     id: \"blur\",\n *   }),\n * ];\n *\n * mergeMessageRuns(messages);\n * ```\n *\n * The above example would return:\n * ```typescript\n * [\n *   new SystemMessage(\"you're a good assistant.\"),\n *   new HumanMessage({\n *     content: \"what's your favorite colorwait your favorite food\",\n *     id: \"foo\",\n *   }),\n *   new AIMessage({\n *     content: [\n *       { type: \"text\", text: \"my favorite colo\" },\n *       { type: \"text\", text: \"my favorite dish is lasagna\" },\n *     ],\n *     tool_calls: [\n *       { name: \"blah_tool\", args: { x: 2 }, id: \"123\" },\n *       { name: \"blah_tool\", args: { x: -10 }, id: \"456\" },\n *     ],\n *     id: \"baz\",\n *   }),\n * ]\n * ```\n */\nexport declare function mergeMessageRuns(): Runnable<BaseMessage[], BaseMessage[]>;\nexport declare function mergeMessageRuns(messages: BaseMessage[]): BaseMessage[];\ninterface _TextSplitterInterface extends BaseDocumentTransformer {\n    splitText(text: string): Promise<string[]>;\n}\nexport interface TrimMessagesFields {\n    /**\n     * @param {number} maxTokens Max token count of trimmed messages.\n     */\n    maxTokens: number;\n    /**\n     * @param {((messages: BaseMessage[]) => number) | ((messages: BaseMessage[]) => Promise<number>) | BaseLanguageModel} tokenCounter\n     * Function or LLM for counting tokens in an array of `BaseMessage`s.\n     * If a `BaseLanguageModel` is passed in then `BaseLanguageModel.getNumTokens()` will be used.\n     */\n    tokenCounter: ((messages: BaseMessage[]) => number) | ((messages: BaseMessage[]) => Promise<number>) | BaseLanguageModel;\n    /**\n     * @param {\"first\" | \"last\"} [strategy=\"last\"] Strategy for trimming.\n     * - \"first\": Keep the first <= n_count tokens of the messages.\n     * - \"last\": Keep the last <= n_count tokens of the messages.\n     * @default \"last\"\n     */\n    strategy?: \"first\" | \"last\";\n    /**\n     * @param {boolean} [allowPartial=false] Whether to split a message if only part of the message can be included.\n     * If `strategy: \"last\"` then the last partial contents of a message are included.\n     * If `strategy: \"first\"` then the first partial contents of a message are included.\n     * @default false\n     */\n    allowPartial?: boolean;\n    /**\n     * @param {MessageTypeOrClass | MessageTypeOrClass[]} [endOn] The message type to end on.\n     * If specified then every message after the last occurrence of this type is ignored.\n     * If `strategy === \"last\"` then this is done before we attempt to get the last `maxTokens`.\n     * If `strategy === \"first\"` then this is done after we get the first `maxTokens`.\n     * Can be specified as string names (e.g. \"system\", \"human\", \"ai\", ...) or as `BaseMessage` classes\n     * (e.g. `SystemMessage`, `HumanMessage`, `AIMessage`, ...). Can be a single type or an array of types.\n     */\n    endOn?: MessageTypeOrClass | MessageTypeOrClass[];\n    /**\n     * @param {MessageTypeOrClass | MessageTypeOrClass[]} [startOn] The message type to start on.\n     * Should only be specified if `strategy: \"last\"`. If specified then every message before the first occurrence\n     * of this type is ignored. This is done after we trim the initial messages to the last `maxTokens`.\n     * Does not apply to a `SystemMessage` at index 0 if `includeSystem: true`.\n     * Can be specified as string names (e.g. \"system\", \"human\", \"ai\", ...) or as `BaseMessage` classes\n     * (e.g. `SystemMessage`, `HumanMessage`, `AIMessage`, ...). Can be a single type or an array of types.\n     */\n    startOn?: MessageTypeOrClass | MessageTypeOrClass[];\n    /**\n     * @param {boolean} [includeSystem=false] Whether to keep the `SystemMessage` if there is one at index 0.\n     * Should only be specified if `strategy: \"last\"`.\n     * @default false\n     */\n    includeSystem?: boolean;\n    /**\n     * @param {((text: string) => string[]) | BaseDocumentTransformer} [textSplitter] Function or `BaseDocumentTransformer` for\n     * splitting the string contents of a message. Only used if `allowPartial: true`.\n     * If `strategy: \"last\"` then the last split tokens from a partial message will be included.\n     * If `strategy: \"first\"` then the first split tokens from a partial message will be included.\n     * Token splitter assumes that separators are kept, so that split contents can be directly concatenated\n     * to recreate the original text. Defaults to splitting on newlines.\n     */\n    textSplitter?: ((text: string) => string[]) | ((text: string) => Promise<string[]>) | _TextSplitterInterface;\n}\n/**\n * Trim messages to be below a token count.\n *\n * @param {BaseMessage[]} messages Array of `BaseMessage` instances to trim.\n * @param {TrimMessagesFields} options Trimming options.\n * @returns An array of trimmed `BaseMessage`s or a `Runnable` that takes a sequence of `BaseMessage`-like objects and returns\n *     an array of trimmed `BaseMessage`s.\n * @throws {Error} If two incompatible arguments are specified or an unrecognized `strategy` is specified.\n *\n * @example\n * ```typescript\n * import { trimMessages, AIMessage, BaseMessage, HumanMessage, SystemMessage } from \"@langchain/core/messages\";\n *\n * const messages = [\n *   new SystemMessage(\"This is a 4 token text. The full message is 10 tokens.\"),\n *   new HumanMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"first\",\n *   }),\n *   new AIMessage({\n *     content: [\n *       { type: \"text\", text: \"This is the FIRST 4 token block.\" },\n *       { type: \"text\", text: \"This is the SECOND 4 token block.\" },\n *     ],\n *     id: \"second\",\n *   }),\n *   new HumanMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"third\",\n *   }),\n *   new AIMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"fourth\",\n *   }),\n * ];\n *\n * function dummyTokenCounter(messages: BaseMessage[]): number {\n *   // treat each message like it adds 3 default tokens at the beginning\n *   // of the message and at the end of the message. 3 + 4 + 3 = 10 tokens\n *   // per message.\n *\n *   const defaultContentLen = 4;\n *   const defaultMsgPrefixLen = 3;\n *   const defaultMsgSuffixLen = 3;\n *\n *   let count = 0;\n *   for (const msg of messages) {\n *     if (typeof msg.content === \"string\") {\n *       count += defaultMsgPrefixLen + defaultContentLen + defaultMsgSuffixLen;\n *     }\n *     if (Array.isArray(msg.content)) {\n *       count +=\n *         defaultMsgPrefixLen +\n *         msg.content.length * defaultContentLen +\n *         defaultMsgSuffixLen;\n *     }\n *   }\n *   return count;\n * }\n * ```\n *\n * First 30 tokens, not allowing partial messages:\n * ```typescript\n * await trimMessages(messages, {\n *   maxTokens: 30,\n *   tokenCounter: dummyTokenCounter,\n *   strategy: \"first\",\n * });\n * ```\n *\n * Output:\n * ```typescript\n * [\n *   new SystemMessage(\n *     \"This is a 4 token text. The full message is 10 tokens.\"\n *   ),\n *   new HumanMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"first\",\n *   }),\n * ]\n * ```\n *\n * First 30 tokens, allowing partial messages:\n * ```typescript\n * await trimMessages(messages, {\n *   maxTokens: 30,\n *   tokenCounter: dummyTokenCounter,\n *   strategy: \"first\",\n *   allowPartial: true,\n * });\n * ```\n *\n * Output:\n * ```typescript\n * [\n *   new SystemMessage(\n *     \"This is a 4 token text. The full message is 10 tokens.\"\n *   ),\n *   new HumanMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"first\",\n *   }),\n *   new AIMessage({\n *     content: [{ type: \"text\", text: \"This is the FIRST 4 token block.\" }],\n *     id: \"second\",\n *   }),\n * ]\n * ```\n *\n * First 30 tokens, allowing partial messages, have to end on HumanMessage:\n * ```typescript\n * await trimMessages(messages, {\n *   maxTokens: 30,\n *   tokenCounter: dummyTokenCounter,\n *   strategy: \"first\",\n *   allowPartial: true,\n *   endOn: \"human\",\n * });\n * ```\n *\n * Output:\n * ```typescript\n * [\n *   new SystemMessage(\n *     \"This is a 4 token text. The full message is 10 tokens.\"\n *   ),\n *   new HumanMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"first\",\n *   }),\n * ]\n * ```\n *\n * Last 30 tokens, including system message, not allowing partial messages:\n * ```typescript\n * await trimMessages(messages, {\n *   maxTokens: 30,\n *   includeSystem: true,\n *   tokenCounter: dummyTokenCounter,\n *   strategy: \"last\",\n * });\n * ```\n *\n * Output:\n * ```typescript\n * [\n *   new SystemMessage(\n *     \"This is a 4 token text. The full message is 10 tokens.\"\n *   ),\n *   new HumanMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"third\",\n *   }),\n *   new AIMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"fourth\",\n *   }),\n * ]\n * ```\n *\n * Last 40 tokens, including system message, allowing partial messages:\n * ```typescript\n * await trimMessages(messages, {\n *   maxTokens: 40,\n *   tokenCounter: dummyTokenCounter,\n *   strategy: \"last\",\n *   allowPartial: true,\n *   includeSystem: true,\n * });\n * ```\n *\n * Output:\n * ```typescript\n * [\n *   new SystemMessage(\n *     \"This is a 4 token text. The full message is 10 tokens.\"\n *   ),\n *   new AIMessage({\n *     content: [{ type: \"text\", text: \"This is the FIRST 4 token block.\" }],\n *     id: \"second\",\n *   }),\n *   new HumanMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"third\",\n *   }),\n *   new AIMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"fourth\",\n *   }),\n * ]\n * ```\n *\n * Last 30 tokens, including system message, allowing partial messages, end on HumanMessage:\n * ```typescript\n * await trimMessages(messages, {\n *   maxTokens: 30,\n *   tokenCounter: dummyTokenCounter,\n *   strategy: \"last\",\n *   endOn: \"human\",\n *   includeSystem: true,\n *   allowPartial: true,\n * });\n * ```\n *\n * Output:\n * ```typescript\n * [\n *   new SystemMessage(\n *     \"This is a 4 token text. The full message is 10 tokens.\"\n *   ),\n *   new AIMessage({\n *     content: [{ type: \"text\", text: \"This is the FIRST 4 token block.\" }],\n *     id: \"second\",\n *   }),\n *   new HumanMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"third\",\n *   }),\n * ]\n * ```\n *\n * Last 40 tokens, including system message, allowing partial messages, start on HumanMessage:\n * ```typescript\n * await trimMessages(messages, {\n *   maxTokens: 40,\n *   tokenCounter: dummyTokenCounter,\n *   strategy: \"last\",\n *   includeSystem: true,\n *   allowPartial: true,\n *   startOn: \"human\",\n * });\n * ```\n *\n * Output:\n * ```typescript\n * [\n *   new SystemMessage(\n *     \"This is a 4 token text. The full message is 10 tokens.\"\n *   ),\n *   new HumanMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"third\",\n *   }),\n *   new AIMessage({\n *     content: \"This is a 4 token text. The full message is 10 tokens.\",\n *     id: \"fourth\",\n *   }),\n * ]\n * ```\n */\nexport declare function trimMessages(options: TrimMessagesFields): Runnable<BaseMessage[], BaseMessage[]>;\nexport declare function trimMessages(messages: BaseMessage[], options: TrimMessagesFields): Promise<BaseMessage[]>;\n/**\n * The default text splitter function that splits text by newlines.\n *\n * @param {string} text\n * @returns A promise that resolves to an array of strings split by newlines.\n */\nexport declare function defaultTextSplitter(text: string): Promise<string[]>;\nexport {};\n//# sourceMappingURL=transformers.d.ts.map"],"mappings":";;;;;;;;;;;;;;KAYYkB,YAAAA,UAAsBR,sBAAsBP,mBAAmBW,uBAAuBR,qBAAqBE,yBAAyBQ,qBAAqBH;KACzJM,iBAAAA,UAA2BR,2BAA2BP,wBAAwBW,4BAA4BN,8BAA8BQ,0BAA0BV,0BAA0BM;AAD5LK,KAEAE,kBAAAA,GAAqBR,WAFT,GAEuBM,YAFvB,GAEsCC,iBAFtC;AAAUT,UAGjBW,oBAAAA,CAHiBX;EAAsBP;;;EAA+DK,YAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAyBQ;;AAAkC;EACtKG,YAAAA,CAAAA,EAAAA,MAAiB,EAAA;EAAUR;;;;;EAAuIJ,YAAAA,CAAAA,EAgB3Ja,kBAhB2Jb,EAAAA;EAA0BM;AAAa;AACrN;;;EAA8DM,YAAAA,CAAAA,EAqB3CC,kBArB2CD,EAAAA;EAAiB;AAC/E;AAmEA;EAAiDE,UAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAgChB;;;EAAD,UAAA,CAAA,EAAA,MAAA,EAAA;AAChF;;;;AAA4G;AA2D5G;;;;AAAoD;AACpD;AAAiF;AAIjF;;;;;;;;;;;AAyDgH;AA6PhH;;;;;AAA2E;AAC3E;;;;;AAAmG;AAOnG;;iBA/XwBiB,cAAAA,WAAyBD,uBAAuBnB,SAASG,eAAeA;iBACxEiB,cAAAA,WAAyBjB,yBAAyBgB,uBAAuBhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2DzEkB,gBAAAA,CAAAA,GAAoBrB,SAASG,eAAeA;iBAC5CkB,gBAAAA,WAA2BlB,gBAAgBA;UACzDmB,sBAAAA,SAA+BxB;2BACZyB;;UAEZC,kBAAAA;;;;;;;;;;4BAUarB,wCAAwCA,kBAAkBoB,mBAAmBxB;;;;;;;;;;;;;;;;;;;;;;;UAuB/FmB,qBAAqBA;;;;;;;;;YASnBA,qBAAqBA;;;;;;;;;;;;;;;mEAekCK,qBAAqBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6PlEG,YAAAA,UAAsBD,qBAAqBxB,SAASG,eAAeA;iBACnEsB,YAAAA,WAAuBtB,wBAAwBqB,qBAAqBD,QAAQpB;;;;;;;iBAO5EuB,mBAAAA,gBAAmCH"}

package/dist/messages/utils.d.cts

@@ -63,9 +63,7 @@ type $OnlyIndexSignatures<T$1> = $HasIndexSignature<T$1> extends true ? [$KnownK
  * // }
  * ```
  */
-type $MergeObjects<T$1, U$1> =
-// If U is purely index-signature based, prefer U as a whole
-$OnlyIndexSignatures<U$1> extends true ? U$1 : $OnlyIndexSignatures<T$1> extends true ? U$1 : { [K in keyof T$1 | keyof U$1]: K extends keyof T$1 ? K extends keyof U$1 ? T$1[K] extends Record<string, unknown> ? U$1[K] extends Record<string, unknown> ? $MergeObjects<T$1[K], U$1[K]> : U$1[K] : U$1[K] : T$1[K] : K extends keyof U$1 ? U$1[K] : never };
+type $MergeObjects<T$1, U$1> = $OnlyIndexSignatures<U$1> extends true ? U$1 : $OnlyIndexSignatures<T$1> extends true ? U$1 : { [K in keyof T$1 | keyof U$1]: K extends keyof T$1 ? K extends keyof U$1 ? T$1[K] extends Record<string, unknown> ? U$1[K] extends Record<string, unknown> ? $MergeObjects<T$1[K], U$1[K]> : U$1[K] : U$1[K] : T$1[K] : K extends keyof U$1 ? U$1[K] : never };
 /**
  * Merges two discriminated unions A and B based on a discriminator key (defaults to "type").
  * For each possible value of the discriminator across both unions:
@@ -77,8 +75,7 @@ $OnlyIndexSignatures<U$1> extends true ? U$1 : $OnlyIndexSignatures<T$1> extends
  * @template B - Second discriminated union type that extends Record<Key, PropertyKey>
  * @template Key - The discriminator key property, defaults to "type"
  */
-type $MergeDiscriminatedUnion<A extends Record<Key, PropertyKey>, B extends Record<Key, PropertyKey>, Key extends PropertyKey = "type"> = { [T in A[Key] | B[Key]]: [Extract<B, Record<Key, T>>] extends [never] // Check if B has a member with this discriminator value
-? Extract<A, Record<Key, T>> : [Extract<A, Record<Key, T>>] extends [never] ? Extract<B, Record<Key, T>> : $MergeObjects<Extract<A, Record<Key, T>>, Extract<B, Record<Key, T>>> }[A[Key] | B[Key]];
+type $MergeDiscriminatedUnion<A extends Record<Key, PropertyKey>, B extends Record<Key, PropertyKey>, Key extends PropertyKey = "type"> = { [T in A[Key] | B[Key]]: [Extract<B, Record<Key, T>>] extends [never] ? Extract<A, Record<Key, T>> : [Extract<A, Record<Key, T>>] extends [never] ? Extract<B, Record<Key, T>> : $MergeObjects<Extract<A, Record<Key, T>>, Extract<B, Record<Key, T>>> }[A[Key] | B[Key]];
 type Constructor<T$1> = new (...args: unknown[]) => T$1;
 /**
  * Immediately-invoked function expression.

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.cts","names":["AIMessage","AIMessageChunk","BaseMessageLike","BaseMessage","StoredMessage","ChatMessage","ChatMessageChunk","FunctionMessage","FunctionMessageChunk","HumanMessage","HumanMessageChunk","SystemMessage","SystemMessageChunk","InvalidToolCall","ToolCall","ToolCallChunk","ToolMessage","$Expand","T","U","K","$KnownKeys","$HasIndexSignature","$OnlyIndexSignatures","$MergeObjects","Record","$MergeDiscriminatedUnion","A","B","Key","PropertyKey","Extract","Constructor","iife","coerceMessageLikeToMessage","getBufferString","mapStoredMessageToChatMessage","__message_js0","MessageStructure","mapStoredMessagesToChatMessages","mapChatMessagesToStoredMessages","convertToChunk","collapseToolCallChunks"],"sources":["../../src/messages/utils.d.ts"],"sourcesContent":["import { AIMessage, AIMessageChunk } from \"./ai.js\";\nimport { BaseMessageLike, BaseMessage, StoredMessage } from \"./base.js\";\nimport { ChatMessage, ChatMessageChunk } from \"./chat.js\";\nimport { FunctionMessage, FunctionMessageChunk } from \"./function.js\";\nimport { HumanMessage, HumanMessageChunk } from \"./human.js\";\nimport { SystemMessage, SystemMessageChunk } from \"./system.js\";\nimport { InvalidToolCall, ToolCall, ToolCallChunk, ToolMessage } from \"./tool.js\";\nexport type $Expand<T> = T extends infer U ? {\n    [K in keyof U]: U[K];\n} : never;\n/**\n * Extracts the explicitly declared keys from a type T.\n *\n * @template T - The type to extract keys from\n * @returns A union of keys that are not string, number, or symbol\n */\ntype $KnownKeys<T> = {\n    [K in keyof T]: string extends K ? never : number extends K ? never : symbol extends K ? never : K;\n}[keyof T];\n/**\n * Detects if T has an index signature.\n *\n * @template T - The type to check for index signatures\n * @returns True if T has an index signature, false otherwise\n */\ntype $HasIndexSignature<T> = string extends keyof T ? true : number extends keyof T ? true : symbol extends keyof T ? true : false;\n/**\n * Detects if T has an index signature and no known keys.\n *\n * @template T - The type to check for index signatures and no known keys\n * @returns True if T has an index signature and no known keys, false otherwise\n */\ntype $OnlyIndexSignatures<T> = $HasIndexSignature<T> extends true ? [$KnownKeys<T>] extends [never] ? true : false : false;\n/**\n * Recursively merges two object types T and U, with U taking precedence over T.\n *\n * This utility type performs a deep merge of two object types:\n * - For keys that exist in both T and U:\n *   - If both values are objects (Record<string, unknown>), recursively merge them\n *   - Otherwise, U's value takes precedence\n * - For keys that exist only in T, use T's value\n * - For keys that exist only in U, use U's value\n *\n * @template T - The first object type to merge\n * @template U - The second object type to merge (takes precedence over T)\n *\n * @example\n * ```ts\n * type ObjectA = {\n *   shared: { a: string; b: number };\n *   onlyInA: boolean;\n * };\n *\n * type ObjectB = {\n *   shared: { b: string; c: Date };\n *   onlyInB: symbol;\n * };\n *\n * type Merged = $MergeObjects<ObjectA, ObjectB>;\n * // Result: {\n * //   shared: { a: string; b: string; c: Date };\n * //   onlyInA: boolean;\n * //   onlyInB: symbol;\n * // }\n * ```\n */\nexport type $MergeObjects<T, U> = $OnlyIndexSignatures<U> extends true ? U : $OnlyIndexSignatures<T> extends true ? U : {\n    [K in keyof T | keyof U]: K extends keyof T ? K extends keyof U ? T[K] extends Record<string, unknown> ? U[K] extends Record<string, unknown> ? $MergeObjects<T[K], U[K]> : U[K] : U[K] : T[K] : K extends keyof U ? U[K] : never;\n};\n/**\n * Merges two discriminated unions A and B based on a discriminator key (defaults to \"type\").\n * For each possible value of the discriminator across both unions:\n * - If B has a member with that discriminator value, use B's member\n * - Otherwise use A's member with that discriminator value\n * This effectively merges the unions while giving B's members precedence over A's members.\n *\n * @template A - First discriminated union type that extends Record<Key, PropertyKey>\n * @template B - Second discriminated union type that extends Record<Key, PropertyKey>\n * @template Key - The discriminator key property, defaults to \"type\"\n */\nexport type $MergeDiscriminatedUnion<A extends Record<Key, PropertyKey>, B extends Record<Key, PropertyKey>, Key extends PropertyKey = \"type\"> = {\n    [T in A[Key] | B[Key]]: [Extract<B, Record<Key, T>>] extends [never] ? Extract<A, Record<Key, T>> : [\n        Extract<A, Record<Key, T>>\n    ] extends [never] ? Extract<B, Record<Key, T>> : $MergeObjects<Extract<A, Record<Key, T>>, Extract<B, Record<Key, T>>>;\n}[A[Key] | B[Key]];\nexport type Constructor<T> = new (...args: unknown[]) => T;\n/**\n * Immediately-invoked function expression.\n *\n * @param fn - The function to execute\n * @returns The result of the function\n */\nexport declare const iife: <T>(fn: () => T) => T;\nexport declare function coerceMessageLikeToMessage(messageLike: BaseMessageLike): BaseMessage;\n/**\n * This function is used by memory classes to get a string representation\n * of the chat message history, based on the message content and role.\n */\nexport declare function getBufferString(messages: BaseMessage[], humanPrefix?: string, aiPrefix?: string): string;\nexport declare function mapStoredMessageToChatMessage(message: StoredMessage): AIMessage<import(\"./message.js\").MessageStructure> | ChatMessage<import(\"./message.js\").MessageStructure> | FunctionMessage<import(\"./message.js\").MessageStructure> | HumanMessage<import(\"./message.js\").MessageStructure> | SystemMessage<import(\"./message.js\").MessageStructure> | ToolMessage<import(\"./message.js\").MessageStructure>;\n/**\n * Transforms an array of `StoredMessage` instances into an array of\n * `BaseMessage` instances. It uses the `mapV1MessageToStoredMessage`\n * function to ensure all messages are in the `StoredMessage` format, then\n * creates new instances of the appropriate `BaseMessage` subclass based\n * on the type of each message. This function is used to prepare stored\n * messages for use in a chat context.\n */\nexport declare function mapStoredMessagesToChatMessages(messages: StoredMessage[]): BaseMessage[];\n/**\n * Transforms an array of `BaseMessage` instances into an array of\n * `StoredMessage` instances. It does this by calling the `toDict` method\n * on each `BaseMessage`, which returns a `StoredMessage`. This function\n * is used to prepare chat messages for storage.\n */\nexport declare function mapChatMessagesToStoredMessages(messages: BaseMessage[]): StoredMessage[];\nexport declare function convertToChunk(message: BaseMessage): AIMessageChunk<import(\"./message.js\").MessageStructure> | ChatMessageChunk<import(\"./message.js\").MessageStructure> | FunctionMessageChunk<import(\"./message.js\").MessageStructure> | HumanMessageChunk<import(\"./message.js\").MessageStructure> | SystemMessageChunk<import(\"./message.js\").MessageStructure>;\n/**\n * Collapses an array of tool call chunks into complete tool calls.\n *\n * This function groups tool call chunks by their id and/or index, then attempts to\n * parse and validate the accumulated arguments for each group. Successfully parsed\n * tool calls are returned as valid `ToolCall` objects, while malformed ones are\n * returned as `InvalidToolCall` objects.\n *\n * @param chunks - An array of `ToolCallChunk` objects to collapse\n * @returns An object containing:\n *   - `tool_call_chunks`: The original input chunks\n *   - `tool_calls`: An array of successfully parsed and validated tool calls\n *   - `invalid_tool_calls`: An array of tool calls that failed parsing or validation\n *\n * @remarks\n * Chunks are grouped using the following matching logic:\n * - If a chunk has both an id and index, it matches chunks with the same id and index\n * - If a chunk has only an id, it matches chunks with the same id\n * - If a chunk has only an index, it matches chunks with the same index\n *\n * For each group, the function:\n * 1. Concatenates all `args` strings from the chunks\n * 2. Attempts to parse the concatenated string as JSON\n * 3. Validates that the result is a non-null object with a valid id\n * 4. Creates either a `ToolCall` (if valid) or `InvalidToolCall` (if invalid)\n */\nexport declare function collapseToolCallChunks(chunks: ToolCallChunk[]): {\n    tool_call_chunks: ToolCallChunk[];\n    tool_calls: ToolCall[];\n    invalid_tool_calls: InvalidToolCall[];\n};\nexport {};\n//# sourceMappingURL=utils.d.ts.map"],"mappings":"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"}

package/dist/messages/utils.d.ts

@@ -63,9 +63,7 @@ type $OnlyIndexSignatures<T$1> = $HasIndexSignature<T$1> extends true ? [$KnownK
  * // }
  * ```
  */
-type $MergeObjects<T$1, U$1> =
-// If U is purely index-signature based, prefer U as a whole
-$OnlyIndexSignatures<U$1> extends true ? U$1 : $OnlyIndexSignatures<T$1> extends true ? U$1 : { [K in keyof T$1 | keyof U$1]: K extends keyof T$1 ? K extends keyof U$1 ? T$1[K] extends Record<string, unknown> ? U$1[K] extends Record<string, unknown> ? $MergeObjects<T$1[K], U$1[K]> : U$1[K] : U$1[K] : T$1[K] : K extends keyof U$1 ? U$1[K] : never };
+type $MergeObjects<T$1, U$1> = $OnlyIndexSignatures<U$1> extends true ? U$1 : $OnlyIndexSignatures<T$1> extends true ? U$1 : { [K in keyof T$1 | keyof U$1]: K extends keyof T$1 ? K extends keyof U$1 ? T$1[K] extends Record<string, unknown> ? U$1[K] extends Record<string, unknown> ? $MergeObjects<T$1[K], U$1[K]> : U$1[K] : U$1[K] : T$1[K] : K extends keyof U$1 ? U$1[K] : never };
 /**
  * Merges two discriminated unions A and B based on a discriminator key (defaults to "type").
  * For each possible value of the discriminator across both unions:
@@ -77,8 +75,7 @@ $OnlyIndexSignatures<U$1> extends true ? U$1 : $OnlyIndexSignatures<T$1> extends
  * @template B - Second discriminated union type that extends Record<Key, PropertyKey>
  * @template Key - The discriminator key property, defaults to "type"
  */
-type $MergeDiscriminatedUnion<A extends Record<Key, PropertyKey>, B extends Record<Key, PropertyKey>, Key extends PropertyKey = "type"> = { [T in A[Key] | B[Key]]: [Extract<B, Record<Key, T>>] extends [never] // Check if B has a member with this discriminator value
-? Extract<A, Record<Key, T>> : [Extract<A, Record<Key, T>>] extends [never] ? Extract<B, Record<Key, T>> : $MergeObjects<Extract<A, Record<Key, T>>, Extract<B, Record<Key, T>>> }[A[Key] | B[Key]];
+type $MergeDiscriminatedUnion<A extends Record<Key, PropertyKey>, B extends Record<Key, PropertyKey>, Key extends PropertyKey = "type"> = { [T in A[Key] | B[Key]]: [Extract<B, Record<Key, T>>] extends [never] ? Extract<A, Record<Key, T>> : [Extract<A, Record<Key, T>>] extends [never] ? Extract<B, Record<Key, T>> : $MergeObjects<Extract<A, Record<Key, T>>, Extract<B, Record<Key, T>>> }[A[Key] | B[Key]];
 type Constructor<T$1> = new (...args: unknown[]) => T$1;
 /**
  * Immediately-invoked function expression.