@langchain/core 1.0.2 → 1.0.4

package/dist/utils/format.d.cts

@@ -0,0 +1,58 @@
+//#region src/utils/format.d.ts
+/**
+ * A function that converts data from one format to another.
+ *
+ * This is commonly used for transforming message content blocks between different
+ * provider-specific formats and standardized internal representations.
+ *
+ * @template T - The input type to convert from
+ * @template U - The output type to convert to
+ *
+ * @param input - The data to convert
+ * @returns The converted data in the target format
+ *
+ * @example
+ * ```typescript
+ * // Convert from OpenAI format to standard format
+ * const converter: Converter<OpenAIBlock, ContentBlock.Standard> = (block) => {
+ *   return { type: "text", text: block.text };
+ * };
+ * ```
+ */
+type Converter<T, U> = (input: T) => U;
+/**
+ * A pair of bidirectional conversion functions for transforming data between two formats.
+ *
+ * This type is used throughout the message system to enable conversion between
+ * provider-specific message formats (like OpenAI, Anthropic, Google, etc.) and
+ * standardized internal content block representations. The `encode` function
+ * typically converts from a standard format to a provider-specific format, while
+ * `decode` converts from a provider-specific format back to the standard format.
+ *
+ * @template T - The first format (typically the standard/internal format)
+ * @template U - The second format (typically the provider-specific format)
+ *
+ * @property encode - Converts from format T to format U
+ * @property decode - Converts from format U back to format T
+ *
+ * @example
+ * ```typescript
+ * // Converter pair for OpenAI message blocks
+ * const openAIConverter: ConverterPair<ContentBlock.Standard, OpenAIBlock> = {
+ *   encode: (standard) => ({ text: standard.text }),
+ *   decode: (openai) => ({ type: "text", text: openai.text })
+ * };
+ *
+ * // Usage
+ * const standardBlock = { type: "text", text: "Hello" };
+ * const openaiBlock = openAIConverter.encode(standardBlock);
+ * const backToStandard = openAIConverter.decode(openaiBlock);
+ * ```
+ */
+type ConverterPair<T, U> = {
+  encode: Converter<T, U>;
+  decode: Converter<U, T>;
+};
+//#endregion
+export { Converter, ConverterPair };
+//# sourceMappingURL=format.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.cts","names":["Converter","T","U","ConverterPair"],"sources":["../../src/utils/format.d.ts"],"sourcesContent":["/**\n * A function that converts data from one format to another.\n *\n * This is commonly used for transforming message content blocks between different\n * provider-specific formats and standardized internal representations.\n *\n * @template T - The input type to convert from\n * @template U - The output type to convert to\n *\n * @param input - The data to convert\n * @returns The converted data in the target format\n *\n * @example\n * ```typescript\n * // Convert from OpenAI format to standard format\n * const converter: Converter<OpenAIBlock, ContentBlock.Standard> = (block) => {\n *   return { type: \"text\", text: block.text };\n * };\n * ```\n */\nexport type Converter<T, U> = (input: T) => U;\n/**\n * A pair of bidirectional conversion functions for transforming data between two formats.\n *\n * This type is used throughout the message system to enable conversion between\n * provider-specific message formats (like OpenAI, Anthropic, Google, etc.) and\n * standardized internal content block representations. The `encode` function\n * typically converts from a standard format to a provider-specific format, while\n * `decode` converts from a provider-specific format back to the standard format.\n *\n * @template T - The first format (typically the standard/internal format)\n * @template U - The second format (typically the provider-specific format)\n *\n * @property encode - Converts from format T to format U\n * @property decode - Converts from format U back to format T\n *\n * @example\n * ```typescript\n * // Converter pair for OpenAI message blocks\n * const openAIConverter: ConverterPair<ContentBlock.Standard, OpenAIBlock> = {\n *   encode: (standard) => ({ text: standard.text }),\n *   decode: (openai) => ({ type: \"text\", text: openai.text })\n * };\n *\n * // Usage\n * const standardBlock = { type: \"text\", text: \"Hello\" };\n * const openaiBlock = openAIConverter.encode(standardBlock);\n * const backToStandard = openAIConverter.decode(openaiBlock);\n * ```\n */\nexport type ConverterPair<T, U> = {\n    encode: Converter<T, U>;\n    decode: Converter<U, T>;\n};\n"],"mappings":";;AAoBA;;;;AAA6C;AA8B7C;;;;;;;;AAEqB;;;;;;KAhCTA,0BAA0BC,MAAMC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8BhCC;UACAH,UAAUC,GAAGC;UACbF,UAAUE,GAAGD"}

package/dist/utils/format.d.ts

@@ -0,0 +1,58 @@
+//#region src/utils/format.d.ts
+/**
+ * A function that converts data from one format to another.
+ *
+ * This is commonly used for transforming message content blocks between different
+ * provider-specific formats and standardized internal representations.
+ *
+ * @template T - The input type to convert from
+ * @template U - The output type to convert to
+ *
+ * @param input - The data to convert
+ * @returns The converted data in the target format
+ *
+ * @example
+ * ```typescript
+ * // Convert from OpenAI format to standard format
+ * const converter: Converter<OpenAIBlock, ContentBlock.Standard> = (block) => {
+ *   return { type: "text", text: block.text };
+ * };
+ * ```
+ */
+type Converter<T, U> = (input: T) => U;
+/**
+ * A pair of bidirectional conversion functions for transforming data between two formats.
+ *
+ * This type is used throughout the message system to enable conversion between
+ * provider-specific message formats (like OpenAI, Anthropic, Google, etc.) and
+ * standardized internal content block representations. The `encode` function
+ * typically converts from a standard format to a provider-specific format, while
+ * `decode` converts from a provider-specific format back to the standard format.
+ *
+ * @template T - The first format (typically the standard/internal format)
+ * @template U - The second format (typically the provider-specific format)
+ *
+ * @property encode - Converts from format T to format U
+ * @property decode - Converts from format U back to format T
+ *
+ * @example
+ * ```typescript
+ * // Converter pair for OpenAI message blocks
+ * const openAIConverter: ConverterPair<ContentBlock.Standard, OpenAIBlock> = {
+ *   encode: (standard) => ({ text: standard.text }),
+ *   decode: (openai) => ({ type: "text", text: openai.text })
+ * };
+ *
+ * // Usage
+ * const standardBlock = { type: "text", text: "Hello" };
+ * const openaiBlock = openAIConverter.encode(standardBlock);
+ * const backToStandard = openAIConverter.decode(openaiBlock);
+ * ```
+ */
+type ConverterPair<T, U> = {
+  encode: Converter<T, U>;
+  decode: Converter<U, T>;
+};
+//#endregion
+export { Converter, ConverterPair };
+//# sourceMappingURL=format.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","names":["Converter","T","U","ConverterPair"],"sources":["../../src/utils/format.d.ts"],"sourcesContent":["/**\n * A function that converts data from one format to another.\n *\n * This is commonly used for transforming message content blocks between different\n * provider-specific formats and standardized internal representations.\n *\n * @template T - The input type to convert from\n * @template U - The output type to convert to\n *\n * @param input - The data to convert\n * @returns The converted data in the target format\n *\n * @example\n * ```typescript\n * // Convert from OpenAI format to standard format\n * const converter: Converter<OpenAIBlock, ContentBlock.Standard> = (block) => {\n *   return { type: \"text\", text: block.text };\n * };\n * ```\n */\nexport type Converter<T, U> = (input: T) => U;\n/**\n * A pair of bidirectional conversion functions for transforming data between two formats.\n *\n * This type is used throughout the message system to enable conversion between\n * provider-specific message formats (like OpenAI, Anthropic, Google, etc.) and\n * standardized internal content block representations. The `encode` function\n * typically converts from a standard format to a provider-specific format, while\n * `decode` converts from a provider-specific format back to the standard format.\n *\n * @template T - The first format (typically the standard/internal format)\n * @template U - The second format (typically the provider-specific format)\n *\n * @property encode - Converts from format T to format U\n * @property decode - Converts from format U back to format T\n *\n * @example\n * ```typescript\n * // Converter pair for OpenAI message blocks\n * const openAIConverter: ConverterPair<ContentBlock.Standard, OpenAIBlock> = {\n *   encode: (standard) => ({ text: standard.text }),\n *   decode: (openai) => ({ type: \"text\", text: openai.text })\n * };\n *\n * // Usage\n * const standardBlock = { type: \"text\", text: \"Hello\" };\n * const openaiBlock = openAIConverter.encode(standardBlock);\n * const backToStandard = openAIConverter.decode(openaiBlock);\n * ```\n */\nexport type ConverterPair<T, U> = {\n    encode: Converter<T, U>;\n    decode: Converter<U, T>;\n};\n"],"mappings":";;AAoBA;;;;AAA6C;AA8B7C;;;;;;;;AAEqB;;;;;;KAhCTA,0BAA0BC,MAAMC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8BhCC;UACAH,UAAUC,GAAGC;UACbF,UAAUE,GAAGD"}

package/dist/utils/format.js

@@ -0,0 +1,6 @@
+//#region src/utils/format.ts
+var format_exports = {};
+
+//#endregion
+export { format_exports };
+//# sourceMappingURL=format.js.map

package/dist/utils/format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.js","names":[],"sources":["../../src/utils/format.ts"],"sourcesContent":["/**\n * A function that converts data from one format to another.\n *\n * This is commonly used for transforming message content blocks between different\n * provider-specific formats and standardized internal representations.\n *\n * @template T - The input type to convert from\n * @template U - The output type to convert to\n *\n * @param input - The data to convert\n * @returns The converted data in the target format\n *\n * @example\n * ```typescript\n * // Convert from OpenAI format to standard format\n * const converter: Converter<OpenAIBlock, ContentBlock.Standard> = (block) => {\n *   return { type: \"text\", text: block.text };\n * };\n * ```\n */\nexport type Converter<T, U> = (input: T) => U;\n\n/**\n * A pair of bidirectional conversion functions for transforming data between two formats.\n *\n * This type is used throughout the message system to enable conversion between\n * provider-specific message formats (like OpenAI, Anthropic, Google, etc.) and\n * standardized internal content block representations. The `encode` function\n * typically converts from a standard format to a provider-specific format, while\n * `decode` converts from a provider-specific format back to the standard format.\n *\n * @template T - The first format (typically the standard/internal format)\n * @template U - The second format (typically the provider-specific format)\n *\n * @property encode - Converts from format T to format U\n * @property decode - Converts from format U back to format T\n *\n * @example\n * ```typescript\n * // Converter pair for OpenAI message blocks\n * const openAIConverter: ConverterPair<ContentBlock.Standard, OpenAIBlock> = {\n *   encode: (standard) => ({ text: standard.text }),\n *   decode: (openai) => ({ type: \"text\", text: openai.text })\n * };\n *\n * // Usage\n * const standardBlock = { type: \"text\", text: \"Hello\" };\n * const openaiBlock = openAIConverter.encode(standardBlock);\n * const backToStandard = openAIConverter.decode(openaiBlock);\n * ```\n */\nexport type ConverterPair<T, U> = {\n  encode: Converter<T, U>;\n  decode: Converter<U, T>;\n};\n"],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {
@@ -589,6 +589,17 @@
         "default": "./dist/utils/event_source_parse.js"
       }
     },
+    "./utils/format": {
+      "input": "./src/utils/format.ts",
+      "require": {
+        "types": "./dist/utils/format.d.cts",
+        "default": "./dist/utils/format.cjs"
+      },
+      "import": {
+        "types": "./dist/utils/format.d.ts",
+        "default": "./dist/utils/format.js"
+      }
+    },
     "./utils/function_calling": {
       "input": "./src/utils/function_calling.ts",
       "require": {