@langchain/core 1.2.4 → 1.2.5

package/dist/messages/message.d.ts

@@ -1,7 +1,6 @@
 import { ContentBlock } from "./content/index.js";
 import { ResponseMetadata, UsageMetadata } from "./metadata.js";
 import { $MergeDiscriminatedUnion, $MergeObjects } from "./utils.js";
-
 //#region src/messages/message.d.ts
 /**
  * Represents the possible types of messages in the system.
@@ -113,7 +112,7 @@ interface MessageToolSet {
  * // }
  * ```
  */
-type $MessageToolCallBlock<TStructure extends MessageStructure> = TStructure["tools"] extends MessageToolSet ? { [K in keyof TStructure["tools"]]: K extends string ? TStructure["tools"][K] extends MessageToolDefinition ? ContentBlock.Tools.ToolCall<K, TStructure["tools"][K]["input"]> : never : never }[keyof TStructure["tools"]] : never;
+type $MessageToolCallBlock<TStructure extends MessageStructure> = TStructure["tools"] extends MessageToolSet ? { [K in keyof TStructure["tools"]]: K extends string ? TStructure["tools"][K] extends MessageToolDefinition ? ContentBlock.Tools.ToolCall<K, TStructure["tools"][K]["input"]> : never : never; }[keyof TStructure["tools"]] : never;
 /**
  * Helper type to infer a union of ToolCall types from the tools defined in a MessageStructure.
  * This is used to type the `tool_calls` array in AIMessage based on the available tools.
@@ -137,12 +136,12 @@ type $MessageToolCallBlock<TStructure extends MessageStructure> = TStructure["to
  * // | { type?: "tool_call"; id?: string; name: "search"; args: { query: string } }
  * ```
  */
-type $InferToolCalls<TStructure extends MessageStructure> = NonNullable<TStructure["tools"]> extends MessageToolSet ? NonNullable<TStructure["tools"]> extends infer TTools extends MessageToolSet ? { [K in keyof TTools]: K extends string ? TTools[K] extends MessageToolDefinition ? {
+type $InferToolCalls<TStructure extends MessageStructure> = NonNullable<TStructure["tools"]> extends MessageToolSet ? NonNullable<TStructure["tools"]> extends (infer TTools extends MessageToolSet) ? { [K in keyof TTools]: K extends string ? TTools[K] extends MessageToolDefinition ? {
   readonly type?: "tool_call";
   id?: string;
   name: K;
   args: [unknown] extends [TTools[K]["input"]] ? Record<string, any> : TTools[K]["input"];
-} : never : never }[keyof TTools] : never : {
+} : never : never; }[keyof TTools] : never : {
   readonly type?: "tool_call";
   id?: string;
   name: string;
@@ -169,7 +168,7 @@ type $InferToolCalls<TStructure extends MessageStructure> = NonNullable<TStructu
  * // Resolves to: number | string[]
  * ```
  */
-type $InferToolOutputs<TStructure extends MessageStructure> = NonNullable<TStructure["tools"]> extends MessageToolSet ? NonNullable<TStructure["tools"]> extends infer TTools extends MessageToolSet ? { [K in keyof TTools]: TTools[K] extends MessageToolDefinition ? TTools[K]["output"] : never }[keyof TTools] : unknown : unknown;
+type $InferToolOutputs<TStructure extends MessageStructure> = NonNullable<TStructure["tools"]> extends MessageToolSet ? NonNullable<TStructure["tools"]> extends (infer TTools extends MessageToolSet) ? { [K in keyof TTools]: TTools[K] extends MessageToolDefinition ? TTools[K]["output"] : never; }[keyof TTools] : unknown : unknown;
 /**
  * Core interface that defines the structure of messages.
  *
@@ -246,12 +245,12 @@ interface MessageStructure<TTools extends MessageToolSet = MessageToolSet> {
    * Optional mapping of message types to their allowed content blocks.
    * Each message type can specify what content block types it supports (text, images, etc).
    */
-  readonly content?: Partial<{ [key in MessageType]: ContentBlock }>;
+  readonly content?: Partial<{ [key in MessageType]: ContentBlock; }>;
   /**
    * Optional mapping of message types to arbitrary property objects.
    * Allows attaching custom metadata or other information to specific message types.
    */
-  readonly properties?: Partial<{ [key in MessageType]: Record<string, unknown> }>;
+  readonly properties?: Partial<{ [key in MessageType]: Record<string, unknown>; }>;
 }
 /**
  * Normalizes an arbitrary type to a message output version or undefined.
@@ -285,7 +284,7 @@ type $NormalizeMessageOutputVersion<T> = Extract<T, MessageOutputVersion> | unde
  * type Result4 = $MergeOutputVersion<"v0", "v1">; // "v1"
  * ```
  */
-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;
+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;
 /**
  * Merges two content definition objects from message structures.
  *
@@ -323,7 +322,7 @@ type $MergeOutputVersion<T, U> = $NormalizeMessageOutputVersion<T> extends infer
  * // }
  * ```
  */
-type $MergeContentDefinition<T, U> = { [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 };
+type $MergeContentDefinition<T, U> = { [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; };
 /**
  * Merges two message structures A and B into a combined structure.
  * This is a type utility that handles merging of tools, content blocks, and properties
@@ -373,24 +372,34 @@ type $MergeMessageStructure<T extends MessageStructure, U extends MessageStructu
  */
 interface StandardMessageStructure extends MessageStructure {
   content: {
-    /** Text content for AI messages */ai: ContentBlock.Text; /** Text content for human messages */
-    human: ContentBlock.Text; /** Text content for system messages */
-    system: ContentBlock.Text; /** Text content for tool messages */
+    /** Text content for AI messages */
+    ai: ContentBlock.Text;
+    /** Text content for human messages */
+    human: ContentBlock.Text;
+    /** Text content for system messages */
+    system: ContentBlock.Text;
+    /** Text content for tool messages */
     tool: ContentBlock.Text;
   };
   properties: {
-    /** Properties specific to AI messages */ai: {
-      /** Metadata about the AI model response */response_metadata: ResponseMetadata; /** Usage statistics for the AI response */
+    /** Properties specific to AI messages */
+    ai: {
+      /** Metadata about the AI model response */
+      response_metadata: ResponseMetadata;
+      /** Usage statistics for the AI response */
       usage_metadata: UsageMetadata;
     };
     human: {
-      /** Metadata about the human message */response_metadata: Record<string, unknown>;
+      /** Metadata about the human message */
+      response_metadata: Record<string, unknown>;
     };
     system: {
-      /** Metadata about the system message */response_metadata: Record<string, unknown>;
+      /** Metadata about the system message */
+      response_metadata: Record<string, unknown>;
     };
     tool: {
-      /** Metadata about the tool message */response_metadata: Record<string, unknown>;
+      /** Metadata about the tool message */
+      response_metadata: Record<string, unknown>;
     };
   };
 }
@@ -431,7 +440,7 @@ type $NormalizedMessageStructure<T extends MessageStructure> = T extends Standar
  * // AIContent = ContentBlock.Text | ContentBlock.ToolCall
  * ```
  */
-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;
+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;
 /**
  * Infers the content type for a specific message type from a message structure.
  *
@@ -471,8 +480,8 @@ type $InferMessageContentBlocks<TStructure extends MessageStructure, TRole exten
  * // AIContentV1 = ContentBlock.Text | ContentBlock.Reasoning
  * ```
  */
-type $InferMessageContent<TStructure extends MessageStructure, TRole extends MessageType> = TRole extends "tool" ? $InferToolOutputs<TStructure> extends infer TOutput ? [TOutput] extends [never] ? string | Array<ContentBlock | ContentBlock.Text> : [unknown] extends [TOutput] ? // Fallback to default when TOutput is unknown (no specific tools defined)
-string | Array<ContentBlock | ContentBlock.Text> : TOutput | string | Array<ContentBlock | ContentBlock.Text> : string | Array<ContentBlock | ContentBlock.Text> : TStructure["outputVersion"] extends "v1" ? Array<$InferMessageContentBlocks<TStructure, TRole>> : string | Array<ContentBlock | ContentBlock.Text>;
+type $InferMessageContent<TStructure extends MessageStructure, TRole extends MessageType> = TRole extends "tool" ? $InferToolOutputs<TStructure> extends (infer TOutput) ? [TOutput] extends [never] ? string | Array<ContentBlock | ContentBlock.Text> : [unknown] extends [TOutput] // Fallback to default when TOutput is unknown (no specific tools defined)
+ ? string | Array<ContentBlock | ContentBlock.Text> : TOutput | string | Array<ContentBlock | ContentBlock.Text> : string | Array<ContentBlock | ContentBlock.Text> : TStructure["outputVersion"] extends "v1" ? Array<$InferMessageContentBlocks<TStructure, TRole>> : string | Array<ContentBlock | ContentBlock.Text>;
 /**
  * Infers the properties for a specific message type from a message structure.
  *
@@ -511,7 +520,7 @@ string | Array<ContentBlock | ContentBlock.Text> : TOutput | string | Array<Cont
  * // SystemProperties = Record<string, unknown> (fallback for undefined role)
  * ```
  */
-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;
+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;
 /**
  * Infers the type of a specific property for a message type from a message structure.
  *
@@ -577,7 +586,7 @@ type $InferMessageProperty<TStructure extends MessageStructure, TRole extends Me
  * // HumanResponseMetadata = Record<string, unknown> (fallback since not defined)
  * ```
  */
-type $InferResponseMetadata<TStructure extends MessageStructure, TRole extends MessageType> = $InferMessageProperty<TStructure, TRole, "response_metadata"> extends infer P ? [P] extends [never] ? Record<string, unknown> : P : never;
+type $InferResponseMetadata<TStructure extends MessageStructure, TRole extends MessageType> = $InferMessageProperty<TStructure, TRole, "response_metadata"> extends (infer P) ? [P] extends [never] ? Record<string, unknown> : P : never;
 /**
  * Represents a message object that organizes context for an LLM.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"message.d.ts","names":[],"sources":["../../src/messages/message.ts"],"mappings":"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"}
+{"version":3,"file":"message.d.ts","names":[],"sources":["../../src/messages/message.ts"],"mappings":"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"}

package/dist/messages/message.js.map

@@ -1 +1 @@
-{"version":3,"file":"message.js","names":[],"sources":["../../src/messages/message.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/**\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 =\n  | \"ai\"\n  | \"human\"\n  | \"tool\"\n  | \"system\"\n  | (string & NonNullable<unknown>);\n\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/**\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/**\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/**\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> =\n  TStructure[\"tools\"] extends MessageToolSet\n    ? {\n        [K in keyof TStructure[\"tools\"]]: K extends string\n          ? TStructure[\"tools\"][K] extends MessageToolDefinition\n            ? ContentBlock.Tools.ToolCall<K, TStructure[\"tools\"][K][\"input\"]>\n            : never\n          : never;\n      }[keyof TStructure[\"tools\"]]\n    : never;\n\n/**\n * Helper type to infer a union of ToolCall types from the tools defined in a MessageStructure.\n * This is used to type the `tool_calls` array in AIMessage based on the available tools.\n *\n * @template TStructure - A message structure type that may contain tool definitions\n *\n * @example\n * ```ts\n * // Given a message structure with tools:\n * interface MyStructure extends MessageStructure {\n *   tools: {\n *     calculator: MessageToolDefinition<{ a: number, b: number }, number>;\n *     search: MessageToolDefinition<{ query: string }, string[]>;\n *   }\n * }\n *\n * // The inferred tool calls would be:\n * type ToolCalls = $InferToolCalls<MyStructure>;\n * // Resolves to:\n * // | { type?: \"tool_call\"; id?: string; name: \"calculator\"; args: { a: number, b: number } }\n * // | { type?: \"tool_call\"; id?: string; name: \"search\"; args: { query: string } }\n * ```\n */\nexport type $InferToolCalls<TStructure extends MessageStructure> =\n  NonNullable<TStructure[\"tools\"]> extends MessageToolSet\n    ? NonNullable<TStructure[\"tools\"]> extends infer TTools extends\n        MessageToolSet\n      ? {\n          [K in keyof TTools]: K extends string\n            ? TTools[K] extends MessageToolDefinition\n              ? {\n                  readonly type?: \"tool_call\";\n                  id?: string;\n                  name: K;\n                  // Fallback to Record<string, any> when input is unknown\n                  args: [unknown] extends [TTools[K][\"input\"]]\n                    ? // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n                      Record<string, any>\n                    : TTools[K][\"input\"];\n                }\n              : never\n            : never;\n        }[keyof TTools]\n      : never\n    : {\n        readonly type?: \"tool_call\";\n        id?: string;\n        name: string;\n        // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n        args: Record<string, any>;\n      };\n\n/**\n * Helper type to infer a union of tool output types from the tools defined in a MessageStructure.\n * This is used to type the `content` of ToolMessage based on the available tool outputs.\n *\n * @template TStructure - A message structure type that may contain tool definitions\n *\n * @example\n * ```ts\n * // Given a message structure with tools:\n * interface MyStructure extends MessageStructure {\n *   tools: {\n *     calculator: MessageToolDefinition<{ a: number, b: number }, number>;\n *     search: MessageToolDefinition<{ query: string }, string[]>;\n *   }\n * }\n *\n * // The inferred tool outputs would be:\n * type ToolOutputs = $InferToolOutputs<MyStructure>;\n * // Resolves to: number | string[]\n * ```\n */\nexport type $InferToolOutputs<TStructure extends MessageStructure> =\n  NonNullable<TStructure[\"tools\"]> extends MessageToolSet\n    ? NonNullable<TStructure[\"tools\"]> extends infer TTools extends\n        MessageToolSet\n      ? {\n          [K in keyof TTools]: TTools[K] extends MessageToolDefinition\n            ? TTools[K][\"output\"]\n            : never;\n        }[keyof TTools]\n      : unknown\n    : unknown;\n\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  TTools extends MessageToolSet = MessageToolSet,\n> {\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?: TTools;\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/**\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> =\n  | Extract<T, MessageOutputVersion>\n  | undefined;\n\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> =\n  $NormalizeMessageOutputVersion<T> extends infer TV\n    ? $NormalizeMessageOutputVersion<U> extends infer UV\n      ? [TV, UV] extends [undefined, undefined]\n        ? \"v0\"\n        : [TV] extends [undefined]\n          ? Exclude<UV, undefined>\n          : [UV] extends [undefined]\n            ? Exclude<TV, undefined>\n            : UV\n      : never\n    : never;\n\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<\n    (K extends keyof T ? T[K] : never) | (K extends keyof U ? U[K] : never),\n    ContentBlock\n  > extends never\n    ? never\n    : K]: K extends keyof T\n    ? K extends keyof U\n      ? $MergeDiscriminatedUnion<\n          Extract<T[K], ContentBlock>,\n          Extract<U[K], ContentBlock>,\n          \"type\"\n        >\n      : Extract<T[K], ContentBlock>\n    : K extends keyof U\n      ? Extract<U[K], ContentBlock>\n      : never;\n};\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<\n  T extends MessageStructure,\n  U extends MessageStructure,\n> = {\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/**\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/**\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> =\n  T extends StandardMessageStructure\n    ? T\n    : $MergeMessageStructure<StandardMessageStructure, T>;\n\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<\n  TStructure extends MessageStructure,\n  TRole extends MessageType,\n> =\n  $NormalizedMessageStructure<TStructure> extends infer S\n    ? S extends MessageStructure\n      ? S[\"content\"] extends infer C\n        ? C extends Record<PropertyKey, ContentBlock>\n          ? TRole extends keyof C\n            ? [$MessageToolCallBlock<TStructure>] extends [never]\n              ? C[TRole]\n              : $MergeDiscriminatedUnion<\n                  NonNullable<C[TRole]>,\n                  $MessageToolCallBlock<TStructure>,\n                  \"type\"\n                >\n            : never\n          : never\n        : never\n      : never\n    : never;\n\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<\n  TStructure extends MessageStructure,\n  TRole extends MessageType,\n> = TRole extends \"tool\"\n  ? // For tool messages, infer content from tool output types if available\n    $InferToolOutputs<TStructure> extends infer TOutput\n    ? [TOutput] extends [never]\n      ? string | Array<ContentBlock | ContentBlock.Text>\n      : [unknown] extends [TOutput]\n        ? // Fallback to default when TOutput is unknown (no specific tools defined)\n            string | Array<ContentBlock | ContentBlock.Text>\n        : TOutput | string | Array<ContentBlock | ContentBlock.Text>\n    : string | Array<ContentBlock | ContentBlock.Text>\n  : TStructure[\"outputVersion\"] extends \"v1\"\n    ? Array<$InferMessageContentBlocks<TStructure, TRole>>\n    : string | Array<ContentBlock | ContentBlock.Text>;\n\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<\n  TStructure extends MessageStructure,\n  TRole extends MessageType,\n> =\n  $NormalizedMessageStructure<TStructure> extends infer S\n    ? S extends MessageStructure\n      ? S[\"properties\"] extends (infer P) | undefined\n        ? P extends Record<PropertyKey, unknown>\n          ? TRole extends keyof P\n            ? Omit<P[TRole], \"content\" | \"type\">\n            : Record<string, unknown>\n          : Record<string, unknown>\n        : Record<string, unknown>\n      : never\n    : never;\n\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<\n  TStructure extends MessageStructure,\n  TRole extends MessageType,\n  K extends string,\n> = K extends keyof $InferMessageProperties<TStructure, TRole>\n  ? $InferMessageProperties<TStructure, TRole>[K]\n  : never;\n\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<\n  TStructure extends MessageStructure,\n  TRole extends MessageType,\n> =\n  $InferMessageProperty<TStructure, TRole, \"response_metadata\"> extends infer P\n    ? [P] extends [never]\n      ? Record<string, unknown>\n      : P\n    : never;\n\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<\n  TStructure extends MessageStructure = StandardMessageStructure,\n  TRole extends MessageType = MessageType,\n> {\n  /** The message type/role */\n  readonly type: TRole;\n  /** Unique identifier for this message */\n  id?: string;\n  /**\n   * An optional name for the message participant.\n   *\n   * This property is primarily used to:\n   *\n   * 1. **Identify agent roles in multi-agent systems**: When multiple agents\n   *    collaborate, setting `name` helps distinguish which agent produced a\n   *    message, preventing confusion about who said what.\n   *\n   * 2. **Pass participant names to model providers**: Some providers (notably\n   *    OpenAI, e.g. see {@link https://platform.openai.com/docs/api-reference/chat/create | OpenAI Chat Completions API})\n   *    use this field to differentiate between participants with the\n   *    same role. For example, when using OpenAI's Chat Completions API, the\n   *    `name` is included in the message payload sent to the model.\n   *\n   * @example\n   * ```typescript\n   * // Setting name on an AIMessage to identify the agent\n   * const message = new AIMessage({\n   *   content: \"I'll handle the calendar scheduling.\",\n   *   name: \"calendar_agent\"\n   * });\n   *\n   * // In a multi-agent system, this helps track message origins\n   * const researcherMessage = new AIMessage({\n   *   content: \"Here are the findings...\",\n   *   name: \"researcher\"\n   * });\n   * const writerMessage = new AIMessage({\n   *   content: \"I've drafted the report.\",\n   *   name: \"writer\"\n   * });\n   * ```\n   */\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/**\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 function isMessage(message: unknown): message is Message {\n  return (\n    typeof message === \"object\" &&\n    message !== null &&\n    \"type\" in message &&\n    \"content\" in message &&\n    (typeof message.content === \"string\" || Array.isArray(message.content))\n  );\n}\n"],"mappings":";;;;;;;AAk1BA,SAAgB,UAAU,SAAsC;AAC9D,QACE,OAAO,YAAY,YACnB,YAAY,QACZ,UAAU,WACV,aAAa,YACZ,OAAO,QAAQ,YAAY,YAAY,MAAM,QAAQ,QAAQ,QAAQ"}
+{"version":3,"file":"message.js","names":[],"sources":["../../src/messages/message.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/**\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 =\n  | \"ai\"\n  | \"human\"\n  | \"tool\"\n  | \"system\"\n  | (string & NonNullable<unknown>);\n\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/**\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/**\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/**\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> =\n  TStructure[\"tools\"] extends MessageToolSet\n    ? {\n        [K in keyof TStructure[\"tools\"]]: K extends string\n          ? TStructure[\"tools\"][K] extends MessageToolDefinition\n            ? ContentBlock.Tools.ToolCall<K, TStructure[\"tools\"][K][\"input\"]>\n            : never\n          : never;\n      }[keyof TStructure[\"tools\"]]\n    : never;\n\n/**\n * Helper type to infer a union of ToolCall types from the tools defined in a MessageStructure.\n * This is used to type the `tool_calls` array in AIMessage based on the available tools.\n *\n * @template TStructure - A message structure type that may contain tool definitions\n *\n * @example\n * ```ts\n * // Given a message structure with tools:\n * interface MyStructure extends MessageStructure {\n *   tools: {\n *     calculator: MessageToolDefinition<{ a: number, b: number }, number>;\n *     search: MessageToolDefinition<{ query: string }, string[]>;\n *   }\n * }\n *\n * // The inferred tool calls would be:\n * type ToolCalls = $InferToolCalls<MyStructure>;\n * // Resolves to:\n * // | { type?: \"tool_call\"; id?: string; name: \"calculator\"; args: { a: number, b: number } }\n * // | { type?: \"tool_call\"; id?: string; name: \"search\"; args: { query: string } }\n * ```\n */\nexport type $InferToolCalls<TStructure extends MessageStructure> =\n  NonNullable<TStructure[\"tools\"]> extends MessageToolSet\n    ? NonNullable<TStructure[\"tools\"]> extends infer TTools extends\n        MessageToolSet\n      ? {\n          [K in keyof TTools]: K extends string\n            ? TTools[K] extends MessageToolDefinition\n              ? {\n                  readonly type?: \"tool_call\";\n                  id?: string;\n                  name: K;\n                  // Fallback to Record<string, any> when input is unknown\n                  args: [unknown] extends [TTools[K][\"input\"]]\n                    ? // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n                      Record<string, any>\n                    : TTools[K][\"input\"];\n                }\n              : never\n            : never;\n        }[keyof TTools]\n      : never\n    : {\n        readonly type?: \"tool_call\";\n        id?: string;\n        name: string;\n        // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n        args: Record<string, any>;\n      };\n\n/**\n * Helper type to infer a union of tool output types from the tools defined in a MessageStructure.\n * This is used to type the `content` of ToolMessage based on the available tool outputs.\n *\n * @template TStructure - A message structure type that may contain tool definitions\n *\n * @example\n * ```ts\n * // Given a message structure with tools:\n * interface MyStructure extends MessageStructure {\n *   tools: {\n *     calculator: MessageToolDefinition<{ a: number, b: number }, number>;\n *     search: MessageToolDefinition<{ query: string }, string[]>;\n *   }\n * }\n *\n * // The inferred tool outputs would be:\n * type ToolOutputs = $InferToolOutputs<MyStructure>;\n * // Resolves to: number | string[]\n * ```\n */\nexport type $InferToolOutputs<TStructure extends MessageStructure> =\n  NonNullable<TStructure[\"tools\"]> extends MessageToolSet\n    ? NonNullable<TStructure[\"tools\"]> extends infer TTools extends\n        MessageToolSet\n      ? {\n          [K in keyof TTools]: TTools[K] extends MessageToolDefinition\n            ? TTools[K][\"output\"]\n            : never;\n        }[keyof TTools]\n      : unknown\n    : unknown;\n\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  TTools extends MessageToolSet = MessageToolSet,\n> {\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?: TTools;\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/**\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> =\n  | Extract<T, MessageOutputVersion>\n  | undefined;\n\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> =\n  $NormalizeMessageOutputVersion<T> extends infer TV\n    ? $NormalizeMessageOutputVersion<U> extends infer UV\n      ? [TV, UV] extends [undefined, undefined]\n        ? \"v0\"\n        : [TV] extends [undefined]\n          ? Exclude<UV, undefined>\n          : [UV] extends [undefined]\n            ? Exclude<TV, undefined>\n            : UV\n      : never\n    : never;\n\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<\n    (K extends keyof T ? T[K] : never) | (K extends keyof U ? U[K] : never),\n    ContentBlock\n  > extends never\n    ? never\n    : K]: K extends keyof T\n    ? K extends keyof U\n      ? $MergeDiscriminatedUnion<\n          Extract<T[K], ContentBlock>,\n          Extract<U[K], ContentBlock>,\n          \"type\"\n        >\n      : Extract<T[K], ContentBlock>\n    : K extends keyof U\n      ? Extract<U[K], ContentBlock>\n      : never;\n};\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<\n  T extends MessageStructure,\n  U extends MessageStructure,\n> = {\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/**\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/**\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> =\n  T extends StandardMessageStructure\n    ? T\n    : $MergeMessageStructure<StandardMessageStructure, T>;\n\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<\n  TStructure extends MessageStructure,\n  TRole extends MessageType,\n> =\n  $NormalizedMessageStructure<TStructure> extends infer S\n    ? S extends MessageStructure\n      ? S[\"content\"] extends infer C\n        ? C extends Record<PropertyKey, ContentBlock>\n          ? TRole extends keyof C\n            ? [$MessageToolCallBlock<TStructure>] extends [never]\n              ? C[TRole]\n              : $MergeDiscriminatedUnion<\n                  NonNullable<C[TRole]>,\n                  $MessageToolCallBlock<TStructure>,\n                  \"type\"\n                >\n            : never\n          : never\n        : never\n      : never\n    : never;\n\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<\n  TStructure extends MessageStructure,\n  TRole extends MessageType,\n> = TRole extends \"tool\"\n  ? // For tool messages, infer content from tool output types if available\n    $InferToolOutputs<TStructure> extends infer TOutput\n    ? [TOutput] extends [never]\n      ? string | Array<ContentBlock | ContentBlock.Text>\n      : [unknown] extends [TOutput]\n        ? // Fallback to default when TOutput is unknown (no specific tools defined)\n            string | Array<ContentBlock | ContentBlock.Text>\n        : TOutput | string | Array<ContentBlock | ContentBlock.Text>\n    : string | Array<ContentBlock | ContentBlock.Text>\n  : TStructure[\"outputVersion\"] extends \"v1\"\n    ? Array<$InferMessageContentBlocks<TStructure, TRole>>\n    : string | Array<ContentBlock | ContentBlock.Text>;\n\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<\n  TStructure extends MessageStructure,\n  TRole extends MessageType,\n> =\n  $NormalizedMessageStructure<TStructure> extends infer S\n    ? S extends MessageStructure\n      ? S[\"properties\"] extends (infer P) | undefined\n        ? P extends Record<PropertyKey, unknown>\n          ? TRole extends keyof P\n            ? Omit<P[TRole], \"content\" | \"type\">\n            : Record<string, unknown>\n          : Record<string, unknown>\n        : Record<string, unknown>\n      : never\n    : never;\n\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<\n  TStructure extends MessageStructure,\n  TRole extends MessageType,\n  K extends string,\n> = K extends keyof $InferMessageProperties<TStructure, TRole>\n  ? $InferMessageProperties<TStructure, TRole>[K]\n  : never;\n\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<\n  TStructure extends MessageStructure,\n  TRole extends MessageType,\n> =\n  $InferMessageProperty<TStructure, TRole, \"response_metadata\"> extends infer P\n    ? [P] extends [never]\n      ? Record<string, unknown>\n      : P\n    : never;\n\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<\n  TStructure extends MessageStructure = StandardMessageStructure,\n  TRole extends MessageType = MessageType,\n> {\n  /** The message type/role */\n  readonly type: TRole;\n  /** Unique identifier for this message */\n  id?: string;\n  /**\n   * An optional name for the message participant.\n   *\n   * This property is primarily used to:\n   *\n   * 1. **Identify agent roles in multi-agent systems**: When multiple agents\n   *    collaborate, setting `name` helps distinguish which agent produced a\n   *    message, preventing confusion about who said what.\n   *\n   * 2. **Pass participant names to model providers**: Some providers (notably\n   *    OpenAI, e.g. see {@link https://platform.openai.com/docs/api-reference/chat/create | OpenAI Chat Completions API})\n   *    use this field to differentiate between participants with the\n   *    same role. For example, when using OpenAI's Chat Completions API, the\n   *    `name` is included in the message payload sent to the model.\n   *\n   * @example\n   * ```typescript\n   * // Setting name on an AIMessage to identify the agent\n   * const message = new AIMessage({\n   *   content: \"I'll handle the calendar scheduling.\",\n   *   name: \"calendar_agent\"\n   * });\n   *\n   * // In a multi-agent system, this helps track message origins\n   * const researcherMessage = new AIMessage({\n   *   content: \"Here are the findings...\",\n   *   name: \"researcher\"\n   * });\n   * const writerMessage = new AIMessage({\n   *   content: \"I've drafted the report.\",\n   *   name: \"writer\"\n   * });\n   * ```\n   */\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/**\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 function isMessage(message: unknown): message is Message {\n  return (\n    typeof message === \"object\" &&\n    message !== null &&\n    \"type\" in message &&\n    \"content\" in message &&\n    (typeof message.content === \"string\" || Array.isArray(message.content))\n  );\n}\n"],"mappings":";;;;;;;AAk1BA,SAAgB,UAAU,SAAsC;CAC9D,OACE,OAAO,YAAY,YACnB,YAAY,QACZ,UAAU,WACV,aAAa,YACZ,OAAO,QAAQ,YAAY,YAAY,MAAM,QAAQ,QAAQ,OAAO;AAEzE"}

package/dist/messages/metadata.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"metadata.cjs","names":["_mergeDicts"],"sources":["../../src/messages/metadata.ts"],"sourcesContent":["import { _mergeDicts } from \"./base.js\";\nimport type { MessageOutputVersion } from \"./message.js\";\n\nexport type ResponseMetadata = {\n  model_provider?: string;\n  model_name?: string;\n  output_version?: MessageOutputVersion;\n  [key: string]: unknown;\n};\n\nexport function mergeResponseMetadata(\n  a?: ResponseMetadata,\n  b?: ResponseMetadata\n): ResponseMetadata {\n  const output: ResponseMetadata = _mergeDicts(a, b) ?? {};\n  return output;\n}\n\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  /**\n   * Image (non-video) tokens.\n   */\n  image?: number;\n\n  /**\n   * Audio tokens.\n   */\n  audio?: number;\n\n  /**\n   * Video tokens.\n   */\n  video?: number;\n\n  /**\n   * Document tokens.\n   * e.g. PDF\n   */\n  document?: number;\n};\n\nfunction mergeModalitiesTokenDetails(\n  a?: ModalitiesTokenDetails,\n  b?: ModalitiesTokenDetails\n): ModalitiesTokenDetails {\n  const output: ModalitiesTokenDetails = {};\n  if (a?.audio !== undefined || b?.audio !== undefined) {\n    output.audio = (a?.audio ?? 0) + (b?.audio ?? 0);\n  }\n  if (a?.image !== undefined || b?.image !== undefined) {\n    output.image = (a?.image ?? 0) + (b?.image ?? 0);\n  }\n  if (a?.video !== undefined || b?.video !== undefined) {\n    output.video = (a?.video ?? 0) + (b?.video ?? 0);\n  }\n  if (a?.document !== undefined || b?.document !== undefined) {\n    output.document = (a?.document ?? 0) + (b?.document ?? 0);\n  }\n  if (a?.text !== undefined || b?.text !== undefined) {\n    output.text = (a?.text ?? 0) + (b?.text ?? 0);\n  }\n  return output;\n}\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  /**\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\nfunction mergeInputTokenDetails(\n  a?: InputTokenDetails,\n  b?: InputTokenDetails\n): InputTokenDetails {\n  const output: InputTokenDetails = {\n    ...mergeModalitiesTokenDetails(a, b),\n  };\n  if (a?.cache_read !== undefined || b?.cache_read !== undefined) {\n    output.cache_read = (a?.cache_read ?? 0) + (b?.cache_read ?? 0);\n  }\n  if (a?.cache_creation !== undefined || b?.cache_creation !== undefined) {\n    output.cache_creation = (a?.cache_creation ?? 0) + (b?.cache_creation ?? 0);\n  }\n  return output;\n}\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\nfunction mergeOutputTokenDetails(\n  a?: OutputTokenDetails,\n  b?: OutputTokenDetails\n): OutputTokenDetails {\n  const output: OutputTokenDetails = {\n    ...mergeModalitiesTokenDetails(a, b),\n  };\n  if (a?.reasoning !== undefined || b?.reasoning !== undefined) {\n    output.reasoning = (a?.reasoning ?? 0) + (b?.reasoning ?? 0);\n  }\n  return output;\n}\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  /**\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  /**\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};\n\nexport function mergeUsageMetadata(\n  a?: UsageMetadata,\n  b?: UsageMetadata\n): UsageMetadata {\n  return {\n    input_tokens: (a?.input_tokens ?? 0) + (b?.input_tokens ?? 0),\n    output_tokens: (a?.output_tokens ?? 0) + (b?.output_tokens ?? 0),\n    total_tokens: (a?.total_tokens ?? 0) + (b?.total_tokens ?? 0),\n    input_token_details: mergeInputTokenDetails(\n      a?.input_token_details,\n      b?.input_token_details\n    ),\n    output_token_details: mergeOutputTokenDetails(\n      a?.output_token_details,\n      b?.output_token_details\n    ),\n  };\n}\n"],"mappings":";;AAUA,SAAgB,sBACd,GACA,GACkB;AAElB,QADiCA,aAAAA,YAAY,GAAG,EAAE,IAAI,EAAE;;AAiC1D,SAAS,4BACP,GACA,GACwB;CACxB,MAAM,SAAiC,EAAE;AACzC,KAAI,GAAG,UAAU,KAAA,KAAa,GAAG,UAAU,KAAA,EACzC,QAAO,SAAS,GAAG,SAAS,MAAM,GAAG,SAAS;AAEhD,KAAI,GAAG,UAAU,KAAA,KAAa,GAAG,UAAU,KAAA,EACzC,QAAO,SAAS,GAAG,SAAS,MAAM,GAAG,SAAS;AAEhD,KAAI,GAAG,UAAU,KAAA,KAAa,GAAG,UAAU,KAAA,EACzC,QAAO,SAAS,GAAG,SAAS,MAAM,GAAG,SAAS;AAEhD,KAAI,GAAG,aAAa,KAAA,KAAa,GAAG,aAAa,KAAA,EAC/C,QAAO,YAAY,GAAG,YAAY,MAAM,GAAG,YAAY;AAEzD,KAAI,GAAG,SAAS,KAAA,KAAa,GAAG,SAAS,KAAA,EACvC,QAAO,QAAQ,GAAG,QAAQ,MAAM,GAAG,QAAQ;AAE7C,QAAO;;AAyBT,SAAS,uBACP,GACA,GACmB;CACnB,MAAM,SAA4B,EAChC,GAAG,4BAA4B,GAAG,EAAE,EACrC;AACD,KAAI,GAAG,eAAe,KAAA,KAAa,GAAG,eAAe,KAAA,EACnD,QAAO,cAAc,GAAG,cAAc,MAAM,GAAG,cAAc;AAE/D,KAAI,GAAG,mBAAmB,KAAA,KAAa,GAAG,mBAAmB,KAAA,EAC3D,QAAO,kBAAkB,GAAG,kBAAkB,MAAM,GAAG,kBAAkB;AAE3E,QAAO;;AAkBT,SAAS,wBACP,GACA,GACoB;CACpB,MAAM,SAA6B,EACjC,GAAG,4BAA4B,GAAG,EAAE,EACrC;AACD,KAAI,GAAG,cAAc,KAAA,KAAa,GAAG,cAAc,KAAA,EACjD,QAAO,aAAa,GAAG,aAAa,MAAM,GAAG,aAAa;AAE5D,QAAO;;AAmCT,SAAgB,mBACd,GACA,GACe;AACf,QAAO;EACL,eAAe,GAAG,gBAAgB,MAAM,GAAG,gBAAgB;EAC3D,gBAAgB,GAAG,iBAAiB,MAAM,GAAG,iBAAiB;EAC9D,eAAe,GAAG,gBAAgB,MAAM,GAAG,gBAAgB;EAC3D,qBAAqB,uBACnB,GAAG,qBACH,GAAG,oBACJ;EACD,sBAAsB,wBACpB,GAAG,sBACH,GAAG,qBACJ;EACF"}
+{"version":3,"file":"metadata.cjs","names":["_mergeDicts"],"sources":["../../src/messages/metadata.ts"],"sourcesContent":["import { _mergeDicts } from \"./base.js\";\nimport type { MessageOutputVersion } from \"./message.js\";\n\nexport type ResponseMetadata = {\n  model_provider?: string;\n  model_name?: string;\n  output_version?: MessageOutputVersion;\n  [key: string]: unknown;\n};\n\nexport function mergeResponseMetadata(\n  a?: ResponseMetadata,\n  b?: ResponseMetadata\n): ResponseMetadata {\n  const output: ResponseMetadata = _mergeDicts(a, b) ?? {};\n  return output;\n}\n\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  /**\n   * Image (non-video) tokens.\n   */\n  image?: number;\n\n  /**\n   * Audio tokens.\n   */\n  audio?: number;\n\n  /**\n   * Video tokens.\n   */\n  video?: number;\n\n  /**\n   * Document tokens.\n   * e.g. PDF\n   */\n  document?: number;\n};\n\nfunction mergeModalitiesTokenDetails(\n  a?: ModalitiesTokenDetails,\n  b?: ModalitiesTokenDetails\n): ModalitiesTokenDetails {\n  const output: ModalitiesTokenDetails = {};\n  if (a?.audio !== undefined || b?.audio !== undefined) {\n    output.audio = (a?.audio ?? 0) + (b?.audio ?? 0);\n  }\n  if (a?.image !== undefined || b?.image !== undefined) {\n    output.image = (a?.image ?? 0) + (b?.image ?? 0);\n  }\n  if (a?.video !== undefined || b?.video !== undefined) {\n    output.video = (a?.video ?? 0) + (b?.video ?? 0);\n  }\n  if (a?.document !== undefined || b?.document !== undefined) {\n    output.document = (a?.document ?? 0) + (b?.document ?? 0);\n  }\n  if (a?.text !== undefined || b?.text !== undefined) {\n    output.text = (a?.text ?? 0) + (b?.text ?? 0);\n  }\n  return output;\n}\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  /**\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\nfunction mergeInputTokenDetails(\n  a?: InputTokenDetails,\n  b?: InputTokenDetails\n): InputTokenDetails {\n  const output: InputTokenDetails = {\n    ...mergeModalitiesTokenDetails(a, b),\n  };\n  if (a?.cache_read !== undefined || b?.cache_read !== undefined) {\n    output.cache_read = (a?.cache_read ?? 0) + (b?.cache_read ?? 0);\n  }\n  if (a?.cache_creation !== undefined || b?.cache_creation !== undefined) {\n    output.cache_creation = (a?.cache_creation ?? 0) + (b?.cache_creation ?? 0);\n  }\n  return output;\n}\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\nfunction mergeOutputTokenDetails(\n  a?: OutputTokenDetails,\n  b?: OutputTokenDetails\n): OutputTokenDetails {\n  const output: OutputTokenDetails = {\n    ...mergeModalitiesTokenDetails(a, b),\n  };\n  if (a?.reasoning !== undefined || b?.reasoning !== undefined) {\n    output.reasoning = (a?.reasoning ?? 0) + (b?.reasoning ?? 0);\n  }\n  return output;\n}\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  /**\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  /**\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};\n\nexport function mergeUsageMetadata(\n  a?: UsageMetadata,\n  b?: UsageMetadata\n): UsageMetadata {\n  return {\n    input_tokens: (a?.input_tokens ?? 0) + (b?.input_tokens ?? 0),\n    output_tokens: (a?.output_tokens ?? 0) + (b?.output_tokens ?? 0),\n    total_tokens: (a?.total_tokens ?? 0) + (b?.total_tokens ?? 0),\n    input_token_details: mergeInputTokenDetails(\n      a?.input_token_details,\n      b?.input_token_details\n    ),\n    output_token_details: mergeOutputTokenDetails(\n      a?.output_token_details,\n      b?.output_token_details\n    ),\n  };\n}\n"],"mappings":";;AAUA,SAAgB,sBACd,GACA,GACkB;CAElB,OADiCA,aAAAA,YAAY,GAAG,CAAC,KAAK,CAAC;AAEzD;AA+BA,SAAS,4BACP,GACA,GACwB;CACxB,MAAM,SAAiC,CAAC;CACxC,IAAI,GAAG,UAAU,KAAA,KAAa,GAAG,UAAU,KAAA,GACzC,OAAO,SAAS,GAAG,SAAS,MAAM,GAAG,SAAS;CAEhD,IAAI,GAAG,UAAU,KAAA,KAAa,GAAG,UAAU,KAAA,GACzC,OAAO,SAAS,GAAG,SAAS,MAAM,GAAG,SAAS;CAEhD,IAAI,GAAG,UAAU,KAAA,KAAa,GAAG,UAAU,KAAA,GACzC,OAAO,SAAS,GAAG,SAAS,MAAM,GAAG,SAAS;CAEhD,IAAI,GAAG,aAAa,KAAA,KAAa,GAAG,aAAa,KAAA,GAC/C,OAAO,YAAY,GAAG,YAAY,MAAM,GAAG,YAAY;CAEzD,IAAI,GAAG,SAAS,KAAA,KAAa,GAAG,SAAS,KAAA,GACvC,OAAO,QAAQ,GAAG,QAAQ,MAAM,GAAG,QAAQ;CAE7C,OAAO;AACT;AAwBA,SAAS,uBACP,GACA,GACmB;CACnB,MAAM,SAA4B,EAChC,GAAG,4BAA4B,GAAG,CAAC,EACrC;CACA,IAAI,GAAG,eAAe,KAAA,KAAa,GAAG,eAAe,KAAA,GACnD,OAAO,cAAc,GAAG,cAAc,MAAM,GAAG,cAAc;CAE/D,IAAI,GAAG,mBAAmB,KAAA,KAAa,GAAG,mBAAmB,KAAA,GAC3D,OAAO,kBAAkB,GAAG,kBAAkB,MAAM,GAAG,kBAAkB;CAE3E,OAAO;AACT;AAiBA,SAAS,wBACP,GACA,GACoB;CACpB,MAAM,SAA6B,EACjC,GAAG,4BAA4B,GAAG,CAAC,EACrC;CACA,IAAI,GAAG,cAAc,KAAA,KAAa,GAAG,cAAc,KAAA,GACjD,OAAO,aAAa,GAAG,aAAa,MAAM,GAAG,aAAa;CAE5D,OAAO;AACT;AAkCA,SAAgB,mBACd,GACA,GACe;CACf,OAAO;EACL,eAAe,GAAG,gBAAgB,MAAM,GAAG,gBAAgB;EAC3D,gBAAgB,GAAG,iBAAiB,MAAM,GAAG,iBAAiB;EAC9D,eAAe,GAAG,gBAAgB,MAAM,GAAG,gBAAgB;EAC3D,qBAAqB,uBACnB,GAAG,qBACH,GAAG,mBACL;EACA,sBAAsB,wBACpB,GAAG,sBACH,GAAG,oBACL;CACF;AACF"}

package/dist/messages/metadata.d.cts

@@ -1,5 +1,4 @@
 import { MessageOutputVersion } from "./message.cjs";
-
 //#region src/messages/metadata.d.ts
 type ResponseMetadata = {
   model_provider?: string;

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

@@ -1 +1 @@
-{"version":3,"file":"metadata.d.cts","names":[],"sources":["../../src/messages/metadata.ts"],"mappings":";;;KAGY,gBAAA;EACV,cAAA;EACA,UAAA;EACA,cAAA,GAAiB,oBAAA;EAAA,CAChB,GAAA;AAAA;AAAA,iBAGa,qBAAA,CACd,CAAA,GAAI,gBAAA,EACJ,CAAA,GAAI,gBAAA,GACH,gBAAA;AAAA,KAKS,sBAAA;EAZV;;;;EAiBA,IAAA;EAbc;;;EAkBd,KAAA;EAhBI;;;EAqBJ,KAAA;EAtBI;;;EA2BJ,KAAA;EAzBC;;;AAKH;EA0BE,QAAA;AAAA;;;;;;KA+BU,iBAAA,GAAoB,sBAAA;EA/BtB;;AA+BV;;;;EAOE,UAAA;EAAA;;;;AA+BF;EAxBE,cAAA;AAAA;;;AAkDF;;;KA1BY,kBAAA,GAAqB,sBAAA;EA8B/B;;;;;;EAvBA,SAAA;AAAA;;AAgDF;;KA7BY,aAAA;EA8BN;;;EA1BJ,YAAA;EA4Bc;;;EAxBd,aAAA;EAuBA;;;EAnBA,YAAA;;;;;;EAOA,mBAAA,GAAsB,iBAAA;;;;;;EAOtB,oBAAA,GAAuB,kBAAA;AAAA;AAAA,iBAGT,kBAAA,CACd,CAAA,GAAI,aAAA,EACJ,CAAA,GAAI,aAAA,GACH,aAAA"}
+{"version":3,"file":"metadata.d.cts","names":[],"sources":["../../src/messages/metadata.ts"],"mappings":";;KAGY;EACV;EACA;EACA,iBAAiB;GAChB;;iBAGa,sBACd,IAAI,kBACJ,IAAI,mBACH;KAKS;;;;;EAKV;;;;EAKA;;;;EAKA;;;;EAKA;;;;;EAMA;;;;;;;KA+BU,oBAAoB;;;;;;;EAO9B;;;;;;EAOA;;;;;;;KAwBU,qBAAqB;;;;;;;EAO/B;;;;;KAmBU;;;;EAIV;;;;EAIA;;;;EAIA;;;;;;EAOA,sBAAsB;;;;;;EAOtB,uBAAuB;;iBAGT,mBACd,IAAI,eACJ,IAAI,gBACH"}

package/dist/messages/metadata.d.ts

@@ -1,5 +1,4 @@
 import { MessageOutputVersion } from "./message.js";
-
 //#region src/messages/metadata.d.ts
 type ResponseMetadata = {
   model_provider?: string;

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

@@ -1 +1 @@
-{"version":3,"file":"metadata.d.ts","names":[],"sources":["../../src/messages/metadata.ts"],"mappings":";;;KAGY,gBAAA;EACV,cAAA;EACA,UAAA;EACA,cAAA,GAAiB,oBAAA;EAAA,CAChB,GAAA;AAAA;AAAA,iBAGa,qBAAA,CACd,CAAA,GAAI,gBAAA,EACJ,CAAA,GAAI,gBAAA,GACH,gBAAA;AAAA,KAKS,sBAAA;EAZV;;;;EAiBA,IAAA;EAbc;;;EAkBd,KAAA;EAhBI;;;EAqBJ,KAAA;EAtBI;;;EA2BJ,KAAA;EAzBC;;;AAKH;EA0BE,QAAA;AAAA;;;;;;KA+BU,iBAAA,GAAoB,sBAAA;EA/BtB;;AA+BV;;;;EAOE,UAAA;EAAA;;;;AA+BF;EAxBE,cAAA;AAAA;;;AAkDF;;;KA1BY,kBAAA,GAAqB,sBAAA;EA8B/B;;;;;;EAvBA,SAAA;AAAA;;AAgDF;;KA7BY,aAAA;EA8BN;;;EA1BJ,YAAA;EA4Bc;;;EAxBd,aAAA;EAuBA;;;EAnBA,YAAA;;;;;;EAOA,mBAAA,GAAsB,iBAAA;;;;;;EAOtB,oBAAA,GAAuB,kBAAA;AAAA;AAAA,iBAGT,kBAAA,CACd,CAAA,GAAI,aAAA,EACJ,CAAA,GAAI,aAAA,GACH,aAAA"}
+{"version":3,"file":"metadata.d.ts","names":[],"sources":["../../src/messages/metadata.ts"],"mappings":";;KAGY;EACV;EACA;EACA,iBAAiB;GAChB;;iBAGa,sBACd,IAAI,kBACJ,IAAI,mBACH;KAKS;;;;;EAKV;;;;EAKA;;;;EAKA;;;;EAKA;;;;;EAMA;;;;;;;KA+BU,oBAAoB;;;;;;;EAO9B;;;;;;EAOA;;;;;;;KAwBU,qBAAqB;;;;;;;EAO/B;;;;;KAmBU;;;;EAIV;;;;EAIA;;;;EAIA;;;;;;EAOA,sBAAsB;;;;;;EAOtB,uBAAuB;;iBAGT,mBACd,IAAI,eACJ,IAAI,gBACH"}

package/dist/messages/metadata.js.map

@@ -1 +1 @@
-{"version":3,"file":"metadata.js","names":[],"sources":["../../src/messages/metadata.ts"],"sourcesContent":["import { _mergeDicts } from \"./base.js\";\nimport type { MessageOutputVersion } from \"./message.js\";\n\nexport type ResponseMetadata = {\n  model_provider?: string;\n  model_name?: string;\n  output_version?: MessageOutputVersion;\n  [key: string]: unknown;\n};\n\nexport function mergeResponseMetadata(\n  a?: ResponseMetadata,\n  b?: ResponseMetadata\n): ResponseMetadata {\n  const output: ResponseMetadata = _mergeDicts(a, b) ?? {};\n  return output;\n}\n\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  /**\n   * Image (non-video) tokens.\n   */\n  image?: number;\n\n  /**\n   * Audio tokens.\n   */\n  audio?: number;\n\n  /**\n   * Video tokens.\n   */\n  video?: number;\n\n  /**\n   * Document tokens.\n   * e.g. PDF\n   */\n  document?: number;\n};\n\nfunction mergeModalitiesTokenDetails(\n  a?: ModalitiesTokenDetails,\n  b?: ModalitiesTokenDetails\n): ModalitiesTokenDetails {\n  const output: ModalitiesTokenDetails = {};\n  if (a?.audio !== undefined || b?.audio !== undefined) {\n    output.audio = (a?.audio ?? 0) + (b?.audio ?? 0);\n  }\n  if (a?.image !== undefined || b?.image !== undefined) {\n    output.image = (a?.image ?? 0) + (b?.image ?? 0);\n  }\n  if (a?.video !== undefined || b?.video !== undefined) {\n    output.video = (a?.video ?? 0) + (b?.video ?? 0);\n  }\n  if (a?.document !== undefined || b?.document !== undefined) {\n    output.document = (a?.document ?? 0) + (b?.document ?? 0);\n  }\n  if (a?.text !== undefined || b?.text !== undefined) {\n    output.text = (a?.text ?? 0) + (b?.text ?? 0);\n  }\n  return output;\n}\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  /**\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\nfunction mergeInputTokenDetails(\n  a?: InputTokenDetails,\n  b?: InputTokenDetails\n): InputTokenDetails {\n  const output: InputTokenDetails = {\n    ...mergeModalitiesTokenDetails(a, b),\n  };\n  if (a?.cache_read !== undefined || b?.cache_read !== undefined) {\n    output.cache_read = (a?.cache_read ?? 0) + (b?.cache_read ?? 0);\n  }\n  if (a?.cache_creation !== undefined || b?.cache_creation !== undefined) {\n    output.cache_creation = (a?.cache_creation ?? 0) + (b?.cache_creation ?? 0);\n  }\n  return output;\n}\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\nfunction mergeOutputTokenDetails(\n  a?: OutputTokenDetails,\n  b?: OutputTokenDetails\n): OutputTokenDetails {\n  const output: OutputTokenDetails = {\n    ...mergeModalitiesTokenDetails(a, b),\n  };\n  if (a?.reasoning !== undefined || b?.reasoning !== undefined) {\n    output.reasoning = (a?.reasoning ?? 0) + (b?.reasoning ?? 0);\n  }\n  return output;\n}\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  /**\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  /**\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};\n\nexport function mergeUsageMetadata(\n  a?: UsageMetadata,\n  b?: UsageMetadata\n): UsageMetadata {\n  return {\n    input_tokens: (a?.input_tokens ?? 0) + (b?.input_tokens ?? 0),\n    output_tokens: (a?.output_tokens ?? 0) + (b?.output_tokens ?? 0),\n    total_tokens: (a?.total_tokens ?? 0) + (b?.total_tokens ?? 0),\n    input_token_details: mergeInputTokenDetails(\n      a?.input_token_details,\n      b?.input_token_details\n    ),\n    output_token_details: mergeOutputTokenDetails(\n      a?.output_token_details,\n      b?.output_token_details\n    ),\n  };\n}\n"],"mappings":";;AAUA,SAAgB,sBACd,GACA,GACkB;AAElB,QADiC,YAAY,GAAG,EAAE,IAAI,EAAE;;AAiC1D,SAAS,4BACP,GACA,GACwB;CACxB,MAAM,SAAiC,EAAE;AACzC,KAAI,GAAG,UAAU,KAAA,KAAa,GAAG,UAAU,KAAA,EACzC,QAAO,SAAS,GAAG,SAAS,MAAM,GAAG,SAAS;AAEhD,KAAI,GAAG,UAAU,KAAA,KAAa,GAAG,UAAU,KAAA,EACzC,QAAO,SAAS,GAAG,SAAS,MAAM,GAAG,SAAS;AAEhD,KAAI,GAAG,UAAU,KAAA,KAAa,GAAG,UAAU,KAAA,EACzC,QAAO,SAAS,GAAG,SAAS,MAAM,GAAG,SAAS;AAEhD,KAAI,GAAG,aAAa,KAAA,KAAa,GAAG,aAAa,KAAA,EAC/C,QAAO,YAAY,GAAG,YAAY,MAAM,GAAG,YAAY;AAEzD,KAAI,GAAG,SAAS,KAAA,KAAa,GAAG,SAAS,KAAA,EACvC,QAAO,QAAQ,GAAG,QAAQ,MAAM,GAAG,QAAQ;AAE7C,QAAO;;AAyBT,SAAS,uBACP,GACA,GACmB;CACnB,MAAM,SAA4B,EAChC,GAAG,4BAA4B,GAAG,EAAE,EACrC;AACD,KAAI,GAAG,eAAe,KAAA,KAAa,GAAG,eAAe,KAAA,EACnD,QAAO,cAAc,GAAG,cAAc,MAAM,GAAG,cAAc;AAE/D,KAAI,GAAG,mBAAmB,KAAA,KAAa,GAAG,mBAAmB,KAAA,EAC3D,QAAO,kBAAkB,GAAG,kBAAkB,MAAM,GAAG,kBAAkB;AAE3E,QAAO;;AAkBT,SAAS,wBACP,GACA,GACoB;CACpB,MAAM,SAA6B,EACjC,GAAG,4BAA4B,GAAG,EAAE,EACrC;AACD,KAAI,GAAG,cAAc,KAAA,KAAa,GAAG,cAAc,KAAA,EACjD,QAAO,aAAa,GAAG,aAAa,MAAM,GAAG,aAAa;AAE5D,QAAO;;AAmCT,SAAgB,mBACd,GACA,GACe;AACf,QAAO;EACL,eAAe,GAAG,gBAAgB,MAAM,GAAG,gBAAgB;EAC3D,gBAAgB,GAAG,iBAAiB,MAAM,GAAG,iBAAiB;EAC9D,eAAe,GAAG,gBAAgB,MAAM,GAAG,gBAAgB;EAC3D,qBAAqB,uBACnB,GAAG,qBACH,GAAG,oBACJ;EACD,sBAAsB,wBACpB,GAAG,sBACH,GAAG,qBACJ;EACF"}
+{"version":3,"file":"metadata.js","names":[],"sources":["../../src/messages/metadata.ts"],"sourcesContent":["import { _mergeDicts } from \"./base.js\";\nimport type { MessageOutputVersion } from \"./message.js\";\n\nexport type ResponseMetadata = {\n  model_provider?: string;\n  model_name?: string;\n  output_version?: MessageOutputVersion;\n  [key: string]: unknown;\n};\n\nexport function mergeResponseMetadata(\n  a?: ResponseMetadata,\n  b?: ResponseMetadata\n): ResponseMetadata {\n  const output: ResponseMetadata = _mergeDicts(a, b) ?? {};\n  return output;\n}\n\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  /**\n   * Image (non-video) tokens.\n   */\n  image?: number;\n\n  /**\n   * Audio tokens.\n   */\n  audio?: number;\n\n  /**\n   * Video tokens.\n   */\n  video?: number;\n\n  /**\n   * Document tokens.\n   * e.g. PDF\n   */\n  document?: number;\n};\n\nfunction mergeModalitiesTokenDetails(\n  a?: ModalitiesTokenDetails,\n  b?: ModalitiesTokenDetails\n): ModalitiesTokenDetails {\n  const output: ModalitiesTokenDetails = {};\n  if (a?.audio !== undefined || b?.audio !== undefined) {\n    output.audio = (a?.audio ?? 0) + (b?.audio ?? 0);\n  }\n  if (a?.image !== undefined || b?.image !== undefined) {\n    output.image = (a?.image ?? 0) + (b?.image ?? 0);\n  }\n  if (a?.video !== undefined || b?.video !== undefined) {\n    output.video = (a?.video ?? 0) + (b?.video ?? 0);\n  }\n  if (a?.document !== undefined || b?.document !== undefined) {\n    output.document = (a?.document ?? 0) + (b?.document ?? 0);\n  }\n  if (a?.text !== undefined || b?.text !== undefined) {\n    output.text = (a?.text ?? 0) + (b?.text ?? 0);\n  }\n  return output;\n}\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  /**\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\nfunction mergeInputTokenDetails(\n  a?: InputTokenDetails,\n  b?: InputTokenDetails\n): InputTokenDetails {\n  const output: InputTokenDetails = {\n    ...mergeModalitiesTokenDetails(a, b),\n  };\n  if (a?.cache_read !== undefined || b?.cache_read !== undefined) {\n    output.cache_read = (a?.cache_read ?? 0) + (b?.cache_read ?? 0);\n  }\n  if (a?.cache_creation !== undefined || b?.cache_creation !== undefined) {\n    output.cache_creation = (a?.cache_creation ?? 0) + (b?.cache_creation ?? 0);\n  }\n  return output;\n}\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\nfunction mergeOutputTokenDetails(\n  a?: OutputTokenDetails,\n  b?: OutputTokenDetails\n): OutputTokenDetails {\n  const output: OutputTokenDetails = {\n    ...mergeModalitiesTokenDetails(a, b),\n  };\n  if (a?.reasoning !== undefined || b?.reasoning !== undefined) {\n    output.reasoning = (a?.reasoning ?? 0) + (b?.reasoning ?? 0);\n  }\n  return output;\n}\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  /**\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  /**\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};\n\nexport function mergeUsageMetadata(\n  a?: UsageMetadata,\n  b?: UsageMetadata\n): UsageMetadata {\n  return {\n    input_tokens: (a?.input_tokens ?? 0) + (b?.input_tokens ?? 0),\n    output_tokens: (a?.output_tokens ?? 0) + (b?.output_tokens ?? 0),\n    total_tokens: (a?.total_tokens ?? 0) + (b?.total_tokens ?? 0),\n    input_token_details: mergeInputTokenDetails(\n      a?.input_token_details,\n      b?.input_token_details\n    ),\n    output_token_details: mergeOutputTokenDetails(\n      a?.output_token_details,\n      b?.output_token_details\n    ),\n  };\n}\n"],"mappings":";;AAUA,SAAgB,sBACd,GACA,GACkB;CAElB,OADiC,YAAY,GAAG,CAAC,KAAK,CAAC;AAEzD;AA+BA,SAAS,4BACP,GACA,GACwB;CACxB,MAAM,SAAiC,CAAC;CACxC,IAAI,GAAG,UAAU,KAAA,KAAa,GAAG,UAAU,KAAA,GACzC,OAAO,SAAS,GAAG,SAAS,MAAM,GAAG,SAAS;CAEhD,IAAI,GAAG,UAAU,KAAA,KAAa,GAAG,UAAU,KAAA,GACzC,OAAO,SAAS,GAAG,SAAS,MAAM,GAAG,SAAS;CAEhD,IAAI,GAAG,UAAU,KAAA,KAAa,GAAG,UAAU,KAAA,GACzC,OAAO,SAAS,GAAG,SAAS,MAAM,GAAG,SAAS;CAEhD,IAAI,GAAG,aAAa,KAAA,KAAa,GAAG,aAAa,KAAA,GAC/C,OAAO,YAAY,GAAG,YAAY,MAAM,GAAG,YAAY;CAEzD,IAAI,GAAG,SAAS,KAAA,KAAa,GAAG,SAAS,KAAA,GACvC,OAAO,QAAQ,GAAG,QAAQ,MAAM,GAAG,QAAQ;CAE7C,OAAO;AACT;AAwBA,SAAS,uBACP,GACA,GACmB;CACnB,MAAM,SAA4B,EAChC,GAAG,4BAA4B,GAAG,CAAC,EACrC;CACA,IAAI,GAAG,eAAe,KAAA,KAAa,GAAG,eAAe,KAAA,GACnD,OAAO,cAAc,GAAG,cAAc,MAAM,GAAG,cAAc;CAE/D,IAAI,GAAG,mBAAmB,KAAA,KAAa,GAAG,mBAAmB,KAAA,GAC3D,OAAO,kBAAkB,GAAG,kBAAkB,MAAM,GAAG,kBAAkB;CAE3E,OAAO;AACT;AAiBA,SAAS,wBACP,GACA,GACoB;CACpB,MAAM,SAA6B,EACjC,GAAG,4BAA4B,GAAG,CAAC,EACrC;CACA,IAAI,GAAG,cAAc,KAAA,KAAa,GAAG,cAAc,KAAA,GACjD,OAAO,aAAa,GAAG,aAAa,MAAM,GAAG,aAAa;CAE5D,OAAO;AACT;AAkCA,SAAgB,mBACd,GACA,GACe;CACf,OAAO;EACL,eAAe,GAAG,gBAAgB,MAAM,GAAG,gBAAgB;EAC3D,gBAAgB,GAAG,iBAAiB,MAAM,GAAG,iBAAiB;EAC9D,eAAe,GAAG,gBAAgB,MAAM,GAAG,gBAAgB;EAC3D,qBAAqB,uBACnB,GAAG,qBACH,GAAG,mBACL;EACA,sBAAsB,wBACpB,GAAG,sBACH,GAAG,oBACL;CACF;AACF"}

package/dist/messages/modifier.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"modifier.cjs","names":["BaseMessage"],"sources":["../../src/messages/modifier.ts"],"sourcesContent":["import { BaseMessage, BaseMessageFields } from \"./base.js\";\n\nexport interface RemoveMessageFields extends Omit<\n  BaseMessageFields,\n  \"content\"\n> {\n  /**\n   * The ID of the message to remove.\n   */\n  id: string;\n}\n\n/**\n * Message responsible for deleting other messages.\n *\n * `RemoveMessage` is intentionally not generic over `MessageStructure`.\n * Its content is always `[]` (empty), so carrying a structure type parameter\n * would only cause unnecessary type incompatibilities when mixing messages\n * from different structure configurations (e.g. passing a `RemoveMessage`\n * into an API that expects `Message<CustomToolCall>`).\n */\nexport class RemoveMessage extends BaseMessage {\n  readonly type = \"remove\" as const;\n\n  /**\n   * The ID of the message to remove.\n   */\n  id: string;\n\n  constructor(fields: RemoveMessageFields) {\n    super({\n      ...fields,\n      content: [],\n    });\n    this.id = fields.id;\n  }\n\n  override get _printableFields(): Record<string, unknown> {\n    return {\n      ...super._printableFields,\n      id: this.id,\n    };\n  }\n\n  static isInstance(obj: unknown): obj is RemoveMessage {\n    return super.isInstance(obj) && obj.type === \"remove\";\n  }\n}\n"],"mappings":";;;;;;;;;;;AAqBA,IAAa,gBAAb,cAAmCA,aAAAA,YAAY;CAC7C,OAAgB;;;;CAKhB;CAEA,YAAY,QAA6B;AACvC,QAAM;GACJ,GAAG;GACH,SAAS,EAAE;GACZ,CAAC;AACF,OAAK,KAAK,OAAO;;CAGnB,IAAa,mBAA4C;AACvD,SAAO;GACL,GAAG,MAAM;GACT,IAAI,KAAK;GACV;;CAGH,OAAO,WAAW,KAAoC;AACpD,SAAO,MAAM,WAAW,IAAI,IAAI,IAAI,SAAS"}
+{"version":3,"file":"modifier.cjs","names":["BaseMessage"],"sources":["../../src/messages/modifier.ts"],"sourcesContent":["import { BaseMessage, BaseMessageFields } from \"./base.js\";\n\nexport interface RemoveMessageFields extends Omit<\n  BaseMessageFields,\n  \"content\"\n> {\n  /**\n   * The ID of the message to remove.\n   */\n  id: string;\n}\n\n/**\n * Message responsible for deleting other messages.\n *\n * `RemoveMessage` is intentionally not generic over `MessageStructure`.\n * Its content is always `[]` (empty), so carrying a structure type parameter\n * would only cause unnecessary type incompatibilities when mixing messages\n * from different structure configurations (e.g. passing a `RemoveMessage`\n * into an API that expects `Message<CustomToolCall>`).\n */\nexport class RemoveMessage extends BaseMessage {\n  readonly type = \"remove\" as const;\n\n  /**\n   * The ID of the message to remove.\n   */\n  id: string;\n\n  constructor(fields: RemoveMessageFields) {\n    super({\n      ...fields,\n      content: [],\n    });\n    this.id = fields.id;\n  }\n\n  override get _printableFields(): Record<string, unknown> {\n    return {\n      ...super._printableFields,\n      id: this.id,\n    };\n  }\n\n  static isInstance(obj: unknown): obj is RemoveMessage {\n    return super.isInstance(obj) && obj.type === \"remove\";\n  }\n}\n"],"mappings":";;;;;;;;;;;AAqBA,IAAa,gBAAb,cAAmCA,aAAAA,YAAY;CAC7C,OAAgB;;;;CAKhB;CAEA,YAAY,QAA6B;EACvC,MAAM;GACJ,GAAG;GACH,SAAS,CAAC;EACZ,CAAC;EACD,KAAK,KAAK,OAAO;CACnB;CAEA,IAAa,mBAA4C;EACvD,OAAO;GACL,GAAG,MAAM;GACT,IAAI,KAAK;EACX;CACF;CAEA,OAAO,WAAW,KAAoC;EACpD,OAAO,MAAM,WAAW,GAAG,KAAK,IAAI,SAAS;CAC/C;AACF"}

package/dist/messages/modifier.d.cts

@@ -1,5 +1,4 @@
 import { BaseMessage, BaseMessageFields } from "./base.cjs";
-
 //#region src/messages/modifier.d.ts
 interface RemoveMessageFields extends Omit<BaseMessageFields, "content"> {
   /**

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

@@ -1 +1 @@
-{"version":3,"file":"modifier.d.cts","names":[],"sources":["../../src/messages/modifier.ts"],"mappings":";;;UAEiB,mBAAA,SAA4B,IAAA,CAC3C,iBAAA;;AADF;;EAOE,EAAA;AAAA;;;;;;AAYF;;;;cAAa,aAAA,SAAsB,WAAA;EAAA,SACxB,IAAA;EADwB;;;EAMjC,EAAA;EAEA,WAAA,CAAY,MAAA,EAAQ,mBAAA;EAAA,IAQP,gBAAA,CAAA,GAAoB,MAAA;EAAA,OAO1B,UAAA,CAAW,GAAA,YAAe,GAAA,IAAO,aAAA;AAAA"}
+{"version":3,"file":"modifier.d.cts","names":[],"sources":["../../src/messages/modifier.ts"],"mappings":";;UAEiB,4BAA4B,KAC3C;;;;EAMA;;;;;;;;;;;cAYW,sBAAsB;WACxB;;;;EAKT;EAEA,YAAY,QAAQ;MAQP,oBAAoB;SAO1B,WAAW,eAAe,OAAO"}

package/dist/messages/modifier.d.ts

@@ -1,5 +1,4 @@
 import { BaseMessage, BaseMessageFields } from "./base.js";
-
 //#region src/messages/modifier.d.ts
 interface RemoveMessageFields extends Omit<BaseMessageFields, "content"> {
   /**

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

@@ -1 +1 @@
-{"version":3,"file":"modifier.d.ts","names":[],"sources":["../../src/messages/modifier.ts"],"mappings":";;;UAEiB,mBAAA,SAA4B,IAAA,CAC3C,iBAAA;;AADF;;EAOE,EAAA;AAAA;;;;;;AAYF;;;;cAAa,aAAA,SAAsB,WAAA;EAAA,SACxB,IAAA;EADwB;;;EAMjC,EAAA;EAEA,WAAA,CAAY,MAAA,EAAQ,mBAAA;EAAA,IAQP,gBAAA,CAAA,GAAoB,MAAA;EAAA,OAO1B,UAAA,CAAW,GAAA,YAAe,GAAA,IAAO,aAAA;AAAA"}
+{"version":3,"file":"modifier.d.ts","names":[],"sources":["../../src/messages/modifier.ts"],"mappings":";;UAEiB,4BAA4B,KAC3C;;;;EAMA;;;;;;;;;;;cAYW,sBAAsB;WACxB;;;;EAKT;EAEA,YAAY,QAAQ;MAQP,oBAAoB;SAO1B,WAAW,eAAe,OAAO"}

package/dist/messages/modifier.js.map

@@ -1 +1 @@
-{"version":3,"file":"modifier.js","names":[],"sources":["../../src/messages/modifier.ts"],"sourcesContent":["import { BaseMessage, BaseMessageFields } from \"./base.js\";\n\nexport interface RemoveMessageFields extends Omit<\n  BaseMessageFields,\n  \"content\"\n> {\n  /**\n   * The ID of the message to remove.\n   */\n  id: string;\n}\n\n/**\n * Message responsible for deleting other messages.\n *\n * `RemoveMessage` is intentionally not generic over `MessageStructure`.\n * Its content is always `[]` (empty), so carrying a structure type parameter\n * would only cause unnecessary type incompatibilities when mixing messages\n * from different structure configurations (e.g. passing a `RemoveMessage`\n * into an API that expects `Message<CustomToolCall>`).\n */\nexport class RemoveMessage extends BaseMessage {\n  readonly type = \"remove\" as const;\n\n  /**\n   * The ID of the message to remove.\n   */\n  id: string;\n\n  constructor(fields: RemoveMessageFields) {\n    super({\n      ...fields,\n      content: [],\n    });\n    this.id = fields.id;\n  }\n\n  override get _printableFields(): Record<string, unknown> {\n    return {\n      ...super._printableFields,\n      id: this.id,\n    };\n  }\n\n  static isInstance(obj: unknown): obj is RemoveMessage {\n    return super.isInstance(obj) && obj.type === \"remove\";\n  }\n}\n"],"mappings":";;;;;;;;;;;AAqBA,IAAa,gBAAb,cAAmC,YAAY;CAC7C,OAAgB;;;;CAKhB;CAEA,YAAY,QAA6B;AACvC,QAAM;GACJ,GAAG;GACH,SAAS,EAAE;GACZ,CAAC;AACF,OAAK,KAAK,OAAO;;CAGnB,IAAa,mBAA4C;AACvD,SAAO;GACL,GAAG,MAAM;GACT,IAAI,KAAK;GACV;;CAGH,OAAO,WAAW,KAAoC;AACpD,SAAO,MAAM,WAAW,IAAI,IAAI,IAAI,SAAS"}
+{"version":3,"file":"modifier.js","names":[],"sources":["../../src/messages/modifier.ts"],"sourcesContent":["import { BaseMessage, BaseMessageFields } from \"./base.js\";\n\nexport interface RemoveMessageFields extends Omit<\n  BaseMessageFields,\n  \"content\"\n> {\n  /**\n   * The ID of the message to remove.\n   */\n  id: string;\n}\n\n/**\n * Message responsible for deleting other messages.\n *\n * `RemoveMessage` is intentionally not generic over `MessageStructure`.\n * Its content is always `[]` (empty), so carrying a structure type parameter\n * would only cause unnecessary type incompatibilities when mixing messages\n * from different structure configurations (e.g. passing a `RemoveMessage`\n * into an API that expects `Message<CustomToolCall>`).\n */\nexport class RemoveMessage extends BaseMessage {\n  readonly type = \"remove\" as const;\n\n  /**\n   * The ID of the message to remove.\n   */\n  id: string;\n\n  constructor(fields: RemoveMessageFields) {\n    super({\n      ...fields,\n      content: [],\n    });\n    this.id = fields.id;\n  }\n\n  override get _printableFields(): Record<string, unknown> {\n    return {\n      ...super._printableFields,\n      id: this.id,\n    };\n  }\n\n  static isInstance(obj: unknown): obj is RemoveMessage {\n    return super.isInstance(obj) && obj.type === \"remove\";\n  }\n}\n"],"mappings":";;;;;;;;;;;AAqBA,IAAa,gBAAb,cAAmC,YAAY;CAC7C,OAAgB;;;;CAKhB;CAEA,YAAY,QAA6B;EACvC,MAAM;GACJ,GAAG;GACH,SAAS,CAAC;EACZ,CAAC;EACD,KAAK,KAAK,OAAO;CACnB;CAEA,IAAa,mBAA4C;EACvD,OAAO;GACL,GAAG,MAAM;GACT,IAAI,KAAK;EACX;CACF;CAEA,OAAO,WAAW,KAAoC;EACpD,OAAO,MAAM,WAAW,GAAG,KAAK,IAAI,SAAS;CAC/C;AACF"}

package/dist/messages/system.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"system.cjs","names":["BaseMessage","mergeContent","BaseMessageChunk","_mergeDicts"],"sources":["../../src/messages/system.ts"],"sourcesContent":["import {\n  BaseMessage,\n  BaseMessageChunk,\n  mergeContent,\n  _mergeDicts,\n  type BaseMessageFields,\n} from \"./base.js\";\nimport { $InferMessageContent, MessageStructure } from \"./message.js\";\nimport { Constructor } from \"./utils.js\";\n\nexport interface SystemMessageFields<\n  TStructure extends MessageStructure = MessageStructure,\n> extends BaseMessageFields<TStructure, \"system\"> {}\n\n/**\n * Represents a system message in a conversation.\n */\nexport class SystemMessage<\n  TStructure extends MessageStructure = MessageStructure,\n> extends BaseMessage<TStructure, \"system\"> {\n  static lc_name() {\n    return \"SystemMessage\";\n  }\n\n  readonly type = \"system\" as const;\n\n  constructor(\n    fields:\n      | $InferMessageContent<TStructure, \"system\">\n      | SystemMessageFields<TStructure>\n  ) {\n    super(fields);\n  }\n\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) {\n    if (typeof chunk === \"string\") {\n      return new SystemMessage({\n        content: mergeContent(this.content, chunk),\n        additional_kwargs: this.additional_kwargs,\n        response_metadata: this.response_metadata,\n        id: this.id,\n        name: this.name,\n      } as SystemMessageFields<TStructure>);\n    }\n\n    if (SystemMessage.isInstance(chunk)) {\n      return new SystemMessage({\n        content: mergeContent(this.content, chunk.content),\n        additional_kwargs: {\n          ...this.additional_kwargs,\n          ...chunk.additional_kwargs,\n        },\n        response_metadata: {\n          ...this.response_metadata,\n          ...chunk.response_metadata,\n        },\n        id: this.id ?? chunk.id,\n        name: this.name ?? chunk.name,\n      } as SystemMessageFields<TStructure>);\n    }\n\n    throw new Error(\"Unexpected chunk type for system message\");\n  }\n\n  static isInstance(obj: unknown): obj is SystemMessage {\n    return super.isInstance(obj) && obj.type === \"system\";\n  }\n}\n\n/**\n * Represents a chunk of a system message, which can be concatenated with\n * other system message chunks.\n */\nexport class SystemMessageChunk<\n  TStructure extends MessageStructure = MessageStructure,\n> extends BaseMessageChunk<TStructure, \"system\"> {\n  static lc_name() {\n    return \"SystemMessageChunk\";\n  }\n\n  readonly type = \"system\" as const;\n\n  constructor(\n    fields:\n      | $InferMessageContent<TStructure, \"system\">\n      | SystemMessageFields<TStructure>\n  ) {\n    super(fields);\n  }\n\n  concat(chunk: SystemMessageChunk<TStructure>) {\n    const Cls = this.constructor as Constructor<this>;\n    return new Cls({\n      content: mergeContent(this.content, chunk.content),\n      additional_kwargs: _mergeDicts(\n        this.additional_kwargs,\n        chunk.additional_kwargs\n      ),\n      response_metadata: _mergeDicts(\n        this.response_metadata,\n        chunk.response_metadata\n      ),\n      id: this.id ?? chunk.id,\n    });\n  }\n\n  static isInstance(obj: unknown): obj is SystemMessageChunk {\n    return super.isInstance(obj) && obj.type === \"system\";\n  }\n}\n\n/**\n * @deprecated Use {@link SystemMessage.isInstance} instead\n */\nexport function isSystemMessage<TStructure extends MessageStructure>(\n  x: BaseMessage\n): x is SystemMessage<TStructure> {\n  return x._getType() === \"system\";\n}\n\n/**\n * @deprecated Use {@link SystemMessageChunk.isInstance} instead\n */\nexport function isSystemMessageChunk<TStructure extends MessageStructure>(\n  x: BaseMessageChunk\n): x is SystemMessageChunk<TStructure> {\n  return x._getType() === \"system\";\n}\n"],"mappings":";;;;;AAiBA,IAAa,gBAAb,MAAa,sBAEHA,aAAAA,YAAkC;CAC1C,OAAO,UAAU;AACf,SAAO;;CAGT,OAAgB;CAEhB,YACE,QAGA;AACA,QAAM,OAAO;;;;;;;CAQf,OAAO,OAA+B;AACpC,MAAI,OAAO,UAAU,SACnB,QAAO,IAAI,cAAc;GACvB,SAASC,aAAAA,aAAa,KAAK,SAAS,MAAM;GAC1C,mBAAmB,KAAK;GACxB,mBAAmB,KAAK;GACxB,IAAI,KAAK;GACT,MAAM,KAAK;GACZ,CAAoC;AAGvC,MAAI,cAAc,WAAW,MAAM,CACjC,QAAO,IAAI,cAAc;GACvB,SAASA,aAAAA,aAAa,KAAK,SAAS,MAAM,QAAQ;GAClD,mBAAmB;IACjB,GAAG,KAAK;IACR,GAAG,MAAM;IACV;GACD,mBAAmB;IACjB,GAAG,KAAK;IACR,GAAG,MAAM;IACV;GACD,IAAI,KAAK,MAAM,MAAM;GACrB,MAAM,KAAK,QAAQ,MAAM;GAC1B,CAAoC;AAGvC,QAAM,IAAI,MAAM,2CAA2C;;CAG7D,OAAO,WAAW,KAAoC;AACpD,SAAO,MAAM,WAAW,IAAI,IAAI,IAAI,SAAS;;;;;;;AAQjD,IAAa,qBAAb,cAEUC,aAAAA,iBAAuC;CAC/C,OAAO,UAAU;AACf,SAAO;;CAGT,OAAgB;CAEhB,YACE,QAGA;AACA,QAAM,OAAO;;CAGf,OAAO,OAAuC;EAC5C,MAAM,MAAM,KAAK;AACjB,SAAO,IAAI,IAAI;GACb,SAASD,aAAAA,aAAa,KAAK,SAAS,MAAM,QAAQ;GAClD,mBAAmBE,aAAAA,YACjB,KAAK,mBACL,MAAM,kBACP;GACD,mBAAmBA,aAAAA,YACjB,KAAK,mBACL,MAAM,kBACP;GACD,IAAI,KAAK,MAAM,MAAM;GACtB,CAAC;;CAGJ,OAAO,WAAW,KAAyC;AACzD,SAAO,MAAM,WAAW,IAAI,IAAI,IAAI,SAAS;;;;;;AAOjD,SAAgB,gBACd,GACgC;AAChC,QAAO,EAAE,UAAU,KAAK;;;;;AAM1B,SAAgB,qBACd,GACqC;AACrC,QAAO,EAAE,UAAU,KAAK"}
+{"version":3,"file":"system.cjs","names":["BaseMessage","mergeContent","BaseMessageChunk","_mergeDicts"],"sources":["../../src/messages/system.ts"],"sourcesContent":["import {\n  BaseMessage,\n  BaseMessageChunk,\n  mergeContent,\n  _mergeDicts,\n  type BaseMessageFields,\n} from \"./base.js\";\nimport { $InferMessageContent, MessageStructure } from \"./message.js\";\nimport { Constructor } from \"./utils.js\";\n\nexport interface SystemMessageFields<\n  TStructure extends MessageStructure = MessageStructure,\n> extends BaseMessageFields<TStructure, \"system\"> {}\n\n/**\n * Represents a system message in a conversation.\n */\nexport class SystemMessage<\n  TStructure extends MessageStructure = MessageStructure,\n> extends BaseMessage<TStructure, \"system\"> {\n  static lc_name() {\n    return \"SystemMessage\";\n  }\n\n  readonly type = \"system\" as const;\n\n  constructor(\n    fields:\n      | $InferMessageContent<TStructure, \"system\">\n      | SystemMessageFields<TStructure>\n  ) {\n    super(fields);\n  }\n\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) {\n    if (typeof chunk === \"string\") {\n      return new SystemMessage({\n        content: mergeContent(this.content, chunk),\n        additional_kwargs: this.additional_kwargs,\n        response_metadata: this.response_metadata,\n        id: this.id,\n        name: this.name,\n      } as SystemMessageFields<TStructure>);\n    }\n\n    if (SystemMessage.isInstance(chunk)) {\n      return new SystemMessage({\n        content: mergeContent(this.content, chunk.content),\n        additional_kwargs: {\n          ...this.additional_kwargs,\n          ...chunk.additional_kwargs,\n        },\n        response_metadata: {\n          ...this.response_metadata,\n          ...chunk.response_metadata,\n        },\n        id: this.id ?? chunk.id,\n        name: this.name ?? chunk.name,\n      } as SystemMessageFields<TStructure>);\n    }\n\n    throw new Error(\"Unexpected chunk type for system message\");\n  }\n\n  static isInstance(obj: unknown): obj is SystemMessage {\n    return super.isInstance(obj) && obj.type === \"system\";\n  }\n}\n\n/**\n * Represents a chunk of a system message, which can be concatenated with\n * other system message chunks.\n */\nexport class SystemMessageChunk<\n  TStructure extends MessageStructure = MessageStructure,\n> extends BaseMessageChunk<TStructure, \"system\"> {\n  static lc_name() {\n    return \"SystemMessageChunk\";\n  }\n\n  readonly type = \"system\" as const;\n\n  constructor(\n    fields:\n      | $InferMessageContent<TStructure, \"system\">\n      | SystemMessageFields<TStructure>\n  ) {\n    super(fields);\n  }\n\n  concat(chunk: SystemMessageChunk<TStructure>) {\n    const Cls = this.constructor as Constructor<this>;\n    return new Cls({\n      content: mergeContent(this.content, chunk.content),\n      additional_kwargs: _mergeDicts(\n        this.additional_kwargs,\n        chunk.additional_kwargs\n      ),\n      response_metadata: _mergeDicts(\n        this.response_metadata,\n        chunk.response_metadata\n      ),\n      id: this.id ?? chunk.id,\n    });\n  }\n\n  static isInstance(obj: unknown): obj is SystemMessageChunk {\n    return super.isInstance(obj) && obj.type === \"system\";\n  }\n}\n\n/**\n * @deprecated Use {@link SystemMessage.isInstance} instead\n */\nexport function isSystemMessage<TStructure extends MessageStructure>(\n  x: BaseMessage\n): x is SystemMessage<TStructure> {\n  return x._getType() === \"system\";\n}\n\n/**\n * @deprecated Use {@link SystemMessageChunk.isInstance} instead\n */\nexport function isSystemMessageChunk<TStructure extends MessageStructure>(\n  x: BaseMessageChunk\n): x is SystemMessageChunk<TStructure> {\n  return x._getType() === \"system\";\n}\n"],"mappings":";;;;;AAiBA,IAAa,gBAAb,MAAa,sBAEHA,aAAAA,YAAkC;CAC1C,OAAO,UAAU;EACf,OAAO;CACT;CAEA,OAAgB;CAEhB,YACE,QAGA;EACA,MAAM,MAAM;CACd;;;;;;CAOA,OAAO,OAA+B;EACpC,IAAI,OAAO,UAAU,UACnB,OAAO,IAAI,cAAc;GACvB,SAASC,aAAAA,aAAa,KAAK,SAAS,KAAK;GACzC,mBAAmB,KAAK;GACxB,mBAAmB,KAAK;GACxB,IAAI,KAAK;GACT,MAAM,KAAK;EACb,CAAoC;EAGtC,IAAI,cAAc,WAAW,KAAK,GAChC,OAAO,IAAI,cAAc;GACvB,SAASA,aAAAA,aAAa,KAAK,SAAS,MAAM,OAAO;GACjD,mBAAmB;IACjB,GAAG,KAAK;IACR,GAAG,MAAM;GACX;GACA,mBAAmB;IACjB,GAAG,KAAK;IACR,GAAG,MAAM;GACX;GACA,IAAI,KAAK,MAAM,MAAM;GACrB,MAAM,KAAK,QAAQ,MAAM;EAC3B,CAAoC;EAGtC,MAAM,IAAI,MAAM,0CAA0C;CAC5D;CAEA,OAAO,WAAW,KAAoC;EACpD,OAAO,MAAM,WAAW,GAAG,KAAK,IAAI,SAAS;CAC/C;AACF;;;;;AAMA,IAAa,qBAAb,cAEUC,aAAAA,iBAAuC;CAC/C,OAAO,UAAU;EACf,OAAO;CACT;CAEA,OAAgB;CAEhB,YACE,QAGA;EACA,MAAM,MAAM;CACd;CAEA,OAAO,OAAuC;EAC5C,MAAM,MAAM,KAAK;EACjB,OAAO,IAAI,IAAI;GACb,SAASD,aAAAA,aAAa,KAAK,SAAS,MAAM,OAAO;GACjD,mBAAmBE,aAAAA,YACjB,KAAK,mBACL,MAAM,iBACR;GACA,mBAAmBA,aAAAA,YACjB,KAAK,mBACL,MAAM,iBACR;GACA,IAAI,KAAK,MAAM,MAAM;EACvB,CAAC;CACH;CAEA,OAAO,WAAW,KAAyC;EACzD,OAAO,MAAM,WAAW,GAAG,KAAK,IAAI,SAAS;CAC/C;AACF;;;;AAKA,SAAgB,gBACd,GACgC;CAChC,OAAO,EAAE,SAAS,MAAM;AAC1B;;;;AAKA,SAAgB,qBACd,GACqC;CACrC,OAAO,EAAE,SAAS,MAAM;AAC1B"}

package/dist/messages/system.d.cts

@@ -1,6 +1,5 @@
 import { BaseMessage, BaseMessageChunk, BaseMessageFields } from "./base.cjs";
 import { $InferMessageContent, MessageStructure } from "./message.cjs";
-
 //#region src/messages/system.d.ts
 interface SystemMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, "system"> {}
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"system.d.cts","names":[],"sources":["../../src/messages/system.ts"],"mappings":";;;;UAUiB,mBAAA,oBACI,gBAAA,GAAmB,gBAAA,UAC9B,iBAAA,CAAkB,UAAA;AAF5B;;;AAAA,cAOa,aAAA,oBACQ,gBAAA,GAAmB,gBAAA,UAC9B,WAAA,CAAY,UAAA;EAAA,OACb,OAAA,CAAA;EAAA,SAIE,IAAA;EAET,WAAA,CACE,MAAA,EACI,oBAAA,CAAqB,UAAA,cACrB,mBAAA,CAAoB,UAAA;EAjBD;;;;;EA2BzB,MAAA,CAAO,KAAA,WAAgB,aAAA,GAAa,aAAA,CAAA,UAAA;EAAA,OA8B7B,UAAA,CAAW,GAAA,YAAe,GAAA,IAAO,aAAA;AAAA;;AApD1C;;;cA6Da,kBAAA,oBACQ,gBAAA,GAAmB,gBAAA,UAC9B,gBAAA,CAAiB,UAAA;EAAA,OAClB,OAAA,CAAA;EAAA,SAIE,IAAA;EAET,WAAA,CACE,MAAA,EACI,oBAAA,CAAqB,UAAA,cACrB,mBAAA,CAAoB,UAAA;EAK1B,MAAA,CAAO,KAAA,EAAO,kBAAA,CAAmB,UAAA;EAAA,OAgB1B,UAAA,CAAW,GAAA,YAAe,GAAA,IAAO,kBAAA;AAAA;;;;iBAQ1B,eAAA,oBAAmC,gBAAA,CAAA,CACjD,CAAA,EAAG,WAAA,GACF,CAAA,IAAK,aAAA,CAAc,UAAA;;;;iBAON,oBAAA,oBAAwC,gBAAA,CAAA,CACtD,CAAA,EAAG,gBAAA,GACF,CAAA,IAAK,kBAAA,CAAmB,UAAA"}
+{"version":3,"file":"system.d.cts","names":[],"sources":["../../src/messages/system.ts"],"mappings":";;;UAUiB,oBACf,mBAAmB,mBAAmB,0BAC9B,kBAAkB;;;;cAKf,cACX,mBAAmB,mBAAmB,0BAC9B,YAAY;SACb;WAIE;EAET,YACE,QACI,qBAAqB,wBACrB,oBAAoB;;;;;;EAU1B,OAAO,gBAAgB,gBAAa,cAAA;SA8B7B,WAAW,eAAe,OAAO;;;;;;cAS7B,mBACX,mBAAmB,mBAAmB,0BAC9B,iBAAiB;SAClB;WAIE;EAET,YACE,QACI,qBAAqB,wBACrB,oBAAoB;EAK1B,OAAO,OAAO,mBAAmB;SAgB1B,WAAW,eAAe,OAAO;;;;;iBAQ1B,gBAAgB,mBAAmB,kBACjD,GAAG,cACF,KAAK,cAAc;;;;iBAON,qBAAqB,mBAAmB,kBACtD,GAAG,mBACF,KAAK,mBAAmB"}

package/dist/messages/system.d.ts

@@ -1,6 +1,5 @@
 import { BaseMessage, BaseMessageChunk, BaseMessageFields } from "./base.js";
 import { $InferMessageContent, MessageStructure } from "./message.js";
-
 //#region src/messages/system.d.ts
 interface SystemMessageFields<TStructure extends MessageStructure = MessageStructure> extends BaseMessageFields<TStructure, "system"> {}
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"system.d.ts","names":[],"sources":["../../src/messages/system.ts"],"mappings":";;;;UAUiB,mBAAA,oBACI,gBAAA,GAAmB,gBAAA,UAC9B,iBAAA,CAAkB,UAAA;AAF5B;;;AAAA,cAOa,aAAA,oBACQ,gBAAA,GAAmB,gBAAA,UAC9B,WAAA,CAAY,UAAA;EAAA,OACb,OAAA,CAAA;EAAA,SAIE,IAAA;EAET,WAAA,CACE,MAAA,EACI,oBAAA,CAAqB,UAAA,cACrB,mBAAA,CAAoB,UAAA;EAjBD;;;;;EA2BzB,MAAA,CAAO,KAAA,WAAgB,aAAA,GAAa,aAAA,CAAA,UAAA;EAAA,OA8B7B,UAAA,CAAW,GAAA,YAAe,GAAA,IAAO,aAAA;AAAA;;AApD1C;;;cA6Da,kBAAA,oBACQ,gBAAA,GAAmB,gBAAA,UAC9B,gBAAA,CAAiB,UAAA;EAAA,OAClB,OAAA,CAAA;EAAA,SAIE,IAAA;EAET,WAAA,CACE,MAAA,EACI,oBAAA,CAAqB,UAAA,cACrB,mBAAA,CAAoB,UAAA;EAK1B,MAAA,CAAO,KAAA,EAAO,kBAAA,CAAmB,UAAA;EAAA,OAgB1B,UAAA,CAAW,GAAA,YAAe,GAAA,IAAO,kBAAA;AAAA;;;;iBAQ1B,eAAA,oBAAmC,gBAAA,CAAA,CACjD,CAAA,EAAG,WAAA,GACF,CAAA,IAAK,aAAA,CAAc,UAAA;;;;iBAON,oBAAA,oBAAwC,gBAAA,CAAA,CACtD,CAAA,EAAG,gBAAA,GACF,CAAA,IAAK,kBAAA,CAAmB,UAAA"}
+{"version":3,"file":"system.d.ts","names":[],"sources":["../../src/messages/system.ts"],"mappings":";;;UAUiB,oBACf,mBAAmB,mBAAmB,0BAC9B,kBAAkB;;;;cAKf,cACX,mBAAmB,mBAAmB,0BAC9B,YAAY;SACb;WAIE;EAET,YACE,QACI,qBAAqB,wBACrB,oBAAoB;;;;;;EAU1B,OAAO,gBAAgB,gBAAa,cAAA;SA8B7B,WAAW,eAAe,OAAO;;;;;;cAS7B,mBACX,mBAAmB,mBAAmB,0BAC9B,iBAAiB;SAClB;WAIE;EAET,YACE,QACI,qBAAqB,wBACrB,oBAAoB;EAK1B,OAAO,OAAO,mBAAmB;SAgB1B,WAAW,eAAe,OAAO;;;;;iBAQ1B,gBAAgB,mBAAmB,kBACjD,GAAG,cACF,KAAK,cAAc;;;;iBAON,qBAAqB,mBAAmB,kBACtD,GAAG,mBACF,KAAK,mBAAmB"}