@langchain/openai 1.1.1 → 1.1.3

package/dist/chat_models/index.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.cts","names":["CallbackManagerForLLMRun","AIMessageChunk","BaseMessage","ChatGenerationChunk","ChatResult","BaseLanguageModelInput","Runnable","OpenAICallOptions","OpenAIChatInput","ChatOpenAICompletions","ChatOpenAICompletionsCallOptions","ChatOpenAIResponses","ChatOpenAIResponsesCallOptions","BaseChatOpenAI","BaseChatOpenAIFields","ChatOpenAICallOptions","ChatOpenAIFields","ChatOpenAI","CallOptions","____________langchain_core_dist_language_models_chat_models_js0","LangSmithParams","Promise","AsyncGenerator","Partial"],"sources":["../../src/chat_models/index.d.ts"],"sourcesContent":["import { CallbackManagerForLLMRun } from \"@langchain/core/callbacks/manager\";\nimport { AIMessageChunk, type BaseMessage } from \"@langchain/core/messages\";\nimport { ChatGenerationChunk, type ChatResult } from \"@langchain/core/outputs\";\nimport { type BaseLanguageModelInput } from \"@langchain/core/language_models/base\";\nimport { Runnable } from \"@langchain/core/runnables\";\nimport { type OpenAICallOptions, type OpenAIChatInput } from \"../types.js\";\nimport { ChatOpenAICompletions, ChatOpenAICompletionsCallOptions } from \"./completions.js\";\nimport { ChatOpenAIResponses, ChatOpenAIResponsesCallOptions } from \"./responses.js\";\nimport { BaseChatOpenAI, BaseChatOpenAIFields } from \"./base.js\";\nexport type { OpenAICallOptions, OpenAIChatInput };\nexport type ChatOpenAICallOptions = ChatOpenAICompletionsCallOptions & ChatOpenAIResponsesCallOptions;\nexport interface ChatOpenAIFields extends BaseChatOpenAIFields {\n    /**\n     * Whether to use the responses API for all requests. If `false` the responses API will be used\n     * only when required in order to fulfill the request.\n     */\n    useResponsesApi?: boolean;\n    /**\n     * The completions chat instance\n     * @internal\n     */\n    completions?: ChatOpenAICompletions;\n    /**\n     * The responses chat instance\n     * @internal\n     */\n    responses?: ChatOpenAIResponses;\n}\n/**\n * OpenAI chat model integration.\n *\n * To use with Azure, import the `AzureChatOpenAI` class.\n *\n * Setup:\n * Install `@langchain/openai` and set an environment variable named `OPENAI_API_KEY`.\n *\n * ```bash\n * npm install @langchain/openai\n * export OPENAI_API_KEY=\"your-api-key\"\n * ```\n *\n * ## [Constructor args](https://api.js.langchain.com/classes/langchain_openai.ChatOpenAI.html#constructor)\n *\n * ## [Runtime args](https://api.js.langchain.com/interfaces/langchain_openai.ChatOpenAICallOptions.html)\n *\n * Runtime args can be passed as the second argument to any of the base runnable methods `.invoke`. `.stream`, `.batch`, etc.\n * They can also be passed via `.withConfig`, or the second arg in `.bindTools`, like shown in the examples below:\n *\n * ```typescript\n * // When calling `.withConfig`, call options should be passed via the first argument\n * const llmWithArgsBound = llm.withConfig({\n *   stop: [\"\\n\"],\n *   tools: [...],\n * });\n *\n * // When calling `.bindTools`, call options should be passed via the second argument\n * const llmWithTools = llm.bindTools(\n *   [...],\n *   {\n *     tool_choice: \"auto\",\n *   }\n * );\n * ```\n *\n * ## Examples\n *\n * <details open>\n * <summary><strong>Instantiate</strong></summary>\n *\n * ```typescript\n * import { ChatOpenAI } from '@langchain/openai';\n *\n * const llm = new ChatOpenAI({\n *   model: \"gpt-4o-mini\",\n *   temperature: 0,\n *   maxTokens: undefined,\n *   timeout: undefined,\n *   maxRetries: 2,\n *   // apiKey: \"...\",\n *   // configuration: {\n *   //   baseURL: \"...\",\n *   // }\n *   // organization: \"...\",\n *   // other params...\n * });\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Invoking</strong></summary>\n *\n * ```typescript\n * const input = `Translate \"I love programming\" into French.`;\n *\n * // Models also accept a list of chat messages or a formatted prompt\n * const result = await llm.invoke(input);\n * console.log(result);\n * ```\n *\n * ```txt\n * AIMessage {\n *   \"id\": \"chatcmpl-9u4Mpu44CbPjwYFkTbeoZgvzB00Tz\",\n *   \"content\": \"J'adore la programmation.\",\n *   \"response_metadata\": {\n *     \"tokenUsage\": {\n *       \"completionTokens\": 5,\n *       \"promptTokens\": 28,\n *       \"totalTokens\": 33\n *     },\n *     \"finish_reason\": \"stop\",\n *     \"system_fingerprint\": \"fp_3aa7262c27\"\n *   },\n *   \"usage_metadata\": {\n *     \"input_tokens\": 28,\n *     \"output_tokens\": 5,\n *     \"total_tokens\": 33\n *   }\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Streaming Chunks</strong></summary>\n *\n * ```typescript\n * for await (const chunk of await llm.stream(input)) {\n *   console.log(chunk);\n * }\n * ```\n *\n * ```txt\n * AIMessageChunk {\n *   \"id\": \"chatcmpl-9u4NWB7yUeHCKdLr6jP3HpaOYHTqs\",\n *   \"content\": \"\"\n * }\n * AIMessageChunk {\n *   \"content\": \"J\"\n * }\n * AIMessageChunk {\n *   \"content\": \"'adore\"\n * }\n * AIMessageChunk {\n *   \"content\": \" la\"\n * }\n * AIMessageChunk {\n *   \"content\": \" programmation\",,\n * }\n * AIMessageChunk {\n *   \"content\": \".\",,\n * }\n * AIMessageChunk {\n *   \"content\": \"\",\n *   \"response_metadata\": {\n *     \"finish_reason\": \"stop\",\n *     \"system_fingerprint\": \"fp_c9aa9c0491\"\n *   },\n * }\n * AIMessageChunk {\n *   \"content\": \"\",\n *   \"usage_metadata\": {\n *     \"input_tokens\": 28,\n *     \"output_tokens\": 5,\n *     \"total_tokens\": 33\n *   }\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Aggregate Streamed Chunks</strong></summary>\n *\n * ```typescript\n * import { AIMessageChunk } from '@langchain/core/messages';\n * import { concat } from '@langchain/core/utils/stream';\n *\n * const stream = await llm.stream(input);\n * let full: AIMessageChunk | undefined;\n * for await (const chunk of stream) {\n *   full = !full ? chunk : concat(full, chunk);\n * }\n * console.log(full);\n * ```\n *\n * ```txt\n * AIMessageChunk {\n *   \"id\": \"chatcmpl-9u4PnX6Fy7OmK46DASy0bH6cxn5Xu\",\n *   \"content\": \"J'adore la programmation.\",\n *   \"response_metadata\": {\n *     \"prompt\": 0,\n *     \"completion\": 0,\n *     \"finish_reason\": \"stop\",\n *   },\n *   \"usage_metadata\": {\n *     \"input_tokens\": 28,\n *     \"output_tokens\": 5,\n *     \"total_tokens\": 33\n *   }\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Bind tools</strong></summary>\n *\n * ```typescript\n * import { z } from 'zod';\n *\n * const GetWeather = {\n *   name: \"GetWeather\",\n *   description: \"Get the current weather in a given location\",\n *   schema: z.object({\n *     location: z.string().describe(\"The city and state, e.g. San Francisco, CA\")\n *   }),\n * }\n *\n * const GetPopulation = {\n *   name: \"GetPopulation\",\n *   description: \"Get the current population in a given location\",\n *   schema: z.object({\n *     location: z.string().describe(\"The city and state, e.g. San Francisco, CA\")\n *   }),\n * }\n *\n * const llmWithTools = llm.bindTools(\n *   [GetWeather, GetPopulation],\n *   {\n *     // strict: true  // enforce tool args schema is respected\n *   }\n * );\n * const aiMsg = await llmWithTools.invoke(\n *   \"Which city is hotter today and which is bigger: LA or NY?\"\n * );\n * console.log(aiMsg.tool_calls);\n * ```\n *\n * ```txt\n * [\n *   {\n *     name: 'GetWeather',\n *     args: { location: 'Los Angeles, CA' },\n *     type: 'tool_call',\n *     id: 'call_uPU4FiFzoKAtMxfmPnfQL6UK'\n *   },\n *   {\n *     name: 'GetWeather',\n *     args: { location: 'New York, NY' },\n *     type: 'tool_call',\n *     id: 'call_UNkEwuQsHrGYqgDQuH9nPAtX'\n *   },\n *   {\n *     name: 'GetPopulation',\n *     args: { location: 'Los Angeles, CA' },\n *     type: 'tool_call',\n *     id: 'call_kL3OXxaq9OjIKqRTpvjaCH14'\n *   },\n *   {\n *     name: 'GetPopulation',\n *     args: { location: 'New York, NY' },\n *     type: 'tool_call',\n *     id: 'call_s9KQB1UWj45LLGaEnjz0179q'\n *   }\n * ]\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Structured Output</strong></summary>\n *\n * ```typescript\n * import { z } from 'zod';\n *\n * const Joke = z.object({\n *   setup: z.string().describe(\"The setup of the joke\"),\n *   punchline: z.string().describe(\"The punchline to the joke\"),\n *   rating: z.number().nullable().describe(\"How funny the joke is, from 1 to 10\")\n * }).describe('Joke to tell user.');\n *\n * const structuredLlm = llm.withStructuredOutput(Joke, {\n *   name: \"Joke\",\n *   strict: true, // Optionally enable OpenAI structured outputs\n * });\n * const jokeResult = await structuredLlm.invoke(\"Tell me a joke about cats\");\n * console.log(jokeResult);\n * ```\n *\n * ```txt\n * {\n *   setup: 'Why was the cat sitting on the computer?',\n *   punchline: 'Because it wanted to keep an eye on the mouse!',\n *   rating: 7\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>JSON Object Response Format</strong></summary>\n *\n * ```typescript\n * const jsonLlm = llm.withConfig({ response_format: { type: \"json_object\" } });\n * const jsonLlmAiMsg = await jsonLlm.invoke(\n *   \"Return a JSON object with key 'randomInts' and a value of 10 random ints in [0-99]\"\n * );\n * console.log(jsonLlmAiMsg.content);\n * ```\n *\n * ```txt\n * {\n *   \"randomInts\": [23, 87, 45, 12, 78, 34, 56, 90, 11, 67]\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Multimodal</strong></summary>\n *\n * ```typescript\n * import { HumanMessage } from '@langchain/core/messages';\n *\n * const imageUrl = \"https://example.com/image.jpg\";\n * const imageData = await fetch(imageUrl).then(res => res.arrayBuffer());\n * const base64Image = Buffer.from(imageData).toString('base64');\n *\n * const message = new HumanMessage({\n *   content: [\n *     { type: \"text\", text: \"describe the weather in this image\" },\n *     {\n *       type: \"image_url\",\n *       image_url: { url: `data:image/jpeg;base64,${base64Image}` },\n *     },\n *   ]\n * });\n *\n * const imageDescriptionAiMsg = await llm.invoke([message]);\n * console.log(imageDescriptionAiMsg.content);\n * ```\n *\n * ```txt\n * The weather in the image appears to be clear and sunny. The sky is mostly blue with a few scattered white clouds, indicating fair weather. The bright sunlight is casting shadows on the green, grassy hill, suggesting it is a pleasant day with good visibility. There are no signs of rain or stormy conditions.\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Usage Metadata</strong></summary>\n *\n * ```typescript\n * const aiMsgForMetadata = await llm.invoke(input);\n * console.log(aiMsgForMetadata.usage_metadata);\n * ```\n *\n * ```txt\n * { input_tokens: 28, output_tokens: 5, total_tokens: 33 }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Logprobs</strong></summary>\n *\n * ```typescript\n * const logprobsLlm = new ChatOpenAI({ model: \"gpt-4o-mini\", logprobs: true });\n * const aiMsgForLogprobs = await logprobsLlm.invoke(input);\n * console.log(aiMsgForLogprobs.response_metadata.logprobs);\n * ```\n *\n * ```txt\n * {\n *   content: [\n *     {\n *       token: 'J',\n *       logprob: -0.000050616763,\n *       bytes: [Array],\n *       top_logprobs: []\n *     },\n *     {\n *       token: \"'\",\n *       logprob: -0.01868736,\n *       bytes: [Array],\n *       top_logprobs: []\n *     },\n *     {\n *       token: 'ad',\n *       logprob: -0.0000030545007,\n *       bytes: [Array],\n *       top_logprobs: []\n *     },\n *     { token: 'ore', logprob: 0, bytes: [Array], top_logprobs: [] },\n *     {\n *       token: ' la',\n *       logprob: -0.515404,\n *       bytes: [Array],\n *       top_logprobs: []\n *     },\n *     {\n *       token: ' programm',\n *       logprob: -0.0000118755715,\n *       bytes: [Array],\n *       top_logprobs: []\n *     },\n *     { token: 'ation', logprob: 0, bytes: [Array], top_logprobs: [] },\n *     {\n *       token: '.',\n *       logprob: -0.0000037697225,\n *       bytes: [Array],\n *       top_logprobs: []\n *     }\n *   ],\n *   refusal: null\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Response Metadata</strong></summary>\n *\n * ```typescript\n * const aiMsgForResponseMetadata = await llm.invoke(input);\n * console.log(aiMsgForResponseMetadata.response_metadata);\n * ```\n *\n * ```txt\n * {\n *   tokenUsage: { completionTokens: 5, promptTokens: 28, totalTokens: 33 },\n *   finish_reason: 'stop',\n *   system_fingerprint: 'fp_3aa7262c27'\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>JSON Schema Structured Output</strong></summary>\n *\n * ```typescript\n * const llmForJsonSchema = new ChatOpenAI({\n *   model: \"gpt-4o-2024-08-06\",\n * }).withStructuredOutput(\n *   z.object({\n *     command: z.string().describe(\"The command to execute\"),\n *     expectedOutput: z.string().describe(\"The expected output of the command\"),\n *     options: z\n *       .array(z.string())\n *       .describe(\"The options you can pass to the command\"),\n *   }),\n *   {\n *     method: \"jsonSchema\",\n *     strict: true, // Optional when using the `jsonSchema` method\n *   }\n * );\n *\n * const jsonSchemaRes = await llmForJsonSchema.invoke(\n *   \"What is the command to list files in a directory?\"\n * );\n * console.log(jsonSchemaRes);\n * ```\n *\n * ```txt\n * {\n *   command: 'ls',\n *   expectedOutput: 'A list of files and subdirectories within the specified directory.',\n *   options: [\n *     '-a: include directory entries whose names begin with a dot (.).',\n *     '-l: use a long listing format.',\n *     '-h: with -l, print sizes in human readable format (e.g., 1K, 234M, 2G).',\n *     '-t: sort by time, newest first.',\n *     '-r: reverse order while sorting.',\n *     '-S: sort by file size, largest first.',\n *     '-R: list subdirectories recursively.'\n *   ]\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Audio Outputs</strong></summary>\n *\n * ```typescript\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * const modelWithAudioOutput = new ChatOpenAI({\n *   model: \"gpt-4o-audio-preview\",\n *   // You may also pass these fields to `.withConfig` as a call argument.\n *   modalities: [\"text\", \"audio\"], // Specifies that the model should output audio.\n *   audio: {\n *     voice: \"alloy\",\n *     format: \"wav\",\n *   },\n * });\n *\n * const audioOutputResult = await modelWithAudioOutput.invoke(\"Tell me a joke about cats.\");\n * const castMessageContent = audioOutputResult.content[0] as Record<string, any>;\n *\n * console.log({\n *   ...castMessageContent,\n *   data: castMessageContent.data.slice(0, 100) // Sliced for brevity\n * })\n * ```\n *\n * ```txt\n * {\n *   id: 'audio_67117718c6008190a3afad3e3054b9b6',\n *   data: 'UklGRqYwBgBXQVZFZm10IBAAAAABAAEAwF0AAIC7AAACABAATElTVBoAAABJTkZPSVNGVA4AAABMYXZmNTguMjkuMTAwAGRhdGFg',\n *   expires_at: 1729201448,\n *   transcript: 'Sure! Why did the cat sit on the computer? Because it wanted to keep an eye on the mouse!'\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Audio Outputs</strong></summary>\n *\n * ```typescript\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * const modelWithAudioOutput = new ChatOpenAI({\n *   model: \"gpt-4o-audio-preview\",\n *   // You may also pass these fields to `.withConfig` as a call argument.\n *   modalities: [\"text\", \"audio\"], // Specifies that the model should output audio.\n *   audio: {\n *     voice: \"alloy\",\n *     format: \"wav\",\n *   },\n * });\n *\n * const audioOutputResult = await modelWithAudioOutput.invoke(\"Tell me a joke about cats.\");\n * const castAudioContent = audioOutputResult.additional_kwargs.audio as Record<string, any>;\n *\n * console.log({\n *   ...castAudioContent,\n *   data: castAudioContent.data.slice(0, 100) // Sliced for brevity\n * })\n * ```\n *\n * ```txt\n * {\n *   id: 'audio_67117718c6008190a3afad3e3054b9b6',\n *   data: 'UklGRqYwBgBXQVZFZm10IBAAAAABAAEAwF0AAIC7AAACABAATElTVBoAAABJTkZPSVNGVA4AAABMYXZmNTguMjkuMTAwAGRhdGFg',\n *   expires_at: 1729201448,\n *   transcript: 'Sure! Why did the cat sit on the computer? Because it wanted to keep an eye on the mouse!'\n * }\n * ```\n * </details>\n *\n * <br />\n */\nexport declare class ChatOpenAI<CallOptions extends ChatOpenAICallOptions = ChatOpenAICallOptions> extends BaseChatOpenAI<CallOptions> {\n    protected fields?: ChatOpenAIFields | undefined;\n    /**\n     * Whether to use the responses API for all requests. If `false` the responses API will be used\n     * only when required in order to fulfill the request.\n     */\n    useResponsesApi: boolean;\n    protected responses: ChatOpenAIResponses;\n    protected completions: ChatOpenAICompletions;\n    get lc_serializable_keys(): string[];\n    get callKeys(): string[];\n    constructor(fields?: ChatOpenAIFields | undefined);\n    protected _useResponsesApi(options: this[\"ParsedCallOptions\"] | undefined): boolean | undefined;\n    getLsParams(options: this[\"ParsedCallOptions\"]): import(\"../../../../langchain-core/dist/language_models/chat_models.js\").LangSmithParams;\n    invocationParams(options?: this[\"ParsedCallOptions\"]): any;\n    /** @ignore */\n    _generate(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;\n    _streamResponseChunks(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;\n    withConfig(config: Partial<CallOptions>): Runnable<BaseLanguageModelInput, AIMessageChunk, CallOptions>;\n}\n"],"mappings":";;;;;;;;;;;;KAUYe,qBAAAA,GAAwBL,mCAAmCE;UACtDI,gBAAAA,SAAyBF;EAD9BC;;;;EAAyF,eAAA,CAAA,EAAA,OAAA;EACpFC;;;;EAekB,WAfOF,CAAAA,EAUxBL,qBAVwBK;EAAoB;AA6iB9D;;;EAAyE,SAAGC,CAAAA,EA9hB5DJ,mBA8hB4DI;;;;;;;;;;;;;;;;;;;;;;AAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAApGE,+BAA+BF,wBAAwBA,+BAA+BF,eAAeK;qBACnGF;;;;;;uBAMEL;yBACEF;;;uBAGFO;;mDAAgB;;;sBAKjBd,gEAAgEF,2BAA2BqB,QAAQjB;kCACvFF,gEAAgEF,2BAA2BsB,eAAenB;qBACvHoB,QAAQL,eAAeZ,SAASD,wBAAwBJ,gBAAgBiB"}

package/dist/chat_models/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":["CallbackManagerForLLMRun","AIMessageChunk","BaseMessage","ChatGenerationChunk","ChatResult","BaseLanguageModelInput","Runnable","OpenAICallOptions","OpenAIChatInput","ChatOpenAICompletions","ChatOpenAICompletionsCallOptions","ChatOpenAIResponses","ChatOpenAIResponsesCallOptions","BaseChatOpenAI","BaseChatOpenAIFields","ChatOpenAICallOptions","ChatOpenAIFields","ChatOpenAI","CallOptions","____________langchain_core_dist_language_models_chat_models_js0","LangSmithParams","Promise","AsyncGenerator","Partial"],"sources":["../../src/chat_models/index.d.ts"],"sourcesContent":["import { CallbackManagerForLLMRun } from \"@langchain/core/callbacks/manager\";\nimport { AIMessageChunk, type BaseMessage } from \"@langchain/core/messages\";\nimport { ChatGenerationChunk, type ChatResult } from \"@langchain/core/outputs\";\nimport { type BaseLanguageModelInput } from \"@langchain/core/language_models/base\";\nimport { Runnable } from \"@langchain/core/runnables\";\nimport { type OpenAICallOptions, type OpenAIChatInput } from \"../types.js\";\nimport { ChatOpenAICompletions, ChatOpenAICompletionsCallOptions } from \"./completions.js\";\nimport { ChatOpenAIResponses, ChatOpenAIResponsesCallOptions } from \"./responses.js\";\nimport { BaseChatOpenAI, BaseChatOpenAIFields } from \"./base.js\";\nexport type { OpenAICallOptions, OpenAIChatInput };\nexport type ChatOpenAICallOptions = ChatOpenAICompletionsCallOptions & ChatOpenAIResponsesCallOptions;\nexport interface ChatOpenAIFields extends BaseChatOpenAIFields {\n    /**\n     * Whether to use the responses API for all requests. If `false` the responses API will be used\n     * only when required in order to fulfill the request.\n     */\n    useResponsesApi?: boolean;\n    /**\n     * The completions chat instance\n     * @internal\n     */\n    completions?: ChatOpenAICompletions;\n    /**\n     * The responses chat instance\n     * @internal\n     */\n    responses?: ChatOpenAIResponses;\n}\n/**\n * OpenAI chat model integration.\n *\n * To use with Azure, import the `AzureChatOpenAI` class.\n *\n * Setup:\n * Install `@langchain/openai` and set an environment variable named `OPENAI_API_KEY`.\n *\n * ```bash\n * npm install @langchain/openai\n * export OPENAI_API_KEY=\"your-api-key\"\n * ```\n *\n * ## [Constructor args](https://api.js.langchain.com/classes/langchain_openai.ChatOpenAI.html#constructor)\n *\n * ## [Runtime args](https://api.js.langchain.com/interfaces/langchain_openai.ChatOpenAICallOptions.html)\n *\n * Runtime args can be passed as the second argument to any of the base runnable methods `.invoke`. `.stream`, `.batch`, etc.\n * They can also be passed via `.withConfig`, or the second arg in `.bindTools`, like shown in the examples below:\n *\n * ```typescript\n * // When calling `.withConfig`, call options should be passed via the first argument\n * const llmWithArgsBound = llm.withConfig({\n *   stop: [\"\\n\"],\n *   tools: [...],\n * });\n *\n * // When calling `.bindTools`, call options should be passed via the second argument\n * const llmWithTools = llm.bindTools(\n *   [...],\n *   {\n *     tool_choice: \"auto\",\n *   }\n * );\n * ```\n *\n * ## Examples\n *\n * <details open>\n * <summary><strong>Instantiate</strong></summary>\n *\n * ```typescript\n * import { ChatOpenAI } from '@langchain/openai';\n *\n * const llm = new ChatOpenAI({\n *   model: \"gpt-4o-mini\",\n *   temperature: 0,\n *   maxTokens: undefined,\n *   timeout: undefined,\n *   maxRetries: 2,\n *   // apiKey: \"...\",\n *   // configuration: {\n *   //   baseURL: \"...\",\n *   // }\n *   // organization: \"...\",\n *   // other params...\n * });\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Invoking</strong></summary>\n *\n * ```typescript\n * const input = `Translate \"I love programming\" into French.`;\n *\n * // Models also accept a list of chat messages or a formatted prompt\n * const result = await llm.invoke(input);\n * console.log(result);\n * ```\n *\n * ```txt\n * AIMessage {\n *   \"id\": \"chatcmpl-9u4Mpu44CbPjwYFkTbeoZgvzB00Tz\",\n *   \"content\": \"J'adore la programmation.\",\n *   \"response_metadata\": {\n *     \"tokenUsage\": {\n *       \"completionTokens\": 5,\n *       \"promptTokens\": 28,\n *       \"totalTokens\": 33\n *     },\n *     \"finish_reason\": \"stop\",\n *     \"system_fingerprint\": \"fp_3aa7262c27\"\n *   },\n *   \"usage_metadata\": {\n *     \"input_tokens\": 28,\n *     \"output_tokens\": 5,\n *     \"total_tokens\": 33\n *   }\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Streaming Chunks</strong></summary>\n *\n * ```typescript\n * for await (const chunk of await llm.stream(input)) {\n *   console.log(chunk);\n * }\n * ```\n *\n * ```txt\n * AIMessageChunk {\n *   \"id\": \"chatcmpl-9u4NWB7yUeHCKdLr6jP3HpaOYHTqs\",\n *   \"content\": \"\"\n * }\n * AIMessageChunk {\n *   \"content\": \"J\"\n * }\n * AIMessageChunk {\n *   \"content\": \"'adore\"\n * }\n * AIMessageChunk {\n *   \"content\": \" la\"\n * }\n * AIMessageChunk {\n *   \"content\": \" programmation\",,\n * }\n * AIMessageChunk {\n *   \"content\": \".\",,\n * }\n * AIMessageChunk {\n *   \"content\": \"\",\n *   \"response_metadata\": {\n *     \"finish_reason\": \"stop\",\n *     \"system_fingerprint\": \"fp_c9aa9c0491\"\n *   },\n * }\n * AIMessageChunk {\n *   \"content\": \"\",\n *   \"usage_metadata\": {\n *     \"input_tokens\": 28,\n *     \"output_tokens\": 5,\n *     \"total_tokens\": 33\n *   }\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Aggregate Streamed Chunks</strong></summary>\n *\n * ```typescript\n * import { AIMessageChunk } from '@langchain/core/messages';\n * import { concat } from '@langchain/core/utils/stream';\n *\n * const stream = await llm.stream(input);\n * let full: AIMessageChunk | undefined;\n * for await (const chunk of stream) {\n *   full = !full ? chunk : concat(full, chunk);\n * }\n * console.log(full);\n * ```\n *\n * ```txt\n * AIMessageChunk {\n *   \"id\": \"chatcmpl-9u4PnX6Fy7OmK46DASy0bH6cxn5Xu\",\n *   \"content\": \"J'adore la programmation.\",\n *   \"response_metadata\": {\n *     \"prompt\": 0,\n *     \"completion\": 0,\n *     \"finish_reason\": \"stop\",\n *   },\n *   \"usage_metadata\": {\n *     \"input_tokens\": 28,\n *     \"output_tokens\": 5,\n *     \"total_tokens\": 33\n *   }\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Bind tools</strong></summary>\n *\n * ```typescript\n * import { z } from 'zod';\n *\n * const GetWeather = {\n *   name: \"GetWeather\",\n *   description: \"Get the current weather in a given location\",\n *   schema: z.object({\n *     location: z.string().describe(\"The city and state, e.g. San Francisco, CA\")\n *   }),\n * }\n *\n * const GetPopulation = {\n *   name: \"GetPopulation\",\n *   description: \"Get the current population in a given location\",\n *   schema: z.object({\n *     location: z.string().describe(\"The city and state, e.g. San Francisco, CA\")\n *   }),\n * }\n *\n * const llmWithTools = llm.bindTools(\n *   [GetWeather, GetPopulation],\n *   {\n *     // strict: true  // enforce tool args schema is respected\n *   }\n * );\n * const aiMsg = await llmWithTools.invoke(\n *   \"Which city is hotter today and which is bigger: LA or NY?\"\n * );\n * console.log(aiMsg.tool_calls);\n * ```\n *\n * ```txt\n * [\n *   {\n *     name: 'GetWeather',\n *     args: { location: 'Los Angeles, CA' },\n *     type: 'tool_call',\n *     id: 'call_uPU4FiFzoKAtMxfmPnfQL6UK'\n *   },\n *   {\n *     name: 'GetWeather',\n *     args: { location: 'New York, NY' },\n *     type: 'tool_call',\n *     id: 'call_UNkEwuQsHrGYqgDQuH9nPAtX'\n *   },\n *   {\n *     name: 'GetPopulation',\n *     args: { location: 'Los Angeles, CA' },\n *     type: 'tool_call',\n *     id: 'call_kL3OXxaq9OjIKqRTpvjaCH14'\n *   },\n *   {\n *     name: 'GetPopulation',\n *     args: { location: 'New York, NY' },\n *     type: 'tool_call',\n *     id: 'call_s9KQB1UWj45LLGaEnjz0179q'\n *   }\n * ]\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Structured Output</strong></summary>\n *\n * ```typescript\n * import { z } from 'zod';\n *\n * const Joke = z.object({\n *   setup: z.string().describe(\"The setup of the joke\"),\n *   punchline: z.string().describe(\"The punchline to the joke\"),\n *   rating: z.number().nullable().describe(\"How funny the joke is, from 1 to 10\")\n * }).describe('Joke to tell user.');\n *\n * const structuredLlm = llm.withStructuredOutput(Joke, {\n *   name: \"Joke\",\n *   strict: true, // Optionally enable OpenAI structured outputs\n * });\n * const jokeResult = await structuredLlm.invoke(\"Tell me a joke about cats\");\n * console.log(jokeResult);\n * ```\n *\n * ```txt\n * {\n *   setup: 'Why was the cat sitting on the computer?',\n *   punchline: 'Because it wanted to keep an eye on the mouse!',\n *   rating: 7\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>JSON Object Response Format</strong></summary>\n *\n * ```typescript\n * const jsonLlm = llm.withConfig({ response_format: { type: \"json_object\" } });\n * const jsonLlmAiMsg = await jsonLlm.invoke(\n *   \"Return a JSON object with key 'randomInts' and a value of 10 random ints in [0-99]\"\n * );\n * console.log(jsonLlmAiMsg.content);\n * ```\n *\n * ```txt\n * {\n *   \"randomInts\": [23, 87, 45, 12, 78, 34, 56, 90, 11, 67]\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Multimodal</strong></summary>\n *\n * ```typescript\n * import { HumanMessage } from '@langchain/core/messages';\n *\n * const imageUrl = \"https://example.com/image.jpg\";\n * const imageData = await fetch(imageUrl).then(res => res.arrayBuffer());\n * const base64Image = Buffer.from(imageData).toString('base64');\n *\n * const message = new HumanMessage({\n *   content: [\n *     { type: \"text\", text: \"describe the weather in this image\" },\n *     {\n *       type: \"image_url\",\n *       image_url: { url: `data:image/jpeg;base64,${base64Image}` },\n *     },\n *   ]\n * });\n *\n * const imageDescriptionAiMsg = await llm.invoke([message]);\n * console.log(imageDescriptionAiMsg.content);\n * ```\n *\n * ```txt\n * The weather in the image appears to be clear and sunny. The sky is mostly blue with a few scattered white clouds, indicating fair weather. The bright sunlight is casting shadows on the green, grassy hill, suggesting it is a pleasant day with good visibility. There are no signs of rain or stormy conditions.\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Usage Metadata</strong></summary>\n *\n * ```typescript\n * const aiMsgForMetadata = await llm.invoke(input);\n * console.log(aiMsgForMetadata.usage_metadata);\n * ```\n *\n * ```txt\n * { input_tokens: 28, output_tokens: 5, total_tokens: 33 }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Logprobs</strong></summary>\n *\n * ```typescript\n * const logprobsLlm = new ChatOpenAI({ model: \"gpt-4o-mini\", logprobs: true });\n * const aiMsgForLogprobs = await logprobsLlm.invoke(input);\n * console.log(aiMsgForLogprobs.response_metadata.logprobs);\n * ```\n *\n * ```txt\n * {\n *   content: [\n *     {\n *       token: 'J',\n *       logprob: -0.000050616763,\n *       bytes: [Array],\n *       top_logprobs: []\n *     },\n *     {\n *       token: \"'\",\n *       logprob: -0.01868736,\n *       bytes: [Array],\n *       top_logprobs: []\n *     },\n *     {\n *       token: 'ad',\n *       logprob: -0.0000030545007,\n *       bytes: [Array],\n *       top_logprobs: []\n *     },\n *     { token: 'ore', logprob: 0, bytes: [Array], top_logprobs: [] },\n *     {\n *       token: ' la',\n *       logprob: -0.515404,\n *       bytes: [Array],\n *       top_logprobs: []\n *     },\n *     {\n *       token: ' programm',\n *       logprob: -0.0000118755715,\n *       bytes: [Array],\n *       top_logprobs: []\n *     },\n *     { token: 'ation', logprob: 0, bytes: [Array], top_logprobs: [] },\n *     {\n *       token: '.',\n *       logprob: -0.0000037697225,\n *       bytes: [Array],\n *       top_logprobs: []\n *     }\n *   ],\n *   refusal: null\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Response Metadata</strong></summary>\n *\n * ```typescript\n * const aiMsgForResponseMetadata = await llm.invoke(input);\n * console.log(aiMsgForResponseMetadata.response_metadata);\n * ```\n *\n * ```txt\n * {\n *   tokenUsage: { completionTokens: 5, promptTokens: 28, totalTokens: 33 },\n *   finish_reason: 'stop',\n *   system_fingerprint: 'fp_3aa7262c27'\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>JSON Schema Structured Output</strong></summary>\n *\n * ```typescript\n * const llmForJsonSchema = new ChatOpenAI({\n *   model: \"gpt-4o-2024-08-06\",\n * }).withStructuredOutput(\n *   z.object({\n *     command: z.string().describe(\"The command to execute\"),\n *     expectedOutput: z.string().describe(\"The expected output of the command\"),\n *     options: z\n *       .array(z.string())\n *       .describe(\"The options you can pass to the command\"),\n *   }),\n *   {\n *     method: \"jsonSchema\",\n *     strict: true, // Optional when using the `jsonSchema` method\n *   }\n * );\n *\n * const jsonSchemaRes = await llmForJsonSchema.invoke(\n *   \"What is the command to list files in a directory?\"\n * );\n * console.log(jsonSchemaRes);\n * ```\n *\n * ```txt\n * {\n *   command: 'ls',\n *   expectedOutput: 'A list of files and subdirectories within the specified directory.',\n *   options: [\n *     '-a: include directory entries whose names begin with a dot (.).',\n *     '-l: use a long listing format.',\n *     '-h: with -l, print sizes in human readable format (e.g., 1K, 234M, 2G).',\n *     '-t: sort by time, newest first.',\n *     '-r: reverse order while sorting.',\n *     '-S: sort by file size, largest first.',\n *     '-R: list subdirectories recursively.'\n *   ]\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Audio Outputs</strong></summary>\n *\n * ```typescript\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * const modelWithAudioOutput = new ChatOpenAI({\n *   model: \"gpt-4o-audio-preview\",\n *   // You may also pass these fields to `.withConfig` as a call argument.\n *   modalities: [\"text\", \"audio\"], // Specifies that the model should output audio.\n *   audio: {\n *     voice: \"alloy\",\n *     format: \"wav\",\n *   },\n * });\n *\n * const audioOutputResult = await modelWithAudioOutput.invoke(\"Tell me a joke about cats.\");\n * const castMessageContent = audioOutputResult.content[0] as Record<string, any>;\n *\n * console.log({\n *   ...castMessageContent,\n *   data: castMessageContent.data.slice(0, 100) // Sliced for brevity\n * })\n * ```\n *\n * ```txt\n * {\n *   id: 'audio_67117718c6008190a3afad3e3054b9b6',\n *   data: 'UklGRqYwBgBXQVZFZm10IBAAAAABAAEAwF0AAIC7AAACABAATElTVBoAAABJTkZPSVNGVA4AAABMYXZmNTguMjkuMTAwAGRhdGFg',\n *   expires_at: 1729201448,\n *   transcript: 'Sure! Why did the cat sit on the computer? Because it wanted to keep an eye on the mouse!'\n * }\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Audio Outputs</strong></summary>\n *\n * ```typescript\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * const modelWithAudioOutput = new ChatOpenAI({\n *   model: \"gpt-4o-audio-preview\",\n *   // You may also pass these fields to `.withConfig` as a call argument.\n *   modalities: [\"text\", \"audio\"], // Specifies that the model should output audio.\n *   audio: {\n *     voice: \"alloy\",\n *     format: \"wav\",\n *   },\n * });\n *\n * const audioOutputResult = await modelWithAudioOutput.invoke(\"Tell me a joke about cats.\");\n * const castAudioContent = audioOutputResult.additional_kwargs.audio as Record<string, any>;\n *\n * console.log({\n *   ...castAudioContent,\n *   data: castAudioContent.data.slice(0, 100) // Sliced for brevity\n * })\n * ```\n *\n * ```txt\n * {\n *   id: 'audio_67117718c6008190a3afad3e3054b9b6',\n *   data: 'UklGRqYwBgBXQVZFZm10IBAAAAABAAEAwF0AAIC7AAACABAATElTVBoAAABJTkZPSVNGVA4AAABMYXZmNTguMjkuMTAwAGRhdGFg',\n *   expires_at: 1729201448,\n *   transcript: 'Sure! Why did the cat sit on the computer? Because it wanted to keep an eye on the mouse!'\n * }\n * ```\n * </details>\n *\n * <br />\n */\nexport declare class ChatOpenAI<CallOptions extends ChatOpenAICallOptions = ChatOpenAICallOptions> extends BaseChatOpenAI<CallOptions> {\n    protected fields?: ChatOpenAIFields | undefined;\n    /**\n     * Whether to use the responses API for all requests. If `false` the responses API will be used\n     * only when required in order to fulfill the request.\n     */\n    useResponsesApi: boolean;\n    protected responses: ChatOpenAIResponses;\n    protected completions: ChatOpenAICompletions;\n    get lc_serializable_keys(): string[];\n    get callKeys(): string[];\n    constructor(fields?: ChatOpenAIFields | undefined);\n    protected _useResponsesApi(options: this[\"ParsedCallOptions\"] | undefined): boolean | undefined;\n    getLsParams(options: this[\"ParsedCallOptions\"]): import(\"../../../../langchain-core/dist/language_models/chat_models.js\").LangSmithParams;\n    invocationParams(options?: this[\"ParsedCallOptions\"]): any;\n    /** @ignore */\n    _generate(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;\n    _streamResponseChunks(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;\n    withConfig(config: Partial<CallOptions>): Runnable<BaseLanguageModelInput, AIMessageChunk, CallOptions>;\n}\n"],"mappings":";;;;;;;;;;;;KAUYe,qBAAAA,GAAwBL,mCAAmCE;UACtDI,gBAAAA,SAAyBF;EAD9BC;;;;EAAyF,eAAA,CAAA,EAAA,OAAA;EACpFC;;;;EAekB,WAfOF,CAAAA,EAUxBL,qBAVwBK;EAAoB;AA6iB9D;;;EAAyE,SAAGC,CAAAA,EA9hB5DJ,mBA8hB4DI;;;;;;;;;;;;;;;;;;;;;;AAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAApGE,+BAA+BF,wBAAwBA,+BAA+BF,eAAeK;qBACnGF;;;;;;uBAMEL;yBACEF;;;uBAGFO;;mDAAgB;;;sBAKjBd,gEAAgEF,2BAA2BqB,QAAQjB;kCACvFF,gEAAgEF,2BAA2BsB,eAAenB;qBACvHoB,QAAQL,eAAeZ,SAASD,wBAAwBJ,gBAAgBiB"}

package/dist/chat_models/responses.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"responses.d.cts","names":["OpenAI","OpenAIClient","CallbackManagerForLLMRun","BaseMessage","ChatGenerationChunk","ChatResult","ChatOpenAIToolType","ResponsesTool","BaseChatOpenAI","BaseChatOpenAICallOptions","OpenAIVerbosityParam","ChatOpenAIResponsesCallOptions","Responses","ResponseCreateParams","ChatResponsesInvocationParams","Omit","ChatOpenAIResponses","CallOptions","Promise","AsyncGenerator","ResponseCreateParamsStreaming","RequestOptions","ResponseStreamEvent","AsyncIterable","ResponseCreateParamsNonStreaming","Response"],"sources":["../../src/chat_models/responses.d.ts"],"sourcesContent":["import { OpenAI as OpenAIClient } from \"openai\";\nimport { CallbackManagerForLLMRun } from \"@langchain/core/callbacks/manager\";\nimport { type BaseMessage } from \"@langchain/core/messages\";\nimport { ChatGenerationChunk, type ChatResult } from \"@langchain/core/outputs\";\nimport { ChatOpenAIToolType, ResponsesTool } from \"../utils/tools.js\";\nimport { BaseChatOpenAI, BaseChatOpenAICallOptions } from \"./base.js\";\nimport { OpenAIVerbosityParam } from \"../types.js\";\nexport interface ChatOpenAIResponsesCallOptions extends BaseChatOpenAICallOptions {\n    /**\n     * Configuration options for a text response from the model. Can be plain text or\n     * structured JSON data.\n     */\n    text?: OpenAIClient.Responses.ResponseCreateParams[\"text\"];\n    /**\n     * The truncation strategy to use for the model response.\n     */\n    truncation?: OpenAIClient.Responses.ResponseCreateParams[\"truncation\"];\n    /**\n     * Specify additional output data to include in the model response.\n     */\n    include?: OpenAIClient.Responses.ResponseCreateParams[\"include\"];\n    /**\n     * The unique ID of the previous response to the model. Use this to create multi-turn\n     * conversations.\n     */\n    previous_response_id?: OpenAIClient.Responses.ResponseCreateParams[\"previous_response_id\"];\n    /**\n     * The verbosity of the model's response.\n     */\n    verbosity?: OpenAIVerbosityParam;\n}\nexport type ChatResponsesInvocationParams = Omit<OpenAIClient.Responses.ResponseCreateParams, \"input\">;\n/**\n * OpenAI Responses API implementation.\n *\n * Will be exported in a later version of @langchain/openai.\n *\n * @internal\n */\nexport declare class ChatOpenAIResponses<CallOptions extends ChatOpenAIResponsesCallOptions = ChatOpenAIResponsesCallOptions> extends BaseChatOpenAI<CallOptions> {\n    invocationParams(options?: this[\"ParsedCallOptions\"]): ChatResponsesInvocationParams;\n    _generate(messages: BaseMessage[], options: this[\"ParsedCallOptions\"]): Promise<ChatResult>;\n    _streamResponseChunks(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;\n    /**\n     * Calls the Responses API with retry logic in case of failures.\n     * @param request The request to send to the OpenAI API.\n     * @param options Optional configuration for the API call.\n     * @returns The response from the OpenAI API.\n     */\n    completionWithRetry(request: OpenAIClient.Responses.ResponseCreateParamsStreaming, requestOptions?: OpenAIClient.RequestOptions): Promise<AsyncIterable<OpenAIClient.Responses.ResponseStreamEvent>>;\n    completionWithRetry(request: OpenAIClient.Responses.ResponseCreateParamsNonStreaming, requestOptions?: OpenAIClient.RequestOptions): Promise<OpenAIClient.Responses.Response>;\n    /** @internal */\n    protected _reduceChatOpenAITools(tools: ChatOpenAIToolType[], fields: {\n        stream?: boolean;\n        strict?: boolean;\n    }): ResponsesTool[];\n}\n"],"mappings":";;;;;;;;;UAOiBW,8BAAAA,SAAuCF;;AAAxD;;;EAKsD,IAIrCR,CAAAA,EAJNA,QAAAA,CAAaW,SAAAA,CAAUC,oBAIMA,CAAAA,MAAAA,CAAAA;EAAoB;;;EAaxB,UAtBoBJ,CAAAA,EASvCR,QAAAA,CAAaW,SAAAA,CAAUC,oBATgBJ,CAAAA,YAAAA,CAAAA;EAAyB;AAwBjF;;EAAyC,OAAQR,CAAAA,EAXnCA,QAAAA,CAAaW,SAAAA,CAAUC,oBAWmCA,CAAAA,SAAAA,CAAAA;EAAoB;AAA5C;AAQhD;;EAAwC,oBAAqBF,CAAAA,EAdlCV,QAAAA,CAAaW,SAAAA,CAAUC,oBAcWF,CAAAA,sBAAAA,CAAAA;EAA8B;;;EACH,SAChER,CAAAA,EAZRO,oBAYQP;;AAAoDe,KAVhEJ,6BAAAA,GAAgCC,IAUgCG,CAV3BjB,QAAAA,CAAaW,SAAAA,CAAUC,oBAUIK,EAAAA,OAAAA,CAAAA;;;;;;;;AAQkEK,cAVzHP,mBAUyHO,CAAAA,oBAVjFZ,8BAUiFY,GAVhDZ,8BAUgDY,CAAAA,SAVRf,cAUQe,CAVON,WAUPM,CAAAA,CAAAA;EAAa,gBAArBL,CAAAA,OAAAA,CAAAA,EAAAA,IAAAA,CAAAA,mBAAAA,CAAAA,CAAAA,EAT3EJ,6BAS2EI;EAAO,SAC5GjB,CAAAA,QAAaW,EATtBT,WASgCqB,EAAAA,EAAAA,OAAAA,EAAAA,IAAAA,CAAAA,mBAAAA,CAAAA,CAAAA,EAToBN,OASpBM,CAT4BnB,UAS5BmB,CAAAA;EAAgC,qBAAgCH,CAAAA,QAAAA,EARpFlB,WAQoFkB,EAAAA,EAAAA,OAAAA,EAAAA,IAAAA,CAAAA,mBAAAA,CAAAA,EAAAA,UAAAA,CAAAA,EARpBnB,wBAQoBmB,CAAAA,EAROF,cAQPE,CARsBjB,mBAQtBiB,CAAAA;EAAc;;;;;AAXc;+BAUnHpB,QAAAA,CAAaW,SAAAA,CAAUQ,gDAAgDnB,QAAAA,CAAaoB,iBAAiBH,QAAQK,cAActB,QAAAA,CAAaW,SAAAA,CAAUU;+BAClJrB,QAAAA,CAAaW,SAAAA,CAAUY,mDAAmDvB,QAAAA,CAAaoB,iBAAiBH,QAAQjB,QAAAA,CAAaW,SAAAA,CAAUa;;0CAE5HnB;;;MAGpCC"}

package/dist/chat_models/responses.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"responses.d.ts","names":["OpenAI","OpenAIClient","CallbackManagerForLLMRun","BaseMessage","ChatGenerationChunk","ChatResult","ChatOpenAIToolType","ResponsesTool","BaseChatOpenAI","BaseChatOpenAICallOptions","OpenAIVerbosityParam","ChatOpenAIResponsesCallOptions","Responses","ResponseCreateParams","ChatResponsesInvocationParams","Omit","ChatOpenAIResponses","CallOptions","Promise","AsyncGenerator","ResponseCreateParamsStreaming","RequestOptions","ResponseStreamEvent","AsyncIterable","ResponseCreateParamsNonStreaming","Response"],"sources":["../../src/chat_models/responses.d.ts"],"sourcesContent":["import { OpenAI as OpenAIClient } from \"openai\";\nimport { CallbackManagerForLLMRun } from \"@langchain/core/callbacks/manager\";\nimport { type BaseMessage } from \"@langchain/core/messages\";\nimport { ChatGenerationChunk, type ChatResult } from \"@langchain/core/outputs\";\nimport { ChatOpenAIToolType, ResponsesTool } from \"../utils/tools.js\";\nimport { BaseChatOpenAI, BaseChatOpenAICallOptions } from \"./base.js\";\nimport { OpenAIVerbosityParam } from \"../types.js\";\nexport interface ChatOpenAIResponsesCallOptions extends BaseChatOpenAICallOptions {\n    /**\n     * Configuration options for a text response from the model. Can be plain text or\n     * structured JSON data.\n     */\n    text?: OpenAIClient.Responses.ResponseCreateParams[\"text\"];\n    /**\n     * The truncation strategy to use for the model response.\n     */\n    truncation?: OpenAIClient.Responses.ResponseCreateParams[\"truncation\"];\n    /**\n     * Specify additional output data to include in the model response.\n     */\n    include?: OpenAIClient.Responses.ResponseCreateParams[\"include\"];\n    /**\n     * The unique ID of the previous response to the model. Use this to create multi-turn\n     * conversations.\n     */\n    previous_response_id?: OpenAIClient.Responses.ResponseCreateParams[\"previous_response_id\"];\n    /**\n     * The verbosity of the model's response.\n     */\n    verbosity?: OpenAIVerbosityParam;\n}\nexport type ChatResponsesInvocationParams = Omit<OpenAIClient.Responses.ResponseCreateParams, \"input\">;\n/**\n * OpenAI Responses API implementation.\n *\n * Will be exported in a later version of @langchain/openai.\n *\n * @internal\n */\nexport declare class ChatOpenAIResponses<CallOptions extends ChatOpenAIResponsesCallOptions = ChatOpenAIResponsesCallOptions> extends BaseChatOpenAI<CallOptions> {\n    invocationParams(options?: this[\"ParsedCallOptions\"]): ChatResponsesInvocationParams;\n    _generate(messages: BaseMessage[], options: this[\"ParsedCallOptions\"]): Promise<ChatResult>;\n    _streamResponseChunks(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;\n    /**\n     * Calls the Responses API with retry logic in case of failures.\n     * @param request The request to send to the OpenAI API.\n     * @param options Optional configuration for the API call.\n     * @returns The response from the OpenAI API.\n     */\n    completionWithRetry(request: OpenAIClient.Responses.ResponseCreateParamsStreaming, requestOptions?: OpenAIClient.RequestOptions): Promise<AsyncIterable<OpenAIClient.Responses.ResponseStreamEvent>>;\n    completionWithRetry(request: OpenAIClient.Responses.ResponseCreateParamsNonStreaming, requestOptions?: OpenAIClient.RequestOptions): Promise<OpenAIClient.Responses.Response>;\n    /** @internal */\n    protected _reduceChatOpenAITools(tools: ChatOpenAIToolType[], fields: {\n        stream?: boolean;\n        strict?: boolean;\n    }): ResponsesTool[];\n}\n"],"mappings":";;;;;;;;;UAOiBW,8BAAAA,SAAuCF;;AAAxD;;;EAKsD,IAIrCR,CAAAA,EAJNA,QAAAA,CAAaW,SAAAA,CAAUC,oBAIMA,CAAAA,MAAAA,CAAAA;EAAoB;;;EAaxB,UAtBoBJ,CAAAA,EASvCR,QAAAA,CAAaW,SAAAA,CAAUC,oBATgBJ,CAAAA,YAAAA,CAAAA;EAAyB;AAwBjF;;EAAyC,OAAQR,CAAAA,EAXnCA,QAAAA,CAAaW,SAAAA,CAAUC,oBAWmCA,CAAAA,SAAAA,CAAAA;EAAoB;AAA5C;AAQhD;;EAAwC,oBAAqBF,CAAAA,EAdlCV,QAAAA,CAAaW,SAAAA,CAAUC,oBAcWF,CAAAA,sBAAAA,CAAAA;EAA8B;;;EACH,SAChER,CAAAA,EAZRO,oBAYQP;;AAAoDe,KAVhEJ,6BAAAA,GAAgCC,IAUgCG,CAV3BjB,QAAAA,CAAaW,SAAAA,CAAUC,oBAUIK,EAAAA,OAAAA,CAAAA;;;;;;;;AAQkEK,cAVzHP,mBAUyHO,CAAAA,oBAVjFZ,8BAUiFY,GAVhDZ,8BAUgDY,CAAAA,SAVRf,cAUQe,CAVON,WAUPM,CAAAA,CAAAA;EAAa,gBAArBL,CAAAA,OAAAA,CAAAA,EAAAA,IAAAA,CAAAA,mBAAAA,CAAAA,CAAAA,EAT3EJ,6BAS2EI;EAAO,SAC5GjB,CAAAA,QAAaW,EATtBT,WASgCqB,EAAAA,EAAAA,OAAAA,EAAAA,IAAAA,CAAAA,mBAAAA,CAAAA,CAAAA,EAToBN,OASpBM,CAT4BnB,UAS5BmB,CAAAA;EAAgC,qBAAgCH,CAAAA,QAAAA,EARpFlB,WAQoFkB,EAAAA,EAAAA,OAAAA,EAAAA,IAAAA,CAAAA,mBAAAA,CAAAA,EAAAA,UAAAA,CAAAA,EARpBnB,wBAQoBmB,CAAAA,EAROF,cAQPE,CARsBjB,mBAQtBiB,CAAAA;EAAc;;;;;AAXc;+BAUnHpB,QAAAA,CAAaW,SAAAA,CAAUQ,gDAAgDnB,QAAAA,CAAaoB,iBAAiBH,QAAQK,cAActB,QAAAA,CAAaW,SAAAA,CAAUU;+BAClJrB,QAAAA,CAAaW,SAAAA,CAAUY,mDAAmDvB,QAAAA,CAAaoB,iBAAiBH,QAAQjB,QAAAA,CAAaW,SAAAA,CAAUa;;0CAE5HnB;;;MAGpCC"}

package/dist/converters/completions.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"completions.d.cts","names":["BaseMessage","BaseMessageChunk","StandardContentBlockConverter","ContentBlock","Converter","ChatCompletionContentPartText","ChatCompletionContentPartImage","ChatCompletionContentPartInputAudio","ChatCompletionContentPart","OpenAI","OpenAIClient","completionsApiContentBlockConverter","File","convertCompletionsMessageToBaseMessage","Chat","Completions","ChatCompletionMessage","ChatCompletion","convertCompletionsDeltaToBaseMessageChunk","Record","ChatCompletionChunk","ChatCompletionRole","convertStandardContentBlockToCompletionsContentPart","Standard","convertStandardContentMessageToCompletionsMessage","ChatCompletionMessageParam","convertMessagesToCompletionsMessageParams"],"sources":["../../src/converters/completions.d.ts"],"sourcesContent":["import { BaseMessage, BaseMessageChunk, StandardContentBlockConverter, ContentBlock } from \"@langchain/core/messages\";\nimport { Converter } from \"@langchain/core/utils/format\";\nimport type { ChatCompletionContentPartText, ChatCompletionContentPartImage, ChatCompletionContentPartInputAudio, ChatCompletionContentPart } from \"openai/resources/chat/completions\";\nimport { OpenAI as OpenAIClient } from \"openai\";\n/**\n * @deprecated This converter is an internal detail of the OpenAI provider. Do not use it directly. This will be revisited in a future release.\n */\nexport declare const completionsApiContentBlockConverter: StandardContentBlockConverter<{\n    text: ChatCompletionContentPartText;\n    image: ChatCompletionContentPartImage;\n    audio: ChatCompletionContentPartInputAudio;\n    file: ChatCompletionContentPart.File;\n}>;\n/**\n * Converts an OpenAI Chat Completions API message to a LangChain BaseMessage.\n *\n * This converter transforms messages from OpenAI's Chat Completions API format into\n * LangChain's internal message representation, handling various message types and\n * preserving metadata, tool calls, and other relevant information.\n *\n * @remarks\n * The converter handles the following message roles:\n * - `assistant`: Converted to {@link AIMessage} with support for tool calls, function calls,\n *   audio content, and multi-modal outputs\n * - Other roles: Converted to generic {@link ChatMessage}\n *\n * For assistant messages, the converter:\n * - Parses and validates tool calls, separating valid and invalid calls\n * - Preserves function call information in additional_kwargs\n * - Includes usage statistics and system fingerprint in response_metadata\n * - Handles multi-modal content (text, images, audio)\n * - Optionally includes the raw API response for debugging\n *\n * @param params - Conversion parameters\n * @param params.message - The OpenAI chat completion message to convert\n * @param params.rawResponse - The complete raw response from OpenAI's API, used to extract\n *   metadata like model name, usage statistics, and system fingerprint\n * @param params.includeRawResponse - If true, includes the raw OpenAI response in the\n *   message's additional_kwargs under the `__raw_response` key. Useful for debugging\n *   or accessing provider-specific fields. Defaults to false.\n *\n * @returns A LangChain BaseMessage instance:\n *   - {@link AIMessage} for assistant messages with tool calls, metadata, and content\n *   - {@link ChatMessage} for all other message types\n *\n * @example\n * ```typescript\n * const baseMessage = convertCompletionsMessageToBaseMessage({\n *   message: {\n *     role: \"assistant\",\n *     content: \"Hello! How can I help you?\",\n *     tool_calls: [\n *       {\n *         id: \"call_123\",\n *         type: \"function\",\n *         function: { name: \"get_weather\", arguments: '{\"location\":\"NYC\"}' }\n *       }\n *     ]\n *   },\n *   rawResponse: completionResponse,\n *   includeRawResponse: true\n * });\n * // Returns an AIMessage with parsed tool calls and metadata\n * ```\n *\n * @throws {Error} If tool call parsing fails, the invalid tool call is captured in\n *   the `invalid_tool_calls` array rather than throwing an error\n *\n */\nexport declare const convertCompletionsMessageToBaseMessage: Converter<{\n    message: OpenAIClient.Chat.Completions.ChatCompletionMessage;\n    rawResponse: OpenAIClient.Chat.Completions.ChatCompletion;\n    includeRawResponse?: boolean;\n}, BaseMessage>;\n/**\n * Converts an OpenAI Chat Completions API delta (streaming chunk) to a LangChain BaseMessageChunk.\n *\n * This converter is used during streaming responses to transform incremental updates from OpenAI's\n * Chat Completions API into LangChain message chunks. It handles various message types, tool calls,\n * function calls, audio content, and role-specific message chunk creation.\n *\n * @param params - Conversion parameters\n * @param params.delta - The delta object from an OpenAI streaming chunk containing incremental\n *   message updates. May include content, role, tool_calls, function_call, audio, etc.\n * @param params.rawResponse - The complete raw ChatCompletionChunk response from OpenAI,\n *   containing metadata like model info, usage stats, and the delta\n * @param params.includeRawResponse - Optional flag to include the raw OpenAI response in the\n *   message chunk's additional_kwargs. Useful for debugging or accessing provider-specific data\n * @param params.defaultRole - Optional default role to use if the delta doesn't specify one.\n *   Typically used to maintain role consistency across chunks in a streaming response\n *\n * @returns A BaseMessageChunk subclass appropriate for the message role:\n *   - HumanMessageChunk for \"user\" role\n *   - AIMessageChunk for \"assistant\" role (includes tool call chunks)\n *   - SystemMessageChunk for \"system\" or \"developer\" roles\n *   - FunctionMessageChunk for \"function\" role\n *   - ToolMessageChunk for \"tool\" role\n *   - ChatMessageChunk for any other role\n *\n * @example\n * Basic streaming text chunk:\n * ```typescript\n * const chunk = convertCompletionsDeltaToBaseMessageChunk({\n *   delta: { role: \"assistant\", content: \"Hello\" },\n *   rawResponse: { id: \"chatcmpl-123\", model: \"gpt-4\", ... }\n * });\n * // Returns: AIMessageChunk with content \"Hello\"\n * ```\n *\n * @example\n * Streaming chunk with tool call:\n * ```typescript\n * const chunk = convertCompletionsDeltaToBaseMessageChunk({\n *   delta: {\n *     role: \"assistant\",\n *     tool_calls: [{\n *       index: 0,\n *       id: \"call_123\",\n *       function: { name: \"get_weather\", arguments: '{\"location\":' }\n *     }]\n *   },\n *   rawResponse: { id: \"chatcmpl-123\", ... }\n * });\n * // Returns: AIMessageChunk with tool_call_chunks containing partial tool call data\n * ```\n *\n * @remarks\n * - Tool calls are converted to ToolCallChunk objects with incremental data\n * - Audio content includes the chunk index from the raw response\n * - The \"developer\" role is mapped to SystemMessageChunk with a special marker\n * - Response metadata includes model provider info and usage statistics\n * - Function calls and tool calls are stored in additional_kwargs for compatibility\n */\nexport declare const convertCompletionsDeltaToBaseMessageChunk: Converter<{\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    delta: Record<string, any>;\n    rawResponse: OpenAIClient.Chat.Completions.ChatCompletionChunk;\n    includeRawResponse?: boolean;\n    defaultRole?: OpenAIClient.Chat.ChatCompletionRole;\n}, BaseMessageChunk>;\n/**\n * Converts a standard LangChain content block to an OpenAI Completions API content part.\n *\n * This converter transforms LangChain's standardized content blocks (image, audio, file)\n * into the format expected by OpenAI's Chat Completions API. It handles various content\n * types including images (URL or base64), audio (base64), and files (data or file ID).\n *\n * @param block - The standard content block to convert. Can be an image, audio, or file block.\n *\n * @returns An OpenAI Chat Completions content part object, or undefined if the block\n *   cannot be converted (e.g., missing required data).\n *\n * @example\n * Image with URL:\n * ```typescript\n * const block = { type: \"image\", url: \"https://example.com/image.jpg\" };\n * const part = convertStandardContentBlockToCompletionsContentPart(block);\n * // Returns: { type: \"image_url\", image_url: { url: \"https://example.com/image.jpg\" } }\n * ```\n *\n * @example\n * Image with base64 data:\n * ```typescript\n * const block = { type: \"image\", data: \"iVBORw0KGgo...\", mimeType: \"image/png\" };\n * const part = convertStandardContentBlockToCompletionsContentPart(block);\n * // Returns: { type: \"image_url\", image_url: { url: \"data:image/png;base64,iVBORw0KGgo...\" } }\n * ```\n */\nexport declare const convertStandardContentBlockToCompletionsContentPart: Converter<ContentBlock.Standard, OpenAIClient.Chat.Completions.ChatCompletionContentPartImage | OpenAIClient.Chat.Completions.ChatCompletionContentPartInputAudio | OpenAIClient.Chat.Completions.ChatCompletionContentPart.File | undefined>;\n/**\n * Converts a LangChain BaseMessage with standard content blocks to an OpenAI Chat Completions API message parameter.\n *\n * This converter transforms LangChain's standardized message format (using contentBlocks) into the format\n * expected by OpenAI's Chat Completions API. It handles role mapping, content filtering, and multi-modal\n * content conversion for various message types.\n *\n * @remarks\n * The converter performs the following transformations:\n * - Maps LangChain message roles to OpenAI API roles (user, assistant, system, developer, tool, function)\n * - For reasoning models, automatically converts \"system\" role to \"developer\" role\n * - Filters content blocks based on message role (most roles only include text blocks)\n * - For user messages, converts multi-modal content blocks (images, audio, files) to OpenAI format\n * - Preserves tool call IDs for tool messages and function names for function messages\n *\n * Role-specific behavior:\n * - **developer**: Returns only text content blocks (used for reasoning models)\n * - **system**: Returns only text content blocks\n * - **assistant**: Returns only text content blocks\n * - **tool**: Returns only text content blocks with tool_call_id preserved\n * - **function**: Returns text content blocks joined as a single string with function name\n * - **user** (default): Returns multi-modal content including text, images, audio, and files\n *\n * @param params - Conversion parameters\n * @param params.message - The LangChain BaseMessage to convert. Must have contentBlocks property\n *   containing an array of standard content blocks (text, image, audio, file, etc.)\n * @param params.model - Optional model name. Used to determine if special role mapping is needed\n *   (e.g., \"system\" -> \"developer\" for reasoning models like o1)\n *\n * @returns An OpenAI ChatCompletionMessageParam object formatted for the Chat Completions API.\n *   The structure varies by role:\n *   - Developer/System/Assistant: `{ role, content: TextBlock[] }`\n *   - Tool: `{ role: \"tool\", tool_call_id, content: TextBlock[] }`\n *   - Function: `{ role: \"function\", name, content: string }`\n *   - User: `{ role: \"user\", content: Array<TextPart | ImagePart | AudioPart | FilePart> }`\n *\n * @example\n * Simple text message:\n * ```typescript\n * const message = new HumanMessage({\n *   content: [{ type: \"text\", text: \"Hello!\" }]\n * });\n * const param = convertStandardContentMessageToCompletionsMessage({ message });\n * // Returns: { role: \"user\", content: [{ type: \"text\", text: \"Hello!\" }] }\n * ```\n *\n * @example\n * Multi-modal user message with image:\n * ```typescript\n * const message = new HumanMessage({\n *   content: [\n *     { type: \"text\", text: \"What's in this image?\" },\n *     { type: \"image\", url: \"https://example.com/image.jpg\" }\n *   ]\n * });\n * const param = convertStandardContentMessageToCompletionsMessage({ message });\n * // Returns: {\n * //   role: \"user\",\n * //   content: [\n * //     { type: \"text\", text: \"What's in this image?\" },\n * //     { type: \"image_url\", image_url: { url: \"https://example.com/image.jpg\" } }\n * //   ]\n * // }\n * ```\n */\nexport declare const convertStandardContentMessageToCompletionsMessage: Converter<{\n    message: BaseMessage;\n    model?: string;\n}, OpenAIClient.Chat.Completions.ChatCompletionMessageParam>;\n/**\n * Converts an array of LangChain BaseMessages to OpenAI Chat Completions API message parameters.\n *\n * This converter transforms LangChain's internal message representation into the format required\n * by OpenAI's Chat Completions API. It handles various message types, roles, content formats,\n * tool calls, function calls, audio messages, and special model-specific requirements.\n *\n * @remarks\n * The converter performs several key transformations:\n * - Maps LangChain message types to OpenAI roles (user, assistant, system, tool, function, developer)\n * - Converts standard content blocks (v1 format) using a specialized converter\n * - Handles multimodal content including text, images, audio, and data blocks\n * - Preserves tool calls and function calls with proper formatting\n * - Applies model-specific role mappings (e.g., \"system\" → \"developer\" for reasoning models)\n * - Splits audio messages into separate message parameters when needed\n *\n * @param params - Conversion parameters\n * @param params.messages - Array of LangChain BaseMessages to convert. Can include any message\n *   type: HumanMessage, AIMessage, SystemMessage, ToolMessage, FunctionMessage, etc.\n * @param params.model - Optional model name used to determine if special role mapping is needed.\n *   For reasoning models (o1, o3, etc.), \"system\" role is converted to \"developer\" role.\n *\n * @returns Array of ChatCompletionMessageParam objects formatted for OpenAI's Chat Completions API.\n *   Some messages may be split into multiple parameters (e.g., audio messages).\n *\n * @example\n * Basic message conversion:\n * ```typescript\n * const messages = [\n *   new HumanMessage(\"What's the weather like?\"),\n *   new AIMessage(\"Let me check that for you.\")\n * ];\n *\n * const params = convertMessagesToCompletionsMessageParams({\n *   messages,\n *   model: \"gpt-4\"\n * });\n * // Returns:\n * // [\n * //   { role: \"user\", content: \"What's the weather like?\" },\n * //   { role: \"assistant\", content: \"Let me check that for you.\" }\n * // ]\n * ```\n *\n * @example\n * Message with tool calls:\n * ```typescript\n * const messages = [\n *   new AIMessage({\n *     content: \"\",\n *     tool_calls: [{\n *       id: \"call_123\",\n *       name: \"get_weather\",\n *       args: { location: \"San Francisco\" }\n *     }]\n *   })\n * ];\n *\n * const params = convertMessagesToCompletionsMessageParams({ messages });\n * // Returns:\n * // [{\n * //   role: \"assistant\",\n * //   content: \"\",\n * //   tool_calls: [{\n * //     id: \"call_123\",\n * //     type: \"function\",\n * //     function: { name: \"get_weather\", arguments: '{\"location\":\"San Francisco\"}' }\n * //   }]\n * // }]\n * ```\n */\nexport declare const convertMessagesToCompletionsMessageParams: Converter<{\n    messages: BaseMessage[];\n    model?: string;\n}, OpenAIClient.Chat.Completions.ChatCompletionMessageParam[]>;\n"],"mappings":";;;;;;;;;AAOA;AAKE,cALmBW,mCAKnB,EALwDT,6BAKxD,CAAA;EAAA,IAJQG,EAAAA,6BAAAA;EAA6B,KAC5BC,EAAAA,8BAAAA;EAA8B,KAC9BC,EAAAA,mCAAAA;EAAmC,IACpCC,EAAAA,yBAAAA,CAA0BI,IAAAA;CAAI,CAAA;AAJ+C;AA8DvF;;;;;;AAAsE;AAgEtE;;;;;;;AAAyE;AAmCzE;;;;;;;AAAmF;AAkEnF;;;;;AAAiF;AA2EjF;;;;;AAAyE;;;;;;;;;;;;;;;;;;;;;cAhPpDC,wCAAwCT;WAChDM,QAAAA,CAAaI,IAAAA,CAAKC,WAAAA,CAAYC;eAC1BN,QAAAA,CAAaI,IAAAA,CAAKC,WAAAA,CAAYE;;GAE5CjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4DkBkB,2CAA2Cd;;SAErDe;eACMT,QAAAA,CAAaI,IAAAA,CAAKC,WAAAA,CAAYK;;gBAE7BV,QAAAA,CAAaI,IAAAA,CAAKO;GACjCpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6BkBqB,qDAAqDlB,UAAUD,YAAAA,CAAaoB,UAAUb,QAAAA,CAAaI,IAAAA,CAAKC,WAAAA,CAAYT,iCAAiCI,QAAAA,CAAaI,IAAAA,CAAKC,WAAAA,CAAYR,sCAAsCG,QAAAA,CAAaI,IAAAA,CAAKC,WAAAA,CAAYP,yBAAAA,CAA0BI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkEjRY,mDAAmDpB;WAC3DJ;;GAEVU,QAAAA,CAAaI,IAAAA,CAAKC,WAAAA,CAAYU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwEZC,2CAA2CtB;YAClDJ;;GAEXU,QAAAA,CAAaI,IAAAA,CAAKC,WAAAA,CAAYU"}

package/dist/converters/completions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"completions.d.ts","names":["BaseMessage","BaseMessageChunk","StandardContentBlockConverter","ContentBlock","Converter","ChatCompletionContentPartText","ChatCompletionContentPartImage","ChatCompletionContentPartInputAudio","ChatCompletionContentPart","OpenAI","OpenAIClient","completionsApiContentBlockConverter","File","convertCompletionsMessageToBaseMessage","Chat","Completions","ChatCompletionMessage","ChatCompletion","convertCompletionsDeltaToBaseMessageChunk","Record","ChatCompletionChunk","ChatCompletionRole","convertStandardContentBlockToCompletionsContentPart","Standard","convertStandardContentMessageToCompletionsMessage","ChatCompletionMessageParam","convertMessagesToCompletionsMessageParams"],"sources":["../../src/converters/completions.d.ts"],"sourcesContent":["import { BaseMessage, BaseMessageChunk, StandardContentBlockConverter, ContentBlock } from \"@langchain/core/messages\";\nimport { Converter } from \"@langchain/core/utils/format\";\nimport type { ChatCompletionContentPartText, ChatCompletionContentPartImage, ChatCompletionContentPartInputAudio, ChatCompletionContentPart } from \"openai/resources/chat/completions\";\nimport { OpenAI as OpenAIClient } from \"openai\";\n/**\n * @deprecated This converter is an internal detail of the OpenAI provider. Do not use it directly. This will be revisited in a future release.\n */\nexport declare const completionsApiContentBlockConverter: StandardContentBlockConverter<{\n    text: ChatCompletionContentPartText;\n    image: ChatCompletionContentPartImage;\n    audio: ChatCompletionContentPartInputAudio;\n    file: ChatCompletionContentPart.File;\n}>;\n/**\n * Converts an OpenAI Chat Completions API message to a LangChain BaseMessage.\n *\n * This converter transforms messages from OpenAI's Chat Completions API format into\n * LangChain's internal message representation, handling various message types and\n * preserving metadata, tool calls, and other relevant information.\n *\n * @remarks\n * The converter handles the following message roles:\n * - `assistant`: Converted to {@link AIMessage} with support for tool calls, function calls,\n *   audio content, and multi-modal outputs\n * - Other roles: Converted to generic {@link ChatMessage}\n *\n * For assistant messages, the converter:\n * - Parses and validates tool calls, separating valid and invalid calls\n * - Preserves function call information in additional_kwargs\n * - Includes usage statistics and system fingerprint in response_metadata\n * - Handles multi-modal content (text, images, audio)\n * - Optionally includes the raw API response for debugging\n *\n * @param params - Conversion parameters\n * @param params.message - The OpenAI chat completion message to convert\n * @param params.rawResponse - The complete raw response from OpenAI's API, used to extract\n *   metadata like model name, usage statistics, and system fingerprint\n * @param params.includeRawResponse - If true, includes the raw OpenAI response in the\n *   message's additional_kwargs under the `__raw_response` key. Useful for debugging\n *   or accessing provider-specific fields. Defaults to false.\n *\n * @returns A LangChain BaseMessage instance:\n *   - {@link AIMessage} for assistant messages with tool calls, metadata, and content\n *   - {@link ChatMessage} for all other message types\n *\n * @example\n * ```typescript\n * const baseMessage = convertCompletionsMessageToBaseMessage({\n *   message: {\n *     role: \"assistant\",\n *     content: \"Hello! How can I help you?\",\n *     tool_calls: [\n *       {\n *         id: \"call_123\",\n *         type: \"function\",\n *         function: { name: \"get_weather\", arguments: '{\"location\":\"NYC\"}' }\n *       }\n *     ]\n *   },\n *   rawResponse: completionResponse,\n *   includeRawResponse: true\n * });\n * // Returns an AIMessage with parsed tool calls and metadata\n * ```\n *\n * @throws {Error} If tool call parsing fails, the invalid tool call is captured in\n *   the `invalid_tool_calls` array rather than throwing an error\n *\n */\nexport declare const convertCompletionsMessageToBaseMessage: Converter<{\n    message: OpenAIClient.Chat.Completions.ChatCompletionMessage;\n    rawResponse: OpenAIClient.Chat.Completions.ChatCompletion;\n    includeRawResponse?: boolean;\n}, BaseMessage>;\n/**\n * Converts an OpenAI Chat Completions API delta (streaming chunk) to a LangChain BaseMessageChunk.\n *\n * This converter is used during streaming responses to transform incremental updates from OpenAI's\n * Chat Completions API into LangChain message chunks. It handles various message types, tool calls,\n * function calls, audio content, and role-specific message chunk creation.\n *\n * @param params - Conversion parameters\n * @param params.delta - The delta object from an OpenAI streaming chunk containing incremental\n *   message updates. May include content, role, tool_calls, function_call, audio, etc.\n * @param params.rawResponse - The complete raw ChatCompletionChunk response from OpenAI,\n *   containing metadata like model info, usage stats, and the delta\n * @param params.includeRawResponse - Optional flag to include the raw OpenAI response in the\n *   message chunk's additional_kwargs. Useful for debugging or accessing provider-specific data\n * @param params.defaultRole - Optional default role to use if the delta doesn't specify one.\n *   Typically used to maintain role consistency across chunks in a streaming response\n *\n * @returns A BaseMessageChunk subclass appropriate for the message role:\n *   - HumanMessageChunk for \"user\" role\n *   - AIMessageChunk for \"assistant\" role (includes tool call chunks)\n *   - SystemMessageChunk for \"system\" or \"developer\" roles\n *   - FunctionMessageChunk for \"function\" role\n *   - ToolMessageChunk for \"tool\" role\n *   - ChatMessageChunk for any other role\n *\n * @example\n * Basic streaming text chunk:\n * ```typescript\n * const chunk = convertCompletionsDeltaToBaseMessageChunk({\n *   delta: { role: \"assistant\", content: \"Hello\" },\n *   rawResponse: { id: \"chatcmpl-123\", model: \"gpt-4\", ... }\n * });\n * // Returns: AIMessageChunk with content \"Hello\"\n * ```\n *\n * @example\n * Streaming chunk with tool call:\n * ```typescript\n * const chunk = convertCompletionsDeltaToBaseMessageChunk({\n *   delta: {\n *     role: \"assistant\",\n *     tool_calls: [{\n *       index: 0,\n *       id: \"call_123\",\n *       function: { name: \"get_weather\", arguments: '{\"location\":' }\n *     }]\n *   },\n *   rawResponse: { id: \"chatcmpl-123\", ... }\n * });\n * // Returns: AIMessageChunk with tool_call_chunks containing partial tool call data\n * ```\n *\n * @remarks\n * - Tool calls are converted to ToolCallChunk objects with incremental data\n * - Audio content includes the chunk index from the raw response\n * - The \"developer\" role is mapped to SystemMessageChunk with a special marker\n * - Response metadata includes model provider info and usage statistics\n * - Function calls and tool calls are stored in additional_kwargs for compatibility\n */\nexport declare const convertCompletionsDeltaToBaseMessageChunk: Converter<{\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    delta: Record<string, any>;\n    rawResponse: OpenAIClient.Chat.Completions.ChatCompletionChunk;\n    includeRawResponse?: boolean;\n    defaultRole?: OpenAIClient.Chat.ChatCompletionRole;\n}, BaseMessageChunk>;\n/**\n * Converts a standard LangChain content block to an OpenAI Completions API content part.\n *\n * This converter transforms LangChain's standardized content blocks (image, audio, file)\n * into the format expected by OpenAI's Chat Completions API. It handles various content\n * types including images (URL or base64), audio (base64), and files (data or file ID).\n *\n * @param block - The standard content block to convert. Can be an image, audio, or file block.\n *\n * @returns An OpenAI Chat Completions content part object, or undefined if the block\n *   cannot be converted (e.g., missing required data).\n *\n * @example\n * Image with URL:\n * ```typescript\n * const block = { type: \"image\", url: \"https://example.com/image.jpg\" };\n * const part = convertStandardContentBlockToCompletionsContentPart(block);\n * // Returns: { type: \"image_url\", image_url: { url: \"https://example.com/image.jpg\" } }\n * ```\n *\n * @example\n * Image with base64 data:\n * ```typescript\n * const block = { type: \"image\", data: \"iVBORw0KGgo...\", mimeType: \"image/png\" };\n * const part = convertStandardContentBlockToCompletionsContentPart(block);\n * // Returns: { type: \"image_url\", image_url: { url: \"data:image/png;base64,iVBORw0KGgo...\" } }\n * ```\n */\nexport declare const convertStandardContentBlockToCompletionsContentPart: Converter<ContentBlock.Standard, OpenAIClient.Chat.Completions.ChatCompletionContentPartImage | OpenAIClient.Chat.Completions.ChatCompletionContentPartInputAudio | OpenAIClient.Chat.Completions.ChatCompletionContentPart.File | undefined>;\n/**\n * Converts a LangChain BaseMessage with standard content blocks to an OpenAI Chat Completions API message parameter.\n *\n * This converter transforms LangChain's standardized message format (using contentBlocks) into the format\n * expected by OpenAI's Chat Completions API. It handles role mapping, content filtering, and multi-modal\n * content conversion for various message types.\n *\n * @remarks\n * The converter performs the following transformations:\n * - Maps LangChain message roles to OpenAI API roles (user, assistant, system, developer, tool, function)\n * - For reasoning models, automatically converts \"system\" role to \"developer\" role\n * - Filters content blocks based on message role (most roles only include text blocks)\n * - For user messages, converts multi-modal content blocks (images, audio, files) to OpenAI format\n * - Preserves tool call IDs for tool messages and function names for function messages\n *\n * Role-specific behavior:\n * - **developer**: Returns only text content blocks (used for reasoning models)\n * - **system**: Returns only text content blocks\n * - **assistant**: Returns only text content blocks\n * - **tool**: Returns only text content blocks with tool_call_id preserved\n * - **function**: Returns text content blocks joined as a single string with function name\n * - **user** (default): Returns multi-modal content including text, images, audio, and files\n *\n * @param params - Conversion parameters\n * @param params.message - The LangChain BaseMessage to convert. Must have contentBlocks property\n *   containing an array of standard content blocks (text, image, audio, file, etc.)\n * @param params.model - Optional model name. Used to determine if special role mapping is needed\n *   (e.g., \"system\" -> \"developer\" for reasoning models like o1)\n *\n * @returns An OpenAI ChatCompletionMessageParam object formatted for the Chat Completions API.\n *   The structure varies by role:\n *   - Developer/System/Assistant: `{ role, content: TextBlock[] }`\n *   - Tool: `{ role: \"tool\", tool_call_id, content: TextBlock[] }`\n *   - Function: `{ role: \"function\", name, content: string }`\n *   - User: `{ role: \"user\", content: Array<TextPart | ImagePart | AudioPart | FilePart> }`\n *\n * @example\n * Simple text message:\n * ```typescript\n * const message = new HumanMessage({\n *   content: [{ type: \"text\", text: \"Hello!\" }]\n * });\n * const param = convertStandardContentMessageToCompletionsMessage({ message });\n * // Returns: { role: \"user\", content: [{ type: \"text\", text: \"Hello!\" }] }\n * ```\n *\n * @example\n * Multi-modal user message with image:\n * ```typescript\n * const message = new HumanMessage({\n *   content: [\n *     { type: \"text\", text: \"What's in this image?\" },\n *     { type: \"image\", url: \"https://example.com/image.jpg\" }\n *   ]\n * });\n * const param = convertStandardContentMessageToCompletionsMessage({ message });\n * // Returns: {\n * //   role: \"user\",\n * //   content: [\n * //     { type: \"text\", text: \"What's in this image?\" },\n * //     { type: \"image_url\", image_url: { url: \"https://example.com/image.jpg\" } }\n * //   ]\n * // }\n * ```\n */\nexport declare const convertStandardContentMessageToCompletionsMessage: Converter<{\n    message: BaseMessage;\n    model?: string;\n}, OpenAIClient.Chat.Completions.ChatCompletionMessageParam>;\n/**\n * Converts an array of LangChain BaseMessages to OpenAI Chat Completions API message parameters.\n *\n * This converter transforms LangChain's internal message representation into the format required\n * by OpenAI's Chat Completions API. It handles various message types, roles, content formats,\n * tool calls, function calls, audio messages, and special model-specific requirements.\n *\n * @remarks\n * The converter performs several key transformations:\n * - Maps LangChain message types to OpenAI roles (user, assistant, system, tool, function, developer)\n * - Converts standard content blocks (v1 format) using a specialized converter\n * - Handles multimodal content including text, images, audio, and data blocks\n * - Preserves tool calls and function calls with proper formatting\n * - Applies model-specific role mappings (e.g., \"system\" → \"developer\" for reasoning models)\n * - Splits audio messages into separate message parameters when needed\n *\n * @param params - Conversion parameters\n * @param params.messages - Array of LangChain BaseMessages to convert. Can include any message\n *   type: HumanMessage, AIMessage, SystemMessage, ToolMessage, FunctionMessage, etc.\n * @param params.model - Optional model name used to determine if special role mapping is needed.\n *   For reasoning models (o1, o3, etc.), \"system\" role is converted to \"developer\" role.\n *\n * @returns Array of ChatCompletionMessageParam objects formatted for OpenAI's Chat Completions API.\n *   Some messages may be split into multiple parameters (e.g., audio messages).\n *\n * @example\n * Basic message conversion:\n * ```typescript\n * const messages = [\n *   new HumanMessage(\"What's the weather like?\"),\n *   new AIMessage(\"Let me check that for you.\")\n * ];\n *\n * const params = convertMessagesToCompletionsMessageParams({\n *   messages,\n *   model: \"gpt-4\"\n * });\n * // Returns:\n * // [\n * //   { role: \"user\", content: \"What's the weather like?\" },\n * //   { role: \"assistant\", content: \"Let me check that for you.\" }\n * // ]\n * ```\n *\n * @example\n * Message with tool calls:\n * ```typescript\n * const messages = [\n *   new AIMessage({\n *     content: \"\",\n *     tool_calls: [{\n *       id: \"call_123\",\n *       name: \"get_weather\",\n *       args: { location: \"San Francisco\" }\n *     }]\n *   })\n * ];\n *\n * const params = convertMessagesToCompletionsMessageParams({ messages });\n * // Returns:\n * // [{\n * //   role: \"assistant\",\n * //   content: \"\",\n * //   tool_calls: [{\n * //     id: \"call_123\",\n * //     type: \"function\",\n * //     function: { name: \"get_weather\", arguments: '{\"location\":\"San Francisco\"}' }\n * //   }]\n * // }]\n * ```\n */\nexport declare const convertMessagesToCompletionsMessageParams: Converter<{\n    messages: BaseMessage[];\n    model?: string;\n}, OpenAIClient.Chat.Completions.ChatCompletionMessageParam[]>;\n"],"mappings":";;;;;;;;;AAOA;AAKE,cALmBW,mCAKnB,EALwDT,6BAKxD,CAAA;EAAA,IAJQG,EAAAA,6BAAAA;EAA6B,KAC5BC,EAAAA,8BAAAA;EAA8B,KAC9BC,EAAAA,mCAAAA;EAAmC,IACpCC,EAAAA,yBAAAA,CAA0BI,IAAAA;CAAI,CAAA;AAJ+C;AA8DvF;;;;;;AAAsE;AAgEtE;;;;;;;AAAyE;AAmCzE;;;;;;;AAAmF;AAkEnF;;;;;AAAiF;AA2EjF;;;;;AAAyE;;;;;;;;;;;;;;;;;;;;;cAhPpDC,wCAAwCT;WAChDM,QAAAA,CAAaI,IAAAA,CAAKC,WAAAA,CAAYC;eAC1BN,QAAAA,CAAaI,IAAAA,CAAKC,WAAAA,CAAYE;;GAE5CjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4DkBkB,2CAA2Cd;;SAErDe;eACMT,QAAAA,CAAaI,IAAAA,CAAKC,WAAAA,CAAYK;;gBAE7BV,QAAAA,CAAaI,IAAAA,CAAKO;GACjCpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6BkBqB,qDAAqDlB,UAAUD,YAAAA,CAAaoB,UAAUb,QAAAA,CAAaI,IAAAA,CAAKC,WAAAA,CAAYT,iCAAiCI,QAAAA,CAAaI,IAAAA,CAAKC,WAAAA,CAAYR,sCAAsCG,QAAAA,CAAaI,IAAAA,CAAKC,WAAAA,CAAYP,yBAAAA,CAA0BI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkEjRY,mDAAmDpB;WAC3DJ;;GAEVU,QAAAA,CAAaI,IAAAA,CAAKC,WAAAA,CAAYU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwEZC,2CAA2CtB;YAClDJ;;GAEXU,QAAAA,CAAaI,IAAAA,CAAKC,WAAAA,CAAYU"}

package/dist/converters/responses.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"responses.d.cts","names":["OpenAI","OpenAIClient","AIMessage","BaseMessage","UsageMetadata","ChatGenerationChunk","ChatOpenAIReasoningSummary","Converter","ExcludeController","T","ResponsesCreate","Responses","ResponsesParse","ResponsesCreateInvoke","ReturnType","Awaited","ResponsesParseInvoke","ResponsesInputItem","ResponseInputItem","convertResponsesUsageToUsageMetadata","ResponseUsage","convertResponsesMessageToAIMessage","convertReasoningSummaryToResponsesReasoningItem","ResponseReasoningItem","convertResponsesDeltaToChatGenerationChunk","ResponseStreamEvent","convertStandardContentMessageToResponsesInput","convertMessagesToResponsesInput"],"sources":["../../src/converters/responses.d.ts"],"sourcesContent":["import { OpenAI as OpenAIClient } from \"openai\";\nimport { AIMessage, type BaseMessage, type UsageMetadata } from \"@langchain/core/messages\";\nimport { ChatGenerationChunk } from \"@langchain/core/outputs\";\nimport { ChatOpenAIReasoningSummary } from \"../types.js\";\nimport { Converter } from \"@langchain/core/utils/format\";\ntype ExcludeController<T> = T extends {\n    controller: unknown;\n} ? never : T;\nexport type ResponsesCreate = OpenAIClient.Responses[\"create\"];\nexport type ResponsesParse = OpenAIClient.Responses[\"parse\"];\nexport type ResponsesCreateInvoke = ExcludeController<Awaited<ReturnType<ResponsesCreate>>>;\nexport type ResponsesParseInvoke = ExcludeController<Awaited<ReturnType<ResponsesParse>>>;\nexport type ResponsesInputItem = OpenAIClient.Responses.ResponseInputItem;\n/**\n * Converts OpenAI Responses API usage statistics to LangChain's UsageMetadata format.\n *\n * This converter transforms token usage information from OpenAI's Responses API into\n * the standardized UsageMetadata format used throughout LangChain. It handles both\n * basic token counts and detailed token breakdowns including cached tokens and\n * reasoning tokens.\n *\n * @param usage - The usage statistics object from OpenAI's Responses API containing\n *                token counts and optional detailed breakdowns.\n *\n * @returns A UsageMetadata object containing:\n *   - `input_tokens`: Total number of tokens in the input/prompt (defaults to 0 if not provided)\n *   - `output_tokens`: Total number of tokens in the model's output (defaults to 0 if not provided)\n *   - `total_tokens`: Combined total of input and output tokens (defaults to 0 if not provided)\n *   - `input_token_details`: Object containing detailed input token information:\n *     - `cache_read`: Number of tokens read from cache (only included if available)\n *   - `output_token_details`: Object containing detailed output token information:\n *     - `reasoning`: Number of tokens used for reasoning (only included if available)\n *\n * @example\n * ```typescript\n * const usage = {\n *   input_tokens: 100,\n *   output_tokens: 50,\n *   total_tokens: 150,\n *   input_tokens_details: { cached_tokens: 20 },\n *   output_tokens_details: { reasoning_tokens: 10 }\n * };\n *\n * const metadata = convertResponsesUsageToUsageMetadata(usage);\n * // Returns:\n * // {\n * //   input_tokens: 100,\n * //   output_tokens: 50,\n * //   total_tokens: 150,\n * //   input_token_details: { cache_read: 20 },\n * //   output_token_details: { reasoning: 10 }\n * // }\n * ```\n *\n * @remarks\n * - The function safely handles undefined or null values by using optional chaining\n *   and nullish coalescing operators\n * - Detailed token information (cache_read, reasoning) is only included in the result\n *   if the corresponding values are present in the input\n * - Token counts default to 0 if not provided in the usage object\n * - This converter is specifically designed for OpenAI's Responses API format and\n *   may differ from other OpenAI API endpoints\n */\nexport declare const convertResponsesUsageToUsageMetadata: Converter<OpenAIClient.Responses.ResponseUsage | undefined, UsageMetadata>;\n/**\n * Converts an OpenAI Responses API response to a LangChain AIMessage.\n *\n * This converter processes the output from OpenAI's Responses API (both `create` and `parse` methods)\n * and transforms it into a LangChain AIMessage object with all relevant metadata, tool calls, and content.\n *\n * @param response - The response object from OpenAI's Responses API. Can be either:\n *   - ResponsesCreateInvoke: Result from `responses.create()`\n *   - ResponsesParseInvoke: Result from `responses.parse()`\n *\n * @returns An AIMessage containing:\n *   - `id`: The message ID from the response output\n *   - `content`: Array of message content blocks (text, images, etc.)\n *   - `tool_calls`: Array of successfully parsed tool calls\n *   - `invalid_tool_calls`: Array of tool calls that failed to parse\n *   - `usage_metadata`: Token usage information converted to LangChain format\n *   - `additional_kwargs`: Extra data including:\n *     - `refusal`: Refusal text if the model refused to respond\n *     - `reasoning`: Reasoning output for reasoning models\n *     - `tool_outputs`: Results from built-in tools (web search, file search, etc.)\n *     - `parsed`: Parsed structured output when using json_schema format\n *     - Function call ID mappings for tracking\n *   - `response_metadata`: Metadata about the response including model, timestamps, status, etc.\n *\n * @throws Error if the response contains an error object. The error message and code are extracted\n *   from the response.error field.\n *\n * @example\n * ```typescript\n * const response = await client.responses.create({\n *   model: \"gpt-4\",\n *   input: [{ type: \"message\", content: \"Hello\" }]\n * });\n * const message = convertResponsesMessageToAIMessage(response);\n * console.log(message.content); // Message content\n * console.log(message.tool_calls); // Any tool calls made\n * ```\n *\n * @remarks\n * The converter handles multiple output item types:\n * - `message`: Text and structured content from the model\n * - `function_call`: Tool/function calls that need to be executed\n * - `reasoning`: Reasoning traces from reasoning models (o1, o3, etc.)\n * - `custom_tool_call`: Custom tool invocations\n * - Built-in tool outputs: web_search, file_search, code_interpreter, etc.\n *\n * Tool calls are parsed and validated. Invalid tool calls (malformed JSON, etc.) are captured\n * in the `invalid_tool_calls` array rather than throwing errors.\n */\nexport declare const convertResponsesMessageToAIMessage: Converter<ResponsesCreateInvoke | ResponsesParseInvoke, AIMessage>;\n/**\n * Converts a LangChain ChatOpenAI reasoning summary to an OpenAI Responses API reasoning item.\n *\n * This converter transforms reasoning summaries that have been accumulated during streaming\n * (where summary parts may arrive in multiple chunks with the same index) into the final\n * consolidated format expected by OpenAI's Responses API. It combines summary parts that\n * share the same index and removes the index field from the final output.\n *\n * @param reasoning - A ChatOpenAI reasoning summary object containing:\n *   - `id`: The reasoning item ID\n *   - `type`: The type of reasoning (typically \"reasoning\")\n *   - `summary`: Array of summary parts, each with:\n *     - `text`: The summary text content\n *     - `type`: The summary type (e.g., \"summary_text\")\n *     - `index`: The index used to group related summary parts during streaming\n *\n * @returns An OpenAI Responses API ResponseReasoningItem with:\n *   - All properties from the input reasoning object\n *   - `summary`: Consolidated array of summary objects with:\n *     - `text`: Combined text from all parts with the same index\n *     - `type`: The summary type\n *     - No `index` field (removed after consolidation)\n *\n * @example\n * ```typescript\n * // Input: Reasoning summary with multiple parts at the same index\n * const reasoning = {\n *   id: \"reasoning_123\",\n *   type: \"reasoning\",\n *   summary: [\n *     { text: \"First \", type: \"summary_text\", index: 0 },\n *     { text: \"part\", type: \"summary_text\", index: 0 },\n *     { text: \"Second part\", type: \"summary_text\", index: 1 }\n *   ]\n * };\n *\n * const result = convertReasoningSummaryToResponsesReasoningItem(reasoning);\n * // Returns:\n * // {\n * //   id: \"reasoning_123\",\n * //   type: \"reasoning\",\n * //   summary: [\n * //     { text: \"First part\", type: \"summary_text\" },\n * //     { text: \"Second part\", type: \"summary_text\" }\n * //   ]\n * // }\n * ```\n *\n * @remarks\n * - This converter is primarily used when reconstructing complete reasoning items from\n *   streaming chunks, where summary parts may arrive incrementally with index markers\n * - Summary parts with the same index are concatenated in the order they appear\n * - If the reasoning summary contains only one part, no reduction is performed\n * - The index field is used internally during streaming to track which summary parts\n *   belong together, but is removed from the final output as it's not part of the\n *   OpenAI Responses API schema\n * - This is the inverse operation of the streaming accumulation that happens in\n *   `convertResponsesDeltaToChatGenerationChunk`\n */\nexport declare const convertReasoningSummaryToResponsesReasoningItem: Converter<ChatOpenAIReasoningSummary, OpenAIClient.Responses.ResponseReasoningItem>;\n/**\n * Converts OpenAI Responses API stream events to LangChain ChatGenerationChunk objects.\n *\n * This converter processes streaming events from OpenAI's Responses API and transforms them\n * into LangChain ChatGenerationChunk objects that can be used in streaming chat applications.\n * It handles various event types including text deltas, tool calls, reasoning, and metadata updates.\n *\n * @param event - A streaming event from OpenAI's Responses API\n *\n * @returns A ChatGenerationChunk containing:\n *   - `text`: Concatenated text content from all text parts in the event\n *   - `message`: An AIMessageChunk with:\n *     - `id`: Message ID (set when a message output item is added)\n *     - `content`: Array of content blocks (text with optional annotations)\n *     - `tool_call_chunks`: Incremental tool call data (name, args, id)\n *     - `usage_metadata`: Token usage information (only in completion events)\n *     - `additional_kwargs`: Extra data including:\n *       - `refusal`: Refusal text if the model refused to respond\n *       - `reasoning`: Reasoning output for reasoning models (id, type, summary)\n *       - `tool_outputs`: Results from built-in tools (web search, file search, etc.)\n *       - `parsed`: Parsed structured output when using json_schema format\n *       - Function call ID mappings for tracking\n *     - `response_metadata`: Metadata about the response (model, id, etc.)\n *   - `generationInfo`: Additional generation information (e.g., tool output status)\n *\n *   Returns `null` for events that don't produce meaningful chunks:\n *   - Partial image generation events (to avoid storing all partial images in history)\n *   - Unrecognized event types\n *\n * @example\n * ```typescript\n * const stream = await client.responses.create({\n *   model: \"gpt-4\",\n *   input: [{ type: \"message\", content: \"Hello\" }],\n *   stream: true\n * });\n *\n * for await (const event of stream) {\n *   const chunk = convertResponsesDeltaToChatGenerationChunk(event);\n *   if (chunk) {\n *     console.log(chunk.text); // Incremental text\n *     console.log(chunk.message.tool_call_chunks); // Tool call updates\n *   }\n * }\n * ```\n *\n * @remarks\n * - Text content is accumulated in an array with index tracking for proper ordering\n * - Tool call chunks include incremental arguments that need to be concatenated by the consumer\n * - Reasoning summaries are built incrementally across multiple events\n * - Function call IDs are tracked in `additional_kwargs` to map call_id to item id\n * - The `text` field is provided for legacy compatibility with `onLLMNewToken` callbacks\n * - Usage metadata is only available in `response.completed` events\n * - Partial images are intentionally ignored to prevent memory bloat in conversation history\n */\nexport declare const convertResponsesDeltaToChatGenerationChunk: Converter<OpenAIClient.Responses.ResponseStreamEvent, ChatGenerationChunk | null>;\n/**\n * Converts a single LangChain BaseMessage to OpenAI Responses API input format.\n *\n * This converter transforms a LangChain message into one or more ResponseInputItem objects\n * that can be used with OpenAI's Responses API. It handles complex message structures including\n * tool calls, reasoning blocks, multimodal content, and various content block types.\n *\n * @param message - The LangChain BaseMessage to convert. Can be any message type including\n *   HumanMessage, AIMessage, SystemMessage, ToolMessage, etc.\n *\n * @returns An array of ResponseInputItem objects.\n *\n * @example\n * Basic text message conversion:\n * ```typescript\n * const message = new HumanMessage(\"Hello, how are you?\");\n * const items = convertStandardContentMessageToResponsesInput(message);\n * // Returns: [{ type: \"message\", role: \"user\", content: [{ type: \"input_text\", text: \"Hello, how are you?\" }] }]\n * ```\n *\n * @example\n * AI message with tool calls:\n * ```typescript\n * const message = new AIMessage({\n *   content: \"I'll check the weather for you.\",\n *   tool_calls: [{\n *     id: \"call_123\",\n *     name: \"get_weather\",\n *     args: { location: \"San Francisco\" }\n *   }]\n * });\n * const items = convertStandardContentMessageToResponsesInput(message);\n * // Returns:\n * // [\n * //   { type: \"message\", role: \"assistant\", content: [{ type: \"input_text\", text: \"I'll check the weather for you.\" }] },\n * //   { type: \"function_call\", call_id: \"call_123\", name: \"get_weather\", arguments: '{\"location\":\"San Francisco\"}' }\n * // ]\n * ```\n */\nexport declare const convertStandardContentMessageToResponsesInput: Converter<BaseMessage, OpenAIClient.Responses.ResponseInputItem[]>;\n/**\n * - MCP (Model Context Protocol) approval responses\n * - Zero Data Retention (ZDR) mode handling\n *\n * @param params - Conversion parameters\n * @param params.messages - Array of LangChain BaseMessages to convert\n * @param params.zdrEnabled - Whether Zero Data Retention mode is enabled. When true, certain\n *   metadata like message IDs and function call IDs are omitted from the output\n * @param params.model - The model name being used. Used to determine if special role mapping\n *   is needed (e.g., \"system\" -> \"developer\" for reasoning models)\n *\n * @returns Array of ResponsesInputItem objects formatted for the OpenAI Responses API\n *\n * @throws {Error} When a function message is encountered (not supported)\n * @throws {Error} When computer call output format is invalid\n *\n * @example\n * ```typescript\n * const messages = [\n *   new HumanMessage(\"Hello\"),\n *   new AIMessage({ content: \"Hi there!\", tool_calls: [...] })\n * ];\n *\n * const input = convertMessagesToResponsesInput({\n *   messages,\n *   zdrEnabled: false,\n *   model: \"gpt-4\"\n * });\n * ```\n */\nexport declare const convertMessagesToResponsesInput: Converter<{\n    messages: BaseMessage[];\n    zdrEnabled: boolean;\n    model: string;\n}, ResponsesInputItem[]>;\nexport {};\n"],"mappings":";;;;;;;KAKKQ,uBAAuBC;;AAD6B,CAAA,GACpDD,KAAAA,GAEOC,CAFPD;AAAiB,KAGVE,eAAAA,GAAkBT,QAAAA,CAAaU,SAHrB,CAAA,QAAA,CAAA;AAAMF,KAIhBG,cAAAA,GAAiBX,QAAAA,CAAaU,SAJdF,CAAAA,OAAAA,CAAAA;AAEhBA,KAGAI,qBAAAA,GAAwBL,iBAHxBC,CAG0CM,OAH1CN,CAGkDK,UAHlDL,CAG6DC,eAH7DD,CAAAA,CAAAA,CAAAA;AAAC,KAIDO,oBAAAA,GAAuBR,iBAJtB,CAIwCO,OAJxC,CAIgDD,UAJhD,CAI2DF,cAJ3D,CAAA,CAAA,CAAA;AACDF,KAIAO,kBAAAA,GAAqBhB,QAAAA,CAAaU,SAAAA,CAAUO,iBAJJ;AACpD;AACA;;;;;;AAAqD;AACrD;;;;;;AAAoD;AACpD;AAmDA;;;;;AAAoE;AAkDpE;;;;;;AAAkE;AA4DlE;;;;;AAA+E;AAwD/E;;;;;AAA0E;AAwC1E;;;;;AAA6E;AA+B7E;;;AAIGD,cAjPkBE,oCAiPlBF,EAjPwDV,SAiPxDU,CAjPkEhB,QAAAA,CAAaU,SAAAA,CAAUS,aAiPzFH,GAAAA,SAAAA,EAjPoHb,aAiPpHa,CAAAA;;AAJ4D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA3L1CI,oCAAoCd,UAAUM,wBAAwBG,sBAAsBd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4D5FoB,iDAAiDf,UAAUD,4BAA4BL,QAAAA,CAAaU,SAAAA,CAAUY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwD9GC,4CAA4CjB,UAAUN,QAAAA,CAAaU,SAAAA,CAAUc,qBAAqBpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwClGqB,+CAA+CnB,UAAUJ,aAAaF,QAAAA,CAAaU,SAAAA,CAAUO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+B7FS,iCAAiCpB;YACxCJ;;;GAGXc"}

package/dist/converters/responses.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"responses.d.ts","names":["OpenAI","OpenAIClient","AIMessage","BaseMessage","UsageMetadata","ChatGenerationChunk","ChatOpenAIReasoningSummary","Converter","ExcludeController","T","ResponsesCreate","Responses","ResponsesParse","ResponsesCreateInvoke","ReturnType","Awaited","ResponsesParseInvoke","ResponsesInputItem","ResponseInputItem","convertResponsesUsageToUsageMetadata","ResponseUsage","convertResponsesMessageToAIMessage","convertReasoningSummaryToResponsesReasoningItem","ResponseReasoningItem","convertResponsesDeltaToChatGenerationChunk","ResponseStreamEvent","convertStandardContentMessageToResponsesInput","convertMessagesToResponsesInput"],"sources":["../../src/converters/responses.d.ts"],"sourcesContent":["import { OpenAI as OpenAIClient } from \"openai\";\nimport { AIMessage, type BaseMessage, type UsageMetadata } from \"@langchain/core/messages\";\nimport { ChatGenerationChunk } from \"@langchain/core/outputs\";\nimport { ChatOpenAIReasoningSummary } from \"../types.js\";\nimport { Converter } from \"@langchain/core/utils/format\";\ntype ExcludeController<T> = T extends {\n    controller: unknown;\n} ? never : T;\nexport type ResponsesCreate = OpenAIClient.Responses[\"create\"];\nexport type ResponsesParse = OpenAIClient.Responses[\"parse\"];\nexport type ResponsesCreateInvoke = ExcludeController<Awaited<ReturnType<ResponsesCreate>>>;\nexport type ResponsesParseInvoke = ExcludeController<Awaited<ReturnType<ResponsesParse>>>;\nexport type ResponsesInputItem = OpenAIClient.Responses.ResponseInputItem;\n/**\n * Converts OpenAI Responses API usage statistics to LangChain's UsageMetadata format.\n *\n * This converter transforms token usage information from OpenAI's Responses API into\n * the standardized UsageMetadata format used throughout LangChain. It handles both\n * basic token counts and detailed token breakdowns including cached tokens and\n * reasoning tokens.\n *\n * @param usage - The usage statistics object from OpenAI's Responses API containing\n *                token counts and optional detailed breakdowns.\n *\n * @returns A UsageMetadata object containing:\n *   - `input_tokens`: Total number of tokens in the input/prompt (defaults to 0 if not provided)\n *   - `output_tokens`: Total number of tokens in the model's output (defaults to 0 if not provided)\n *   - `total_tokens`: Combined total of input and output tokens (defaults to 0 if not provided)\n *   - `input_token_details`: Object containing detailed input token information:\n *     - `cache_read`: Number of tokens read from cache (only included if available)\n *   - `output_token_details`: Object containing detailed output token information:\n *     - `reasoning`: Number of tokens used for reasoning (only included if available)\n *\n * @example\n * ```typescript\n * const usage = {\n *   input_tokens: 100,\n *   output_tokens: 50,\n *   total_tokens: 150,\n *   input_tokens_details: { cached_tokens: 20 },\n *   output_tokens_details: { reasoning_tokens: 10 }\n * };\n *\n * const metadata = convertResponsesUsageToUsageMetadata(usage);\n * // Returns:\n * // {\n * //   input_tokens: 100,\n * //   output_tokens: 50,\n * //   total_tokens: 150,\n * //   input_token_details: { cache_read: 20 },\n * //   output_token_details: { reasoning: 10 }\n * // }\n * ```\n *\n * @remarks\n * - The function safely handles undefined or null values by using optional chaining\n *   and nullish coalescing operators\n * - Detailed token information (cache_read, reasoning) is only included in the result\n *   if the corresponding values are present in the input\n * - Token counts default to 0 if not provided in the usage object\n * - This converter is specifically designed for OpenAI's Responses API format and\n *   may differ from other OpenAI API endpoints\n */\nexport declare const convertResponsesUsageToUsageMetadata: Converter<OpenAIClient.Responses.ResponseUsage | undefined, UsageMetadata>;\n/**\n * Converts an OpenAI Responses API response to a LangChain AIMessage.\n *\n * This converter processes the output from OpenAI's Responses API (both `create` and `parse` methods)\n * and transforms it into a LangChain AIMessage object with all relevant metadata, tool calls, and content.\n *\n * @param response - The response object from OpenAI's Responses API. Can be either:\n *   - ResponsesCreateInvoke: Result from `responses.create()`\n *   - ResponsesParseInvoke: Result from `responses.parse()`\n *\n * @returns An AIMessage containing:\n *   - `id`: The message ID from the response output\n *   - `content`: Array of message content blocks (text, images, etc.)\n *   - `tool_calls`: Array of successfully parsed tool calls\n *   - `invalid_tool_calls`: Array of tool calls that failed to parse\n *   - `usage_metadata`: Token usage information converted to LangChain format\n *   - `additional_kwargs`: Extra data including:\n *     - `refusal`: Refusal text if the model refused to respond\n *     - `reasoning`: Reasoning output for reasoning models\n *     - `tool_outputs`: Results from built-in tools (web search, file search, etc.)\n *     - `parsed`: Parsed structured output when using json_schema format\n *     - Function call ID mappings for tracking\n *   - `response_metadata`: Metadata about the response including model, timestamps, status, etc.\n *\n * @throws Error if the response contains an error object. The error message and code are extracted\n *   from the response.error field.\n *\n * @example\n * ```typescript\n * const response = await client.responses.create({\n *   model: \"gpt-4\",\n *   input: [{ type: \"message\", content: \"Hello\" }]\n * });\n * const message = convertResponsesMessageToAIMessage(response);\n * console.log(message.content); // Message content\n * console.log(message.tool_calls); // Any tool calls made\n * ```\n *\n * @remarks\n * The converter handles multiple output item types:\n * - `message`: Text and structured content from the model\n * - `function_call`: Tool/function calls that need to be executed\n * - `reasoning`: Reasoning traces from reasoning models (o1, o3, etc.)\n * - `custom_tool_call`: Custom tool invocations\n * - Built-in tool outputs: web_search, file_search, code_interpreter, etc.\n *\n * Tool calls are parsed and validated. Invalid tool calls (malformed JSON, etc.) are captured\n * in the `invalid_tool_calls` array rather than throwing errors.\n */\nexport declare const convertResponsesMessageToAIMessage: Converter<ResponsesCreateInvoke | ResponsesParseInvoke, AIMessage>;\n/**\n * Converts a LangChain ChatOpenAI reasoning summary to an OpenAI Responses API reasoning item.\n *\n * This converter transforms reasoning summaries that have been accumulated during streaming\n * (where summary parts may arrive in multiple chunks with the same index) into the final\n * consolidated format expected by OpenAI's Responses API. It combines summary parts that\n * share the same index and removes the index field from the final output.\n *\n * @param reasoning - A ChatOpenAI reasoning summary object containing:\n *   - `id`: The reasoning item ID\n *   - `type`: The type of reasoning (typically \"reasoning\")\n *   - `summary`: Array of summary parts, each with:\n *     - `text`: The summary text content\n *     - `type`: The summary type (e.g., \"summary_text\")\n *     - `index`: The index used to group related summary parts during streaming\n *\n * @returns An OpenAI Responses API ResponseReasoningItem with:\n *   - All properties from the input reasoning object\n *   - `summary`: Consolidated array of summary objects with:\n *     - `text`: Combined text from all parts with the same index\n *     - `type`: The summary type\n *     - No `index` field (removed after consolidation)\n *\n * @example\n * ```typescript\n * // Input: Reasoning summary with multiple parts at the same index\n * const reasoning = {\n *   id: \"reasoning_123\",\n *   type: \"reasoning\",\n *   summary: [\n *     { text: \"First \", type: \"summary_text\", index: 0 },\n *     { text: \"part\", type: \"summary_text\", index: 0 },\n *     { text: \"Second part\", type: \"summary_text\", index: 1 }\n *   ]\n * };\n *\n * const result = convertReasoningSummaryToResponsesReasoningItem(reasoning);\n * // Returns:\n * // {\n * //   id: \"reasoning_123\",\n * //   type: \"reasoning\",\n * //   summary: [\n * //     { text: \"First part\", type: \"summary_text\" },\n * //     { text: \"Second part\", type: \"summary_text\" }\n * //   ]\n * // }\n * ```\n *\n * @remarks\n * - This converter is primarily used when reconstructing complete reasoning items from\n *   streaming chunks, where summary parts may arrive incrementally with index markers\n * - Summary parts with the same index are concatenated in the order they appear\n * - If the reasoning summary contains only one part, no reduction is performed\n * - The index field is used internally during streaming to track which summary parts\n *   belong together, but is removed from the final output as it's not part of the\n *   OpenAI Responses API schema\n * - This is the inverse operation of the streaming accumulation that happens in\n *   `convertResponsesDeltaToChatGenerationChunk`\n */\nexport declare const convertReasoningSummaryToResponsesReasoningItem: Converter<ChatOpenAIReasoningSummary, OpenAIClient.Responses.ResponseReasoningItem>;\n/**\n * Converts OpenAI Responses API stream events to LangChain ChatGenerationChunk objects.\n *\n * This converter processes streaming events from OpenAI's Responses API and transforms them\n * into LangChain ChatGenerationChunk objects that can be used in streaming chat applications.\n * It handles various event types including text deltas, tool calls, reasoning, and metadata updates.\n *\n * @param event - A streaming event from OpenAI's Responses API\n *\n * @returns A ChatGenerationChunk containing:\n *   - `text`: Concatenated text content from all text parts in the event\n *   - `message`: An AIMessageChunk with:\n *     - `id`: Message ID (set when a message output item is added)\n *     - `content`: Array of content blocks (text with optional annotations)\n *     - `tool_call_chunks`: Incremental tool call data (name, args, id)\n *     - `usage_metadata`: Token usage information (only in completion events)\n *     - `additional_kwargs`: Extra data including:\n *       - `refusal`: Refusal text if the model refused to respond\n *       - `reasoning`: Reasoning output for reasoning models (id, type, summary)\n *       - `tool_outputs`: Results from built-in tools (web search, file search, etc.)\n *       - `parsed`: Parsed structured output when using json_schema format\n *       - Function call ID mappings for tracking\n *     - `response_metadata`: Metadata about the response (model, id, etc.)\n *   - `generationInfo`: Additional generation information (e.g., tool output status)\n *\n *   Returns `null` for events that don't produce meaningful chunks:\n *   - Partial image generation events (to avoid storing all partial images in history)\n *   - Unrecognized event types\n *\n * @example\n * ```typescript\n * const stream = await client.responses.create({\n *   model: \"gpt-4\",\n *   input: [{ type: \"message\", content: \"Hello\" }],\n *   stream: true\n * });\n *\n * for await (const event of stream) {\n *   const chunk = convertResponsesDeltaToChatGenerationChunk(event);\n *   if (chunk) {\n *     console.log(chunk.text); // Incremental text\n *     console.log(chunk.message.tool_call_chunks); // Tool call updates\n *   }\n * }\n * ```\n *\n * @remarks\n * - Text content is accumulated in an array with index tracking for proper ordering\n * - Tool call chunks include incremental arguments that need to be concatenated by the consumer\n * - Reasoning summaries are built incrementally across multiple events\n * - Function call IDs are tracked in `additional_kwargs` to map call_id to item id\n * - The `text` field is provided for legacy compatibility with `onLLMNewToken` callbacks\n * - Usage metadata is only available in `response.completed` events\n * - Partial images are intentionally ignored to prevent memory bloat in conversation history\n */\nexport declare const convertResponsesDeltaToChatGenerationChunk: Converter<OpenAIClient.Responses.ResponseStreamEvent, ChatGenerationChunk | null>;\n/**\n * Converts a single LangChain BaseMessage to OpenAI Responses API input format.\n *\n * This converter transforms a LangChain message into one or more ResponseInputItem objects\n * that can be used with OpenAI's Responses API. It handles complex message structures including\n * tool calls, reasoning blocks, multimodal content, and various content block types.\n *\n * @param message - The LangChain BaseMessage to convert. Can be any message type including\n *   HumanMessage, AIMessage, SystemMessage, ToolMessage, etc.\n *\n * @returns An array of ResponseInputItem objects.\n *\n * @example\n * Basic text message conversion:\n * ```typescript\n * const message = new HumanMessage(\"Hello, how are you?\");\n * const items = convertStandardContentMessageToResponsesInput(message);\n * // Returns: [{ type: \"message\", role: \"user\", content: [{ type: \"input_text\", text: \"Hello, how are you?\" }] }]\n * ```\n *\n * @example\n * AI message with tool calls:\n * ```typescript\n * const message = new AIMessage({\n *   content: \"I'll check the weather for you.\",\n *   tool_calls: [{\n *     id: \"call_123\",\n *     name: \"get_weather\",\n *     args: { location: \"San Francisco\" }\n *   }]\n * });\n * const items = convertStandardContentMessageToResponsesInput(message);\n * // Returns:\n * // [\n * //   { type: \"message\", role: \"assistant\", content: [{ type: \"input_text\", text: \"I'll check the weather for you.\" }] },\n * //   { type: \"function_call\", call_id: \"call_123\", name: \"get_weather\", arguments: '{\"location\":\"San Francisco\"}' }\n * // ]\n * ```\n */\nexport declare const convertStandardContentMessageToResponsesInput: Converter<BaseMessage, OpenAIClient.Responses.ResponseInputItem[]>;\n/**\n * - MCP (Model Context Protocol) approval responses\n * - Zero Data Retention (ZDR) mode handling\n *\n * @param params - Conversion parameters\n * @param params.messages - Array of LangChain BaseMessages to convert\n * @param params.zdrEnabled - Whether Zero Data Retention mode is enabled. When true, certain\n *   metadata like message IDs and function call IDs are omitted from the output\n * @param params.model - The model name being used. Used to determine if special role mapping\n *   is needed (e.g., \"system\" -> \"developer\" for reasoning models)\n *\n * @returns Array of ResponsesInputItem objects formatted for the OpenAI Responses API\n *\n * @throws {Error} When a function message is encountered (not supported)\n * @throws {Error} When computer call output format is invalid\n *\n * @example\n * ```typescript\n * const messages = [\n *   new HumanMessage(\"Hello\"),\n *   new AIMessage({ content: \"Hi there!\", tool_calls: [...] })\n * ];\n *\n * const input = convertMessagesToResponsesInput({\n *   messages,\n *   zdrEnabled: false,\n *   model: \"gpt-4\"\n * });\n * ```\n */\nexport declare const convertMessagesToResponsesInput: Converter<{\n    messages: BaseMessage[];\n    zdrEnabled: boolean;\n    model: string;\n}, ResponsesInputItem[]>;\nexport {};\n"],"mappings":";;;;;;;KAKKQ,uBAAuBC;;AAD6B,CAAA,GACpDD,KAAAA,GAEOC,CAFPD;AAAiB,KAGVE,eAAAA,GAAkBT,QAAAA,CAAaU,SAHrB,CAAA,QAAA,CAAA;AAAMF,KAIhBG,cAAAA,GAAiBX,QAAAA,CAAaU,SAJdF,CAAAA,OAAAA,CAAAA;AAEhBA,KAGAI,qBAAAA,GAAwBL,iBAHxBC,CAG0CM,OAH1CN,CAGkDK,UAHlDL,CAG6DC,eAH7DD,CAAAA,CAAAA,CAAAA;AAAC,KAIDO,oBAAAA,GAAuBR,iBAJtB,CAIwCO,OAJxC,CAIgDD,UAJhD,CAI2DF,cAJ3D,CAAA,CAAA,CAAA;AACDF,KAIAO,kBAAAA,GAAqBhB,QAAAA,CAAaU,SAAAA,CAAUO,iBAJJ;AACpD;AACA;;;;;;AAAqD;AACrD;;;;;;AAAoD;AACpD;AAmDA;;;;;AAAoE;AAkDpE;;;;;;AAAkE;AA4DlE;;;;;AAA+E;AAwD/E;;;;;AAA0E;AAwC1E;;;;;AAA6E;AA+B7E;;;AAIGD,cAjPkBE,oCAiPlBF,EAjPwDV,SAiPxDU,CAjPkEhB,QAAAA,CAAaU,SAAAA,CAAUS,aAiPzFH,GAAAA,SAAAA,EAjPoHb,aAiPpHa,CAAAA;;AAJ4D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA3L1CI,oCAAoCd,UAAUM,wBAAwBG,sBAAsBd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4D5FoB,iDAAiDf,UAAUD,4BAA4BL,QAAAA,CAAaU,SAAAA,CAAUY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwD9GC,4CAA4CjB,UAAUN,QAAAA,CAAaU,SAAAA,CAAUc,qBAAqBpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwClGqB,+CAA+CnB,UAAUJ,aAAaF,QAAAA,CAAaU,SAAAA,CAAUO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+B7FS,iCAAiCpB;YACxCJ;;;GAGXc"}

package/dist/embeddings.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"embeddings.d.cts","names":["ClientOptions","OpenAI","OpenAIClient","Embeddings","EmbeddingsParams","OpenAIEmbeddingModelId","EmbeddingModel","NonNullable","OpenAIEmbeddingsParams","OpenAIEmbeddings","TOutput","Partial","Promise","EmbeddingCreateParams","CreateEmbeddingResponse"],"sources":["../src/embeddings.d.ts"],"sourcesContent":["import { type ClientOptions, OpenAI as OpenAIClient } from \"openai\";\nimport { Embeddings, type EmbeddingsParams } from \"@langchain/core/embeddings\";\n/**\n * @see https://platform.openai.com/docs/guides/embeddings#embedding-models\n */\nexport type OpenAIEmbeddingModelId = OpenAIClient.EmbeddingModel | (string & NonNullable<unknown>);\n/**\n * Interface for OpenAIEmbeddings parameters. Extends EmbeddingsParams and\n * defines additional parameters specific to the OpenAIEmbeddings class.\n */\nexport interface OpenAIEmbeddingsParams extends EmbeddingsParams {\n    /**\n     * Model name to use\n     * Alias for `model`\n     * @deprecated Use \"model\" instead.\n     */\n    modelName: OpenAIEmbeddingModelId;\n    /** Model name to use */\n    model: OpenAIEmbeddingModelId;\n    /**\n     * The number of dimensions the resulting output embeddings should have.\n     * Only supported in `text-embedding-3` and later models.\n     */\n    dimensions?: number;\n    /**\n     * Timeout to use when making requests to OpenAI.\n     */\n    timeout?: number;\n    /**\n     * The maximum number of documents to embed in a single request. This is\n     * limited by the OpenAI API to a maximum of 2048.\n     */\n    batchSize?: number;\n    /**\n     * Whether to strip new lines from the input text. This is recommended by\n     * OpenAI for older models, but may not be suitable for all use cases.\n     * See: https://github.com/openai/openai-python/issues/418#issuecomment-1525939500\n     */\n    stripNewLines?: boolean;\n    /**\n     * The format to return the embeddings in. Can be either 'float' or 'base64'.\n     */\n    encodingFormat?: \"float\" | \"base64\";\n}\n/**\n * Class for generating embeddings using the OpenAI API.\n *\n * To use with Azure, import the `AzureOpenAIEmbeddings` class.\n *\n * @example\n * ```typescript\n * // Embed a query using OpenAIEmbeddings to generate embeddings for a given text\n * const model = new OpenAIEmbeddings();\n * const res = await model.embedQuery(\n *   \"What would be a good company name for a company that makes colorful socks?\",\n * );\n * console.log({ res });\n *\n * ```\n */\nexport declare class OpenAIEmbeddings<TOutput = number[]> extends Embeddings<TOutput> implements Partial<OpenAIEmbeddingsParams> {\n    model: string;\n    /** @deprecated Use \"model\" instead */\n    modelName: string;\n    batchSize: number;\n    // TODO: Update to `false` on next minor release (see: https://github.com/langchain-ai/langchainjs/pull/3612)\n    stripNewLines: boolean;\n    /**\n     * The number of dimensions the resulting output embeddings should have.\n     * Only supported in `text-embedding-3` and later models.\n     */\n    dimensions?: number;\n    timeout?: number;\n    organization?: string;\n    encodingFormat?: \"float\" | \"base64\";\n    protected client: OpenAIClient;\n    protected clientConfig: ClientOptions;\n    constructor(fields?: Partial<OpenAIEmbeddingsParams> & {\n        verbose?: boolean;\n        /**\n         * The OpenAI API key to use.\n         * Alias for `apiKey`.\n         */\n        openAIApiKey?: string;\n        /** The OpenAI API key to use. */\n        apiKey?: string;\n        configuration?: ClientOptions;\n    });\n    /**\n     * Method to generate embeddings for an array of documents. Splits the\n     * documents into batches and makes requests to the OpenAI API to generate\n     * embeddings.\n     * @param texts Array of documents to generate embeddings for.\n     * @returns Promise that resolves to a 2D array of embeddings for each document.\n     */\n    embedDocuments(texts: string[]): Promise<TOutput[]>;\n    /**\n     * Method to generate an embedding for a single document. Calls the\n     * embeddingWithRetry method with the document as the input.\n     * @param text Document to generate an embedding for.\n     * @returns Promise that resolves to an embedding for the document.\n     */\n    embedQuery(text: string): Promise<TOutput>;\n    /**\n     * Private method to make a request to the OpenAI API to generate\n     * embeddings. Handles the retry logic and returns the response from the\n     * API.\n     * @param request Request to send to the OpenAI API.\n     * @returns Promise that resolves to the response from the API.\n     */\n    protected embeddingWithRetry(request: OpenAIClient.EmbeddingCreateParams): Promise<OpenAIClient.CreateEmbeddingResponse & {\n        _request_id?: string | null | undefined;\n    }>;\n}\n"],"mappings":";;;;;;;AAKA;AAAkC,KAAtBK,sBAAAA,GAAyBH,QAAAA,CAAaI,cAAhB,GAAA,CAAA,MAAA,GAA2CC,WAA3C,CAAA,OAAA,CAAA,CAAA;;;AAAsD;AAKxF;AAAuC,UAAtBC,sBAAAA,SAA+BJ,gBAAT,CAAA;EAAA;;;AAAyB;AAkDhE;EAAqC,SAAA,EA5CtBC,sBA4CsB;EAAA;EAA+C,KAAqBG,EA1C9FH,sBA0C8FG;EAAsB;;;;EAiB/F,UASRR,CAAAA,EAAAA,MAAAA;EAAa;;;EAgBQ,OAAfY,CAAAA,EAAAA,MAAAA;EAAO;;;;EA1CuC,SAAqBD,CAAAA,EAAAA,MAAAA;EAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAnFF,6CAA6CN,WAAWO,oBAAoBC,QAAQH;;;;;;;;;;;;;;;oBAenFN;0BACMF;uBACHW,QAAQH;;;;;;;;;oBASTR;;;;;;;;;mCASaY,QAAQF;;;;;;;4BAOfE,QAAQF;;;;;;;;wCAQIR,QAAAA,CAAaW,wBAAwBD,QAAQV,QAAAA,CAAaY"}

package/dist/embeddings.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"embeddings.d.ts","names":["ClientOptions","OpenAI","OpenAIClient","Embeddings","EmbeddingsParams","OpenAIEmbeddingModelId","EmbeddingModel","NonNullable","OpenAIEmbeddingsParams","OpenAIEmbeddings","TOutput","Partial","Promise","EmbeddingCreateParams","CreateEmbeddingResponse"],"sources":["../src/embeddings.d.ts"],"sourcesContent":["import { type ClientOptions, OpenAI as OpenAIClient } from \"openai\";\nimport { Embeddings, type EmbeddingsParams } from \"@langchain/core/embeddings\";\n/**\n * @see https://platform.openai.com/docs/guides/embeddings#embedding-models\n */\nexport type OpenAIEmbeddingModelId = OpenAIClient.EmbeddingModel | (string & NonNullable<unknown>);\n/**\n * Interface for OpenAIEmbeddings parameters. Extends EmbeddingsParams and\n * defines additional parameters specific to the OpenAIEmbeddings class.\n */\nexport interface OpenAIEmbeddingsParams extends EmbeddingsParams {\n    /**\n     * Model name to use\n     * Alias for `model`\n     * @deprecated Use \"model\" instead.\n     */\n    modelName: OpenAIEmbeddingModelId;\n    /** Model name to use */\n    model: OpenAIEmbeddingModelId;\n    /**\n     * The number of dimensions the resulting output embeddings should have.\n     * Only supported in `text-embedding-3` and later models.\n     */\n    dimensions?: number;\n    /**\n     * Timeout to use when making requests to OpenAI.\n     */\n    timeout?: number;\n    /**\n     * The maximum number of documents to embed in a single request. This is\n     * limited by the OpenAI API to a maximum of 2048.\n     */\n    batchSize?: number;\n    /**\n     * Whether to strip new lines from the input text. This is recommended by\n     * OpenAI for older models, but may not be suitable for all use cases.\n     * See: https://github.com/openai/openai-python/issues/418#issuecomment-1525939500\n     */\n    stripNewLines?: boolean;\n    /**\n     * The format to return the embeddings in. Can be either 'float' or 'base64'.\n     */\n    encodingFormat?: \"float\" | \"base64\";\n}\n/**\n * Class for generating embeddings using the OpenAI API.\n *\n * To use with Azure, import the `AzureOpenAIEmbeddings` class.\n *\n * @example\n * ```typescript\n * // Embed a query using OpenAIEmbeddings to generate embeddings for a given text\n * const model = new OpenAIEmbeddings();\n * const res = await model.embedQuery(\n *   \"What would be a good company name for a company that makes colorful socks?\",\n * );\n * console.log({ res });\n *\n * ```\n */\nexport declare class OpenAIEmbeddings<TOutput = number[]> extends Embeddings<TOutput> implements Partial<OpenAIEmbeddingsParams> {\n    model: string;\n    /** @deprecated Use \"model\" instead */\n    modelName: string;\n    batchSize: number;\n    // TODO: Update to `false` on next minor release (see: https://github.com/langchain-ai/langchainjs/pull/3612)\n    stripNewLines: boolean;\n    /**\n     * The number of dimensions the resulting output embeddings should have.\n     * Only supported in `text-embedding-3` and later models.\n     */\n    dimensions?: number;\n    timeout?: number;\n    organization?: string;\n    encodingFormat?: \"float\" | \"base64\";\n    protected client: OpenAIClient;\n    protected clientConfig: ClientOptions;\n    constructor(fields?: Partial<OpenAIEmbeddingsParams> & {\n        verbose?: boolean;\n        /**\n         * The OpenAI API key to use.\n         * Alias for `apiKey`.\n         */\n        openAIApiKey?: string;\n        /** The OpenAI API key to use. */\n        apiKey?: string;\n        configuration?: ClientOptions;\n    });\n    /**\n     * Method to generate embeddings for an array of documents. Splits the\n     * documents into batches and makes requests to the OpenAI API to generate\n     * embeddings.\n     * @param texts Array of documents to generate embeddings for.\n     * @returns Promise that resolves to a 2D array of embeddings for each document.\n     */\n    embedDocuments(texts: string[]): Promise<TOutput[]>;\n    /**\n     * Method to generate an embedding for a single document. Calls the\n     * embeddingWithRetry method with the document as the input.\n     * @param text Document to generate an embedding for.\n     * @returns Promise that resolves to an embedding for the document.\n     */\n    embedQuery(text: string): Promise<TOutput>;\n    /**\n     * Private method to make a request to the OpenAI API to generate\n     * embeddings. Handles the retry logic and returns the response from the\n     * API.\n     * @param request Request to send to the OpenAI API.\n     * @returns Promise that resolves to the response from the API.\n     */\n    protected embeddingWithRetry(request: OpenAIClient.EmbeddingCreateParams): Promise<OpenAIClient.CreateEmbeddingResponse & {\n        _request_id?: string | null | undefined;\n    }>;\n}\n"],"mappings":";;;;;;;AAKA;AAAkC,KAAtBK,sBAAAA,GAAyBH,QAAAA,CAAaI,cAAhB,GAAA,CAAA,MAAA,GAA2CC,WAA3C,CAAA,OAAA,CAAA,CAAA;;;AAAsD;AAKxF;AAAuC,UAAtBC,sBAAAA,SAA+BJ,gBAAT,CAAA;EAAA;;;AAAyB;AAkDhE;EAAqC,SAAA,EA5CtBC,sBA4CsB;EAAA;EAA+C,KAAqBG,EA1C9FH,sBA0C8FG;EAAsB;;;;EAiB/F,UASRR,CAAAA,EAAAA,MAAAA;EAAa;;;EAgBQ,OAAfY,CAAAA,EAAAA,MAAAA;EAAO;;;;EA1CuC,SAAqBD,CAAAA,EAAAA,MAAAA;EAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAnFF,6CAA6CN,WAAWO,oBAAoBC,QAAQH;;;;;;;;;;;;;;;oBAenFN;0BACMF;uBACHW,QAAQH;;;;;;;;;oBASTR;;;;;;;;;mCASaY,QAAQF;;;;;;;4BAOfE,QAAQF;;;;;;;;wCAQIR,QAAAA,CAAaW,wBAAwBD,QAAQV,QAAAA,CAAaY"}

package/dist/langchain-core/dist/language_models/chat_models.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chat_models.d.cts","names":["BaseMessage","BaseMessageChunk","BaseMessageLike","AIMessageChunk","MessageOutputVersion","ChatGenerationChunk","ChatResult","Generation","LLMResult","BaseCache","CallbackManagerForLLMRun","Callbacks","RunnableConfig","Runnable","RunnableToolLike","BasePromptValueInterface","BaseLanguageModel","BaseLanguageModelCallOptions","BaseLanguageModelInput","BaseLanguageModelParams","StructuredOutputMethodOptions","ToolDefinition","StructuredToolInterface","StructuredToolParams","ZodType","$ZodType","ToolChoice","Record","SerializedChatModel","SerializedLLM","BaseChatModelParams","BaseChatModelCallOptions","LangSmithParams","Array","BindToolsInput","BaseChatModel","OutputMessageType","CallOptions","Exclude","Omit","Partial","Promise","AsyncGenerator","messages","cache","llmStringKey","parsedOptions","handledOptions","RunOutput","SimpleChatModel"],"sources":["../../../../../../langchain-core/dist/language_models/chat_models.d.ts"],"sourcesContent":["import { BaseMessage, BaseMessageChunk, BaseMessageLike } from \"../messages/base.js\";\nimport { AIMessageChunk } from \"../messages/ai.js\";\nimport { MessageOutputVersion } from \"../messages/message.js\";\nimport { ChatGenerationChunk, ChatResult, Generation, LLMResult } from \"../outputs.js\";\nimport { BaseCache } from \"../caches/base.js\";\nimport { CallbackManagerForLLMRun, Callbacks } from \"../callbacks/manager.js\";\nimport { RunnableConfig } from \"../runnables/types.js\";\nimport { Runnable, RunnableToolLike } from \"../runnables/base.js\";\nimport { BasePromptValueInterface } from \"../prompt_values.js\";\nimport { BaseLanguageModel, BaseLanguageModelCallOptions, BaseLanguageModelInput, BaseLanguageModelParams, StructuredOutputMethodOptions, ToolDefinition } from \"./base.js\";\nimport { StructuredToolInterface, StructuredToolParams } from \"../tools/types.js\";\nimport { ZodType } from \"zod/v3\";\nimport { $ZodType } from \"zod/v4/core\";\n\n//#region src/language_models/chat_models.d.ts\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype ToolChoice = string | Record<string, any> | \"auto\" | \"any\";\n/**\n * Represents a serialized chat model.\n */\ntype SerializedChatModel = {\n  _model: string;\n  _type: string;\n} & Record<string, any>;\n// todo?\n/**\n * Represents a serialized large language model.\n */\ntype SerializedLLM = {\n  _model: string;\n  _type: string;\n} & Record<string, any>;\n/**\n * Represents the parameters for a base chat model.\n */\ntype BaseChatModelParams = BaseLanguageModelParams & {\n  /**\n   * Whether to disable streaming.\n   *\n   * If streaming is bypassed, then `stream()` will defer to\n   * `invoke()`.\n   *\n   * - If true, will always bypass streaming case.\n   * - If false (default), will always use streaming case if available.\n   */\n  disableStreaming?: boolean;\n  /**\n   * Version of `AIMessage` output format to store in message content.\n   *\n   * `AIMessage.contentBlocks` will lazily parse the contents of `content` into a\n   * standard format. This flag can be used to additionally store the standard format\n   * as the message content, e.g., for serialization purposes.\n   *\n   * - \"v0\": provider-specific format in content (can lazily parse with `.contentBlocks`)\n   * - \"v1\": standardized format in content (consistent with `.contentBlocks`)\n   *\n   * You can also set `LC_OUTPUT_VERSION` as an environment variable to \"v1\" to\n   * enable this by default.\n   *\n   * @default \"v0\"\n   */\n  outputVersion?: MessageOutputVersion;\n};\n/**\n * Represents the call options for a base chat model.\n */\ntype BaseChatModelCallOptions = BaseLanguageModelCallOptions & {\n  /**\n   * Specifies how the chat model should use tools.\n   * @default undefined\n   *\n   * Possible values:\n   * - \"auto\": The model may choose to use any of the provided tools, or none.\n   * - \"any\": The model must use one of the provided tools.\n   * - \"none\": The model must not use any tools.\n   * - A string (not \"auto\", \"any\", or \"none\"): The name of a specific tool the model must use.\n   * - An object: A custom schema specifying tool choice parameters. Specific to the provider.\n   *\n   * Note: Not all providers support tool_choice. An error will be thrown\n   * if used with an unsupported model.\n   */\n  tool_choice?: ToolChoice;\n  /**\n   * Version of `AIMessage` output format to store in message content.\n   *\n   * `AIMessage.contentBlocks` will lazily parse the contents of `content` into a\n   * standard format. This flag can be used to additionally store the standard format\n   * as the message content, e.g., for serialization purposes.\n   *\n   * - \"v0\": provider-specific format in content (can lazily parse with `.contentBlocks`)\n   * - \"v1\": standardized format in content (consistent with `.contentBlocks`)\n   *\n   * You can also set `LC_OUTPUT_VERSION` as an environment variable to \"v1\" to\n   * enable this by default.\n   *\n   * @default \"v0\"\n   */\n  outputVersion?: MessageOutputVersion;\n};\ntype LangSmithParams = {\n  ls_provider?: string;\n  ls_model_name?: string;\n  ls_model_type: \"chat\";\n  ls_temperature?: number;\n  ls_max_tokens?: number;\n  ls_stop?: Array<string>;\n};\ntype BindToolsInput = StructuredToolInterface\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n| Record<string, any> | ToolDefinition | RunnableToolLike | StructuredToolParams;\n/**\n * Base class for chat models. It extends the BaseLanguageModel class and\n * provides methods for generating chat based on input messages.\n */\ndeclare abstract class BaseChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions,\n// TODO: Fix the parameter order on the next minor version.\nOutputMessageType extends BaseMessageChunk = AIMessageChunk> extends BaseLanguageModel<OutputMessageType, CallOptions> {\n  // Backwards compatibility since fields have been moved to RunnableConfig\n  ParsedCallOptions: Omit<CallOptions, Exclude<keyof RunnableConfig, \"signal\" | \"timeout\" | \"maxConcurrency\">>;\n  // Only ever instantiated in main LangChain\n  lc_namespace: string[];\n  disableStreaming: boolean;\n  outputVersion?: MessageOutputVersion;\n  get callKeys(): string[];\n  constructor(fields: BaseChatModelParams);\n  _combineLLMOutput?(...llmOutputs: LLMResult[\"llmOutput\"][]): LLMResult[\"llmOutput\"];\n  protected _separateRunnableConfigFromCallOptionsCompat(options?: Partial<CallOptions>): [RunnableConfig, this[\"ParsedCallOptions\"]];\n  /**\n   * Bind tool-like objects to this chat model.\n   *\n   * @param tools A list of tool definitions to bind to this chat model.\n   * Can be a structured tool, an OpenAI formatted tool, or an object\n   * matching the provider's specific tool schema.\n   * @param kwargs Any additional parameters to bind.\n   */\n  bindTools?(tools: BindToolsInput[], kwargs?: Partial<CallOptions>): Runnable<BaseLanguageModelInput, OutputMessageType, CallOptions>;\n  /**\n   * Invokes the chat model with a single input.\n   * @param input The input for the language model.\n   * @param options The call options.\n   * @returns A Promise that resolves to a BaseMessageChunk.\n   */\n  invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<OutputMessageType>;\n  // eslint-disable-next-line require-yield\n  _streamResponseChunks(_messages: BaseMessage[], _options: this[\"ParsedCallOptions\"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;\n  _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<OutputMessageType>;\n  getLsParams(options: this[\"ParsedCallOptions\"]): LangSmithParams;\n  /** @ignore */\n  _generateUncached(messages: BaseMessageLike[][], parsedOptions: this[\"ParsedCallOptions\"], handledOptions: RunnableConfig, startedRunManagers?: CallbackManagerForLLMRun[]): Promise<LLMResult>;\n  _generateCached({\n    messages,\n    cache,\n    llmStringKey,\n    parsedOptions,\n    handledOptions\n  }: {\n    messages: BaseMessageLike[][];\n    cache: BaseCache<Generation[]>;\n    llmStringKey: string;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    parsedOptions: any;\n    handledOptions: RunnableConfig;\n  }): Promise<LLMResult & {\n    missingPromptIndices: number[];\n    startedRunManagers?: CallbackManagerForLLMRun[];\n  }>;\n  /**\n   * Generates chat based on the input messages.\n   * @param messages An array of arrays of BaseMessage instances.\n   * @param options The call options or an array of stop sequences.\n   * @param callbacks The callbacks for the language model.\n   * @returns A Promise that resolves to an LLMResult.\n   */\n  generate(messages: BaseMessageLike[][], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n  /**\n   * Get the parameters used to invoke the model\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  invocationParams(_options?: this[\"ParsedCallOptions\"]): any;\n  _modelType(): string;\n  abstract _llmType(): string;\n  /**\n   * Generates a prompt based on the input prompt values.\n   * @param promptValues An array of BasePromptValue instances.\n   * @param options The call options or an array of stop sequences.\n   * @param callbacks The callbacks for the language model.\n   * @returns A Promise that resolves to an LLMResult.\n   */\n  generatePrompt(promptValues: BasePromptValueInterface[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n  abstract _generate(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;\n  withStructuredOutput<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: $ZodType<RunOutput>\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;\n  withStructuredOutput<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: $ZodType<RunOutput>\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {\n    raw: BaseMessage;\n    parsed: RunOutput;\n  }>;\n  withStructuredOutput<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodType<RunOutput>\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;\n  withStructuredOutput<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodType<RunOutput>\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {\n    raw: BaseMessage;\n    parsed: RunOutput;\n  }>;\n}\n/**\n * An abstract class that extends BaseChatModel and provides a simple\n * implementation of _generate.\n */\ndeclare abstract class SimpleChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions> extends BaseChatModel<CallOptions> {\n  abstract _call(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<string>;\n  _generate(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;\n}\n//#endregion\nexport { BaseChatModel, BaseChatModelCallOptions, BaseChatModelParams, BindToolsInput, LangSmithParams, SerializedChatModel, SerializedLLM, SimpleChatModel, ToolChoice };\n//# sourceMappingURL=chat_models.d.ts.map"],"mappings":";;KAmGKgC,eAAAA;;;;;;YAMOC"}

package/dist/langchain-core/dist/language_models/chat_models.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chat_models.d.ts","names":["BaseMessage","BaseMessageChunk","BaseMessageLike","AIMessageChunk","MessageOutputVersion","ChatGenerationChunk","ChatResult","Generation","LLMResult","BaseCache","CallbackManagerForLLMRun","Callbacks","RunnableConfig","Runnable","RunnableToolLike","BasePromptValueInterface","BaseLanguageModel","BaseLanguageModelCallOptions","BaseLanguageModelInput","BaseLanguageModelParams","StructuredOutputMethodOptions","ToolDefinition","StructuredToolInterface","StructuredToolParams","ZodType","$ZodType","ToolChoice","Record","SerializedChatModel","SerializedLLM","BaseChatModelParams","BaseChatModelCallOptions","LangSmithParams","Array","BindToolsInput","BaseChatModel","OutputMessageType","CallOptions","Exclude","Omit","Partial","Promise","AsyncGenerator","messages","cache","llmStringKey","parsedOptions","handledOptions","RunOutput","SimpleChatModel"],"sources":["../../../../../../langchain-core/dist/language_models/chat_models.d.ts"],"sourcesContent":["import { BaseMessage, BaseMessageChunk, BaseMessageLike } from \"../messages/base.js\";\nimport { AIMessageChunk } from \"../messages/ai.js\";\nimport { MessageOutputVersion } from \"../messages/message.js\";\nimport { ChatGenerationChunk, ChatResult, Generation, LLMResult } from \"../outputs.js\";\nimport { BaseCache } from \"../caches/base.js\";\nimport { CallbackManagerForLLMRun, Callbacks } from \"../callbacks/manager.js\";\nimport { RunnableConfig } from \"../runnables/types.js\";\nimport { Runnable, RunnableToolLike } from \"../runnables/base.js\";\nimport { BasePromptValueInterface } from \"../prompt_values.js\";\nimport { BaseLanguageModel, BaseLanguageModelCallOptions, BaseLanguageModelInput, BaseLanguageModelParams, StructuredOutputMethodOptions, ToolDefinition } from \"./base.js\";\nimport { StructuredToolInterface, StructuredToolParams } from \"../tools/types.js\";\nimport { ZodType } from \"zod/v3\";\nimport { $ZodType } from \"zod/v4/core\";\n\n//#region src/language_models/chat_models.d.ts\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype ToolChoice = string | Record<string, any> | \"auto\" | \"any\";\n/**\n * Represents a serialized chat model.\n */\ntype SerializedChatModel = {\n  _model: string;\n  _type: string;\n} & Record<string, any>;\n// todo?\n/**\n * Represents a serialized large language model.\n */\ntype SerializedLLM = {\n  _model: string;\n  _type: string;\n} & Record<string, any>;\n/**\n * Represents the parameters for a base chat model.\n */\ntype BaseChatModelParams = BaseLanguageModelParams & {\n  /**\n   * Whether to disable streaming.\n   *\n   * If streaming is bypassed, then `stream()` will defer to\n   * `invoke()`.\n   *\n   * - If true, will always bypass streaming case.\n   * - If false (default), will always use streaming case if available.\n   */\n  disableStreaming?: boolean;\n  /**\n   * Version of `AIMessage` output format to store in message content.\n   *\n   * `AIMessage.contentBlocks` will lazily parse the contents of `content` into a\n   * standard format. This flag can be used to additionally store the standard format\n   * as the message content, e.g., for serialization purposes.\n   *\n   * - \"v0\": provider-specific format in content (can lazily parse with `.contentBlocks`)\n   * - \"v1\": standardized format in content (consistent with `.contentBlocks`)\n   *\n   * You can also set `LC_OUTPUT_VERSION` as an environment variable to \"v1\" to\n   * enable this by default.\n   *\n   * @default \"v0\"\n   */\n  outputVersion?: MessageOutputVersion;\n};\n/**\n * Represents the call options for a base chat model.\n */\ntype BaseChatModelCallOptions = BaseLanguageModelCallOptions & {\n  /**\n   * Specifies how the chat model should use tools.\n   * @default undefined\n   *\n   * Possible values:\n   * - \"auto\": The model may choose to use any of the provided tools, or none.\n   * - \"any\": The model must use one of the provided tools.\n   * - \"none\": The model must not use any tools.\n   * - A string (not \"auto\", \"any\", or \"none\"): The name of a specific tool the model must use.\n   * - An object: A custom schema specifying tool choice parameters. Specific to the provider.\n   *\n   * Note: Not all providers support tool_choice. An error will be thrown\n   * if used with an unsupported model.\n   */\n  tool_choice?: ToolChoice;\n  /**\n   * Version of `AIMessage` output format to store in message content.\n   *\n   * `AIMessage.contentBlocks` will lazily parse the contents of `content` into a\n   * standard format. This flag can be used to additionally store the standard format\n   * as the message content, e.g., for serialization purposes.\n   *\n   * - \"v0\": provider-specific format in content (can lazily parse with `.contentBlocks`)\n   * - \"v1\": standardized format in content (consistent with `.contentBlocks`)\n   *\n   * You can also set `LC_OUTPUT_VERSION` as an environment variable to \"v1\" to\n   * enable this by default.\n   *\n   * @default \"v0\"\n   */\n  outputVersion?: MessageOutputVersion;\n};\ntype LangSmithParams = {\n  ls_provider?: string;\n  ls_model_name?: string;\n  ls_model_type: \"chat\";\n  ls_temperature?: number;\n  ls_max_tokens?: number;\n  ls_stop?: Array<string>;\n};\ntype BindToolsInput = StructuredToolInterface\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n| Record<string, any> | ToolDefinition | RunnableToolLike | StructuredToolParams;\n/**\n * Base class for chat models. It extends the BaseLanguageModel class and\n * provides methods for generating chat based on input messages.\n */\ndeclare abstract class BaseChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions,\n// TODO: Fix the parameter order on the next minor version.\nOutputMessageType extends BaseMessageChunk = AIMessageChunk> extends BaseLanguageModel<OutputMessageType, CallOptions> {\n  // Backwards compatibility since fields have been moved to RunnableConfig\n  ParsedCallOptions: Omit<CallOptions, Exclude<keyof RunnableConfig, \"signal\" | \"timeout\" | \"maxConcurrency\">>;\n  // Only ever instantiated in main LangChain\n  lc_namespace: string[];\n  disableStreaming: boolean;\n  outputVersion?: MessageOutputVersion;\n  get callKeys(): string[];\n  constructor(fields: BaseChatModelParams);\n  _combineLLMOutput?(...llmOutputs: LLMResult[\"llmOutput\"][]): LLMResult[\"llmOutput\"];\n  protected _separateRunnableConfigFromCallOptionsCompat(options?: Partial<CallOptions>): [RunnableConfig, this[\"ParsedCallOptions\"]];\n  /**\n   * Bind tool-like objects to this chat model.\n   *\n   * @param tools A list of tool definitions to bind to this chat model.\n   * Can be a structured tool, an OpenAI formatted tool, or an object\n   * matching the provider's specific tool schema.\n   * @param kwargs Any additional parameters to bind.\n   */\n  bindTools?(tools: BindToolsInput[], kwargs?: Partial<CallOptions>): Runnable<BaseLanguageModelInput, OutputMessageType, CallOptions>;\n  /**\n   * Invokes the chat model with a single input.\n   * @param input The input for the language model.\n   * @param options The call options.\n   * @returns A Promise that resolves to a BaseMessageChunk.\n   */\n  invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<OutputMessageType>;\n  // eslint-disable-next-line require-yield\n  _streamResponseChunks(_messages: BaseMessage[], _options: this[\"ParsedCallOptions\"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;\n  _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<OutputMessageType>;\n  getLsParams(options: this[\"ParsedCallOptions\"]): LangSmithParams;\n  /** @ignore */\n  _generateUncached(messages: BaseMessageLike[][], parsedOptions: this[\"ParsedCallOptions\"], handledOptions: RunnableConfig, startedRunManagers?: CallbackManagerForLLMRun[]): Promise<LLMResult>;\n  _generateCached({\n    messages,\n    cache,\n    llmStringKey,\n    parsedOptions,\n    handledOptions\n  }: {\n    messages: BaseMessageLike[][];\n    cache: BaseCache<Generation[]>;\n    llmStringKey: string;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    parsedOptions: any;\n    handledOptions: RunnableConfig;\n  }): Promise<LLMResult & {\n    missingPromptIndices: number[];\n    startedRunManagers?: CallbackManagerForLLMRun[];\n  }>;\n  /**\n   * Generates chat based on the input messages.\n   * @param messages An array of arrays of BaseMessage instances.\n   * @param options The call options or an array of stop sequences.\n   * @param callbacks The callbacks for the language model.\n   * @returns A Promise that resolves to an LLMResult.\n   */\n  generate(messages: BaseMessageLike[][], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n  /**\n   * Get the parameters used to invoke the model\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  invocationParams(_options?: this[\"ParsedCallOptions\"]): any;\n  _modelType(): string;\n  abstract _llmType(): string;\n  /**\n   * Generates a prompt based on the input prompt values.\n   * @param promptValues An array of BasePromptValue instances.\n   * @param options The call options or an array of stop sequences.\n   * @param callbacks The callbacks for the language model.\n   * @returns A Promise that resolves to an LLMResult.\n   */\n  generatePrompt(promptValues: BasePromptValueInterface[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n  abstract _generate(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;\n  withStructuredOutput<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: $ZodType<RunOutput>\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;\n  withStructuredOutput<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: $ZodType<RunOutput>\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {\n    raw: BaseMessage;\n    parsed: RunOutput;\n  }>;\n  withStructuredOutput<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodType<RunOutput>\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;\n  withStructuredOutput<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodType<RunOutput>\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {\n    raw: BaseMessage;\n    parsed: RunOutput;\n  }>;\n}\n/**\n * An abstract class that extends BaseChatModel and provides a simple\n * implementation of _generate.\n */\ndeclare abstract class SimpleChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions> extends BaseChatModel<CallOptions> {\n  abstract _call(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<string>;\n  _generate(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;\n}\n//#endregion\nexport { BaseChatModel, BaseChatModelCallOptions, BaseChatModelParams, BindToolsInput, LangSmithParams, SerializedChatModel, SerializedLLM, SimpleChatModel, ToolChoice };\n//# sourceMappingURL=chat_models.d.ts.map"],"mappings":";;;;;;;;;KAmGKgC,eAAAA;;;;;;YAMOC"}

package/dist/langchain-core/dist/types/_internal.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_internal.d.cts","names":["IterableReadableStreamInterface","T","ReadableStream","AsyncIterable"],"sources":["../../../../../../langchain-core/dist/types/_internal.d.ts"],"sourcesContent":["//#region src/types/_internal.d.ts\n// Make this a type to override ReadableStream's async iterator type in case\n// the popular web-streams-polyfill is imported - the supplied types\n// in that case don't quite match.\ntype IterableReadableStreamInterface<T> = ReadableStream<T> & AsyncIterable<T>;\n//#endregion\nexport { IterableReadableStreamInterface };\n//# sourceMappingURL=_internal.d.ts.map"],"mappings":";;;;;KAIKA,+BAAqCE,CAAAA,CAAAA,CAAAA,GAAAA,cAAAA,CAAeD,CAAfC,CAAAA,GAAoBC,aAApBD,CAAkCD,CAAlCC,CAAAA"}

package/dist/langchain-core/dist/types/_internal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_internal.d.ts","names":["IterableReadableStreamInterface","T","ReadableStream","AsyncIterable"],"sources":["../../../../../../langchain-core/dist/types/_internal.d.ts"],"sourcesContent":["//#region src/types/_internal.d.ts\n// Make this a type to override ReadableStream's async iterator type in case\n// the popular web-streams-polyfill is imported - the supplied types\n// in that case don't quite match.\ntype IterableReadableStreamInterface<T> = ReadableStream<T> & AsyncIterable<T>;\n//#endregion\nexport { IterableReadableStreamInterface };\n//# sourceMappingURL=_internal.d.ts.map"],"mappings":";;;;;KAIKA,+BAAqCE,CAAAA,CAAAA,CAAAA,GAAAA,cAAAA,CAAeD,CAAfC,CAAAA,GAAoBC,aAApBD,CAAkCD,CAAlCC,CAAAA"}

package/dist/langchain-core/dist/utils/stream.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream.d.cts","names":["IterableReadableStreamInterface","IterableReadableStream","T","ReadableStreamDefaultReader","IteratorResult","Promise","Symbol","asyncIterator","asyncDispose","ReadableStream","AsyncGenerator","atee","concat","Array","Record","AsyncGeneratorWithSetup","TReturn","TNext","S","AbortSignal","PromiseLike","Error","pipeGeneratorWithSetup","A","U","UReturn","UNext","Awaited"],"sources":["../../../../../../langchain-core/dist/utils/stream.d.ts"],"sourcesContent":["import { IterableReadableStreamInterface } from \"../types/_internal.js\";\n\n//#region src/utils/stream.d.ts\n\n/*\n * Support async iterator syntax for ReadableStreams in all environments.\n * Source: https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490\n */\ndeclare class IterableReadableStream<T> extends ReadableStream<T> implements IterableReadableStreamInterface<T> {\n  reader: ReadableStreamDefaultReader<T>;\n  ensureReader(): void;\n  next(): Promise<IteratorResult<T>>;\n  return(): Promise<IteratorResult<T>>;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  throw(e: any): Promise<IteratorResult<T>>;\n  [Symbol.asyncIterator](): this;\n  // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n  // @ts-ignore Not present in Node 18 types, required in latest Node 22\n  [Symbol.asyncDispose](): Promise<void>;\n  static fromReadableStream<T>(stream: ReadableStream<T>): IterableReadableStream<T>;\n  static fromAsyncGenerator<T>(generator: AsyncGenerator<T>): IterableReadableStream<T>;\n}\ndeclare function atee<T>(iter: AsyncGenerator<T>, length?: number): AsyncGenerator<T>[];\ndeclare function concat<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nT extends Array<any> | string | number | Record<string, any> | any>(first: T, second: T): T;\ndeclare class AsyncGeneratorWithSetup<S = unknown, T = unknown, TReturn = unknown, TNext = unknown> implements AsyncGenerator<T, TReturn, TNext> {\n  private generator;\n  setup: Promise<S>;\n  config?: unknown;\n  signal?: AbortSignal;\n  private firstResult;\n  private firstResultUsed;\n  constructor(params: {\n    generator: AsyncGenerator<T>;\n    startSetup?: () => Promise<S>;\n    config?: unknown;\n    signal?: AbortSignal;\n  });\n  next(...args: [] | [TNext]): Promise<IteratorResult<T>>;\n  return(value?: TReturn | PromiseLike<TReturn>): Promise<IteratorResult<T>>;\n  throw(e: Error): Promise<IteratorResult<T>>;\n  [Symbol.asyncIterator](): this;\n  // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n  // @ts-ignore Not present in Node 18 types, required in latest Node 22\n  [Symbol.asyncDispose](): Promise<void>;\n}\ndeclare function pipeGeneratorWithSetup<S, A extends unknown[], T, TReturn, TNext, U, UReturn, UNext>(to: (g: AsyncGenerator<T, TReturn, TNext>, s: S, ...args: A) => AsyncGenerator<U, UReturn, UNext>, generator: AsyncGenerator<T, TReturn, TNext>, startSetup: () => Promise<S>, signal: AbortSignal | undefined, ...args: A): Promise<{\n  output: AsyncGenerator<U, UReturn, UNext>;\n  setup: Awaited<S>;\n}>;\n//#endregion\nexport { AsyncGeneratorWithSetup, IterableReadableStream, type IterableReadableStreamInterface, atee, concat, pipeGeneratorWithSetup };\n//# sourceMappingURL=stream.d.ts.map"],"mappings":";;;;;;;;;cAQcC,sBACJE,CAAAA,CAAAA,CAAAA,SADsCM,cACtCN,CADqDD,CACrDC,CAAAA,YADmEH,+BACnEG,CADmGD,CACnGC,CAAAA,CAAAA;EAA2B,MAEJD,EAFvBC,2BAEuBD,CAFKA,CAELA,CAAAA;EAAC,YAAhBE,CAAAA,CAAAA,EAAAA,IAAAA;EAAc,IAAA,CAAA,CAAtBC,EAAAA,OAAAA,CAAQD,cAARC,CAAuBH,CAAvBG,CAAAA,CAAAA;EAAO,MACkBH,CAAAA,CAAAA,EAAvBG,OAAuBH,CAAfE,cAAeF,CAAAA,CAAAA,CAAAA,CAAAA;EAAC;EAAF,KAAtBG,CAAAA,CAAAA,EAAAA,GAAAA,CAAAA,EAEKA,OAFLA,CAEaD,cAFbC,CAE4BH,CAF5BG,CAAAA,CAAAA;EAAO,CAGhBC,MAAAA,CAAOC,aAAAA,GAD8BL,EAAAA,IAAAA;EAAC;EAAF;EAAf,CAIrBI,MAAAA,CAAOE,YAAAA,GAHAD,EAGiBF,OAHjBE,CAAAA,IAAAA,CAAAA;EAAa,OAGIF,kBAAAA,CAAAA,CAAAA,CAAAA,CAAAA,MAAAA,EACYI,cADZJ,CAC2BH,CAD3BG,CAAAA,CAAAA,EACgCJ,sBADhCI,CACuDH,CADvDG,CAAAA;EAAO,OAA/BC,kBAAOE,CAAAA,CAAAA,CAAAA,CAAAA,SAAAA,EAEgCE,cAFhCF,CAE+CN,CAF/CM,CAAAA,CAAAA,EAEoDP,sBAFpDO,CAE2EN,CAF3EM,CAAAA"}

package/dist/langchain-core/dist/utils/stream.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream.d.ts","names":["IterableReadableStreamInterface","IterableReadableStream","T","ReadableStreamDefaultReader","IteratorResult","Promise","Symbol","asyncIterator","asyncDispose","ReadableStream","AsyncGenerator","atee","concat","Array","Record","AsyncGeneratorWithSetup","TReturn","TNext","S","AbortSignal","PromiseLike","Error","pipeGeneratorWithSetup","A","U","UReturn","UNext","Awaited"],"sources":["../../../../../../langchain-core/dist/utils/stream.d.ts"],"sourcesContent":["import { IterableReadableStreamInterface } from \"../types/_internal.js\";\n\n//#region src/utils/stream.d.ts\n\n/*\n * Support async iterator syntax for ReadableStreams in all environments.\n * Source: https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490\n */\ndeclare class IterableReadableStream<T> extends ReadableStream<T> implements IterableReadableStreamInterface<T> {\n  reader: ReadableStreamDefaultReader<T>;\n  ensureReader(): void;\n  next(): Promise<IteratorResult<T>>;\n  return(): Promise<IteratorResult<T>>;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  throw(e: any): Promise<IteratorResult<T>>;\n  [Symbol.asyncIterator](): this;\n  // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n  // @ts-ignore Not present in Node 18 types, required in latest Node 22\n  [Symbol.asyncDispose](): Promise<void>;\n  static fromReadableStream<T>(stream: ReadableStream<T>): IterableReadableStream<T>;\n  static fromAsyncGenerator<T>(generator: AsyncGenerator<T>): IterableReadableStream<T>;\n}\ndeclare function atee<T>(iter: AsyncGenerator<T>, length?: number): AsyncGenerator<T>[];\ndeclare function concat<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nT extends Array<any> | string | number | Record<string, any> | any>(first: T, second: T): T;\ndeclare class AsyncGeneratorWithSetup<S = unknown, T = unknown, TReturn = unknown, TNext = unknown> implements AsyncGenerator<T, TReturn, TNext> {\n  private generator;\n  setup: Promise<S>;\n  config?: unknown;\n  signal?: AbortSignal;\n  private firstResult;\n  private firstResultUsed;\n  constructor(params: {\n    generator: AsyncGenerator<T>;\n    startSetup?: () => Promise<S>;\n    config?: unknown;\n    signal?: AbortSignal;\n  });\n  next(...args: [] | [TNext]): Promise<IteratorResult<T>>;\n  return(value?: TReturn | PromiseLike<TReturn>): Promise<IteratorResult<T>>;\n  throw(e: Error): Promise<IteratorResult<T>>;\n  [Symbol.asyncIterator](): this;\n  // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n  // @ts-ignore Not present in Node 18 types, required in latest Node 22\n  [Symbol.asyncDispose](): Promise<void>;\n}\ndeclare function pipeGeneratorWithSetup<S, A extends unknown[], T, TReturn, TNext, U, UReturn, UNext>(to: (g: AsyncGenerator<T, TReturn, TNext>, s: S, ...args: A) => AsyncGenerator<U, UReturn, UNext>, generator: AsyncGenerator<T, TReturn, TNext>, startSetup: () => Promise<S>, signal: AbortSignal | undefined, ...args: A): Promise<{\n  output: AsyncGenerator<U, UReturn, UNext>;\n  setup: Awaited<S>;\n}>;\n//#endregion\nexport { AsyncGeneratorWithSetup, IterableReadableStream, type IterableReadableStreamInterface, atee, concat, pipeGeneratorWithSetup };\n//# sourceMappingURL=stream.d.ts.map"],"mappings":";;;;;;;;;cAQcC,sBACJE,CAAAA,CAAAA,CAAAA,SADsCM,cACtCN,CADqDD,CACrDC,CAAAA,YADmEH,+BACnEG,CADmGD,CACnGC,CAAAA,CAAAA;EAA2B,MAEJD,EAFvBC,2BAEuBD,CAFKA,CAELA,CAAAA;EAAC,YAAhBE,CAAAA,CAAAA,EAAAA,IAAAA;EAAc,IAAA,CAAA,CAAtBC,EAAAA,OAAAA,CAAQD,cAARC,CAAuBH,CAAvBG,CAAAA,CAAAA;EAAO,MACkBH,CAAAA,CAAAA,EAAvBG,OAAuBH,CAAfE,cAAeF,CAAAA,CAAAA,CAAAA,CAAAA;EAAC;EAAF,KAAtBG,CAAAA,CAAAA,EAAAA,GAAAA,CAAAA,EAEKA,OAFLA,CAEaD,cAFbC,CAE4BH,CAF5BG,CAAAA,CAAAA;EAAO,CAGhBC,MAAAA,CAAOC,aAAAA,GAD8BL,EAAAA,IAAAA;EAAC;EAAF;EAAf,CAIrBI,MAAAA,CAAOE,YAAAA,GAHAD,EAGiBF,OAHjBE,CAAAA,IAAAA,CAAAA;EAAa,OAGIF,kBAAAA,CAAAA,CAAAA,CAAAA,CAAAA,MAAAA,EACYI,cADZJ,CAC2BH,CAD3BG,CAAAA,CAAAA,EACgCJ,sBADhCI,CACuDH,CADvDG,CAAAA;EAAO,OAA/BC,kBAAOE,CAAAA,CAAAA,CAAAA,CAAAA,SAAAA,EAEgCE,cAFhCF,CAE+CN,CAF/CM,CAAAA,CAAAA,EAEoDP,sBAFpDO,CAE2EN,CAF3EM,CAAAA"}

package/dist/llms.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"llms.d.cts","names":["ClientOptions","OpenAI","OpenAIClient","CallbackManagerForLLMRun","GenerationChunk","LLMResult","BaseLLM","BaseLLMParams","OpenAICallOptions","OpenAICoreRequestOptions","OpenAIInput","CallOptions","Record","Partial","CompletionCreateParams","Omit","Promise","AsyncGenerator","CompletionCreateParamsStreaming","Completion","AsyncIterable","CompletionCreateParamsNonStreaming","Completions"],"sources":["../src/llms.d.ts"],"sourcesContent":["import { type ClientOptions, OpenAI as OpenAIClient } from \"openai\";\nimport { CallbackManagerForLLMRun } from \"@langchain/core/callbacks/manager\";\nimport { GenerationChunk, type LLMResult } from \"@langchain/core/outputs\";\nimport { BaseLLM, type BaseLLMParams } from \"@langchain/core/language_models/llms\";\nimport type { OpenAICallOptions, OpenAICoreRequestOptions, OpenAIInput } from \"./types.js\";\nexport type { OpenAICallOptions, OpenAIInput };\n/**\n * Wrapper around OpenAI large language models.\n *\n * To use you should have the `openai` package installed, with the\n * `OPENAI_API_KEY` environment variable set.\n *\n * To use with Azure, import the `AzureOpenAI` class.\n *\n * @remarks\n * Any parameters that are valid to be passed to {@link\n * https://platform.openai.com/docs/api-reference/completions/create |\n * `openai.createCompletion`} can be passed through {@link modelKwargs}, even\n * if not explicitly available on this class.\n * @example\n * ```typescript\n * const model = new OpenAI({\n *   modelName: \"gpt-4\",\n *   temperature: 0.7,\n *   maxTokens: 1000,\n *   maxRetries: 5,\n * });\n *\n * const res = await model.invoke(\n *   \"Question: What would be a good company name for a company that makes colorful socks?\\nAnswer:\"\n * );\n * console.log({ res });\n * ```\n */\nexport declare class OpenAI<CallOptions extends OpenAICallOptions = OpenAICallOptions> extends BaseLLM<CallOptions> implements Partial<OpenAIInput> {\n    static lc_name(): string;\n    get callKeys(): string[];\n    lc_serializable: boolean;\n    get lc_secrets(): {\n        [key: string]: string;\n    } | undefined;\n    get lc_aliases(): Record<string, string>;\n    temperature?: number;\n    maxTokens?: number;\n    topP?: number;\n    frequencyPenalty?: number;\n    presencePenalty?: number;\n    n: number;\n    bestOf?: number;\n    logitBias?: Record<string, number>;\n    model: string;\n    /** @deprecated Use \"model\" instead */\n    modelName: string;\n    modelKwargs?: OpenAIInput[\"modelKwargs\"];\n    batchSize: number;\n    timeout?: number;\n    stop?: string[];\n    stopSequences?: string[];\n    user?: string;\n    streaming: boolean;\n    openAIApiKey?: string;\n    apiKey?: string;\n    organization?: string;\n    protected client: OpenAIClient;\n    protected clientConfig: ClientOptions;\n    constructor(fields?: Partial<OpenAIInput> & BaseLLMParams & {\n        configuration?: ClientOptions;\n    });\n    /**\n     * Get the parameters used to invoke the model\n     */\n    invocationParams(options?: this[\"ParsedCallOptions\"]): Omit<OpenAIClient.CompletionCreateParams, \"prompt\">;\n    /** @ignore */\n    _identifyingParams(): Omit<OpenAIClient.CompletionCreateParams, \"prompt\"> & {\n        model_name: string;\n    } & ClientOptions;\n    /**\n     * Get the identifying parameters for the model\n     */\n    identifyingParams(): Omit<OpenAIClient.CompletionCreateParams, \"prompt\"> & {\n        model_name: string;\n    } & ClientOptions;\n    /**\n     * Call out to OpenAI's endpoint with k unique prompts\n     *\n     * @param [prompts] - The prompts to pass into the model.\n     * @param [options] - Optional list of stop words to use when generating.\n     * @param [runManager] - Optional callback manager to use when generating.\n     *\n     * @returns The full LLM output.\n     *\n     * @example\n     * ```ts\n     * import { OpenAI } from \"langchain/llms/openai\";\n     * const openai = new OpenAI();\n     * const response = await openai.generate([\"Tell me a joke.\"]);\n     * ```\n     */\n    _generate(prompts: string[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<LLMResult>;\n    // TODO(jacoblee): Refactor with _generate(..., {stream: true}) implementation?\n    _streamResponseChunks(input: string, options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<GenerationChunk>;\n    /**\n     * Calls the OpenAI API with retry logic in case of failures.\n     * @param request The request to send to the OpenAI API.\n     * @param options Optional configuration for the API call.\n     * @returns The response from the OpenAI API.\n     */\n    completionWithRetry(request: OpenAIClient.CompletionCreateParamsStreaming, options?: OpenAICoreRequestOptions): Promise<AsyncIterable<OpenAIClient.Completion>>;\n    completionWithRetry(request: OpenAIClient.CompletionCreateParamsNonStreaming, options?: OpenAICoreRequestOptions): Promise<OpenAIClient.Completions.Completion>;\n    /**\n     * Calls the OpenAI API with retry logic in case of failures.\n     * @param request The request to send to the OpenAI API.\n     * @param options Optional configuration for the API call.\n     * @returns The response from the OpenAI API.\n     */\n    protected _getClientOptions(options: OpenAICoreRequestOptions | undefined): OpenAICoreRequestOptions;\n    _llmType(): string;\n}\n"],"mappings":";;;;;;;;;AAkCA;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkEoII,cAlE/GH,QAkE+GG,CAAAA,oBAlEpFI,iBAkEoFJ,GAlEhEI,iBAkEgEJ,CAAAA,SAlErCE,OAkEqCF,CAlE7BO,WAkE6BP,CAAAA,YAlELS,OAkEKT,CAlEGM,WAkEHN,CAAAA,CAAAA;EAAe,OAA9Ba,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAc,IAOlGf,QAAagB,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAA+B,eAAYT,EAAAA,OAAAA;EAAwB,IAAyBP,UAAaiB,CAAAA,CAAAA,EAAAA;IAA3BC,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EAAAA,MAAAA;EAAa,CAAA,GAArBJ,SAAAA;EAAO,IAC1Fd,UAAamB,CAAAA,CAAAA,EAnExBT,MAmEwBS,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAAkC,WAAYZ,CAAAA,EAAAA,MAAAA;EAAwB,SAAWP,CAAAA,EAAaoB,MAAAA;EAAsB,IAA3CN,CAAAA,EAAAA,MAAAA;EAAO,gBAOrFP,CAAAA,EAAAA,MAAAA;EAAwB,eAAeA,CAAAA,EAAAA,MAAAA;EAAwB,CAAA,EAjFTH,MAAAA;EAAO,MAAyBO,CAAAA,EAAAA,MAAAA;EAAO,SAAA,CAAA,EAetHD,MAfsH,CAAA,MAAA,EAAA,MAAA,CAAA;;;;gBAmBpHF;;;;;;;;;;oBAUIR;0BACMF;uBACHa,QAAQH,eAAeH;oBACxBP;;;;;yDAKmCe,KAAKb,QAAAA,CAAaY;;wBAEnDC,KAAKb,QAAAA,CAAaY;;MAEpCd;;;;uBAIiBe,KAAKb,QAAAA,CAAaY;;MAEnCd;;;;;;;;;;;;;;;;;gFAiB0EG,2BAA2Ba,QAAQX;;wFAE3BF,2BAA2Bc,eAAeb;;;;;;;+BAOnGF,QAAAA,CAAagB,2CAA2CT,2BAA2BO,QAAQI,cAAclB,QAAAA,CAAaiB;+BACtHjB,QAAAA,CAAamB,8CAA8CZ,2BAA2BO,QAAQd,QAAAA,CAAaoB,WAAAA,CAAYH;;;;;;;uCAO/GV,uCAAuCA"}

package/dist/llms.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"llms.d.ts","names":["ClientOptions","OpenAI","OpenAIClient","CallbackManagerForLLMRun","GenerationChunk","LLMResult","BaseLLM","BaseLLMParams","OpenAICallOptions","OpenAICoreRequestOptions","OpenAIInput","CallOptions","Record","Partial","CompletionCreateParams","Omit","Promise","AsyncGenerator","CompletionCreateParamsStreaming","Completion","AsyncIterable","CompletionCreateParamsNonStreaming","Completions"],"sources":["../src/llms.d.ts"],"sourcesContent":["import { type ClientOptions, OpenAI as OpenAIClient } from \"openai\";\nimport { CallbackManagerForLLMRun } from \"@langchain/core/callbacks/manager\";\nimport { GenerationChunk, type LLMResult } from \"@langchain/core/outputs\";\nimport { BaseLLM, type BaseLLMParams } from \"@langchain/core/language_models/llms\";\nimport type { OpenAICallOptions, OpenAICoreRequestOptions, OpenAIInput } from \"./types.js\";\nexport type { OpenAICallOptions, OpenAIInput };\n/**\n * Wrapper around OpenAI large language models.\n *\n * To use you should have the `openai` package installed, with the\n * `OPENAI_API_KEY` environment variable set.\n *\n * To use with Azure, import the `AzureOpenAI` class.\n *\n * @remarks\n * Any parameters that are valid to be passed to {@link\n * https://platform.openai.com/docs/api-reference/completions/create |\n * `openai.createCompletion`} can be passed through {@link modelKwargs}, even\n * if not explicitly available on this class.\n * @example\n * ```typescript\n * const model = new OpenAI({\n *   modelName: \"gpt-4\",\n *   temperature: 0.7,\n *   maxTokens: 1000,\n *   maxRetries: 5,\n * });\n *\n * const res = await model.invoke(\n *   \"Question: What would be a good company name for a company that makes colorful socks?\\nAnswer:\"\n * );\n * console.log({ res });\n * ```\n */\nexport declare class OpenAI<CallOptions extends OpenAICallOptions = OpenAICallOptions> extends BaseLLM<CallOptions> implements Partial<OpenAIInput> {\n    static lc_name(): string;\n    get callKeys(): string[];\n    lc_serializable: boolean;\n    get lc_secrets(): {\n        [key: string]: string;\n    } | undefined;\n    get lc_aliases(): Record<string, string>;\n    temperature?: number;\n    maxTokens?: number;\n    topP?: number;\n    frequencyPenalty?: number;\n    presencePenalty?: number;\n    n: number;\n    bestOf?: number;\n    logitBias?: Record<string, number>;\n    model: string;\n    /** @deprecated Use \"model\" instead */\n    modelName: string;\n    modelKwargs?: OpenAIInput[\"modelKwargs\"];\n    batchSize: number;\n    timeout?: number;\n    stop?: string[];\n    stopSequences?: string[];\n    user?: string;\n    streaming: boolean;\n    openAIApiKey?: string;\n    apiKey?: string;\n    organization?: string;\n    protected client: OpenAIClient;\n    protected clientConfig: ClientOptions;\n    constructor(fields?: Partial<OpenAIInput> & BaseLLMParams & {\n        configuration?: ClientOptions;\n    });\n    /**\n     * Get the parameters used to invoke the model\n     */\n    invocationParams(options?: this[\"ParsedCallOptions\"]): Omit<OpenAIClient.CompletionCreateParams, \"prompt\">;\n    /** @ignore */\n    _identifyingParams(): Omit<OpenAIClient.CompletionCreateParams, \"prompt\"> & {\n        model_name: string;\n    } & ClientOptions;\n    /**\n     * Get the identifying parameters for the model\n     */\n    identifyingParams(): Omit<OpenAIClient.CompletionCreateParams, \"prompt\"> & {\n        model_name: string;\n    } & ClientOptions;\n    /**\n     * Call out to OpenAI's endpoint with k unique prompts\n     *\n     * @param [prompts] - The prompts to pass into the model.\n     * @param [options] - Optional list of stop words to use when generating.\n     * @param [runManager] - Optional callback manager to use when generating.\n     *\n     * @returns The full LLM output.\n     *\n     * @example\n     * ```ts\n     * import { OpenAI } from \"langchain/llms/openai\";\n     * const openai = new OpenAI();\n     * const response = await openai.generate([\"Tell me a joke.\"]);\n     * ```\n     */\n    _generate(prompts: string[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<LLMResult>;\n    // TODO(jacoblee): Refactor with _generate(..., {stream: true}) implementation?\n    _streamResponseChunks(input: string, options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<GenerationChunk>;\n    /**\n     * Calls the OpenAI API with retry logic in case of failures.\n     * @param request The request to send to the OpenAI API.\n     * @param options Optional configuration for the API call.\n     * @returns The response from the OpenAI API.\n     */\n    completionWithRetry(request: OpenAIClient.CompletionCreateParamsStreaming, options?: OpenAICoreRequestOptions): Promise<AsyncIterable<OpenAIClient.Completion>>;\n    completionWithRetry(request: OpenAIClient.CompletionCreateParamsNonStreaming, options?: OpenAICoreRequestOptions): Promise<OpenAIClient.Completions.Completion>;\n    /**\n     * Calls the OpenAI API with retry logic in case of failures.\n     * @param request The request to send to the OpenAI API.\n     * @param options Optional configuration for the API call.\n     * @returns The response from the OpenAI API.\n     */\n    protected _getClientOptions(options: OpenAICoreRequestOptions | undefined): OpenAICoreRequestOptions;\n    _llmType(): string;\n}\n"],"mappings":";;;;;;;;;AAkCA;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkEoII,cAlE/GH,QAkE+GG,CAAAA,oBAlEpFI,iBAkEoFJ,GAlEhEI,iBAkEgEJ,CAAAA,SAlErCE,OAkEqCF,CAlE7BO,WAkE6BP,CAAAA,YAlELS,OAkEKT,CAlEGM,WAkEHN,CAAAA,CAAAA;EAAe,OAA9Ba,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAc,IAOlGf,QAAagB,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAA+B,eAAYT,EAAAA,OAAAA;EAAwB,IAAyBP,UAAaiB,CAAAA,CAAAA,EAAAA;IAA3BC,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EAAAA,MAAAA;EAAa,CAAA,GAArBJ,SAAAA;EAAO,IAC1Fd,UAAamB,CAAAA,CAAAA,EAnExBT,MAmEwBS,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAAkC,WAAYZ,CAAAA,EAAAA,MAAAA;EAAwB,SAAWP,CAAAA,EAAaoB,MAAAA;EAAsB,IAA3CN,CAAAA,EAAAA,MAAAA;EAAO,gBAOrFP,CAAAA,EAAAA,MAAAA;EAAwB,eAAeA,CAAAA,EAAAA,MAAAA;EAAwB,CAAA,EAjFTH,MAAAA;EAAO,MAAyBO,CAAAA,EAAAA,MAAAA;EAAO,SAAA,CAAA,EAetHD,MAfsH,CAAA,MAAA,EAAA,MAAA,CAAA;;;;gBAmBpHF;;;;;;;;;;oBAUIR;0BACMF;uBACHa,QAAQH,eAAeH;oBACxBP;;;;;yDAKmCe,KAAKb,QAAAA,CAAaY;;wBAEnDC,KAAKb,QAAAA,CAAaY;;MAEpCd;;;;uBAIiBe,KAAKb,QAAAA,CAAaY;;MAEnCd;;;;;;;;;;;;;;;;;gFAiB0EG,2BAA2Ba,QAAQX;;wFAE3BF,2BAA2Bc,eAAeb;;;;;;;+BAOnGF,QAAAA,CAAagB,2CAA2CT,2BAA2BO,QAAQI,cAAclB,QAAAA,CAAaiB;+BACtHjB,QAAAA,CAAamB,8CAA8CZ,2BAA2BO,QAAQd,QAAAA,CAAaoB,WAAAA,CAAYH;;;;;;;uCAO/GV,uCAAuCA"}

package/dist/tools/custom.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"custom.d.cts","names":["RunnableFunc","DynamicTool","ToolRunnableConfig","OpenAI","CustomToolFields","Responses","CustomTool","Omit","customTool"],"sources":["../../src/tools/custom.d.ts"],"sourcesContent":["import { RunnableFunc } from \"@langchain/core/runnables\";\nimport { DynamicTool, ToolRunnableConfig } from \"@langchain/core/tools\";\nimport OpenAI from \"openai\";\nexport type CustomToolFields = Omit<OpenAI.Responses.CustomTool, \"type\">;\nexport declare function customTool(func: RunnableFunc<string, string, ToolRunnableConfig>, fields: CustomToolFields): DynamicTool<string>;\n"],"mappings":";;;;;KAGYI,gBAAAA,GAAmBG,KAAKJ,MAAAA,CAAOE,SAAAA,CAAUC;iBAC7BE,UAAAA,OAAiBR,6BAA6BE,6BAA6BE,mBAAmBH"}

package/dist/tools/custom.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"custom.d.ts","names":["RunnableFunc","DynamicTool","ToolRunnableConfig","OpenAI","CustomToolFields","Responses","CustomTool","Omit","customTool"],"sources":["../../src/tools/custom.d.ts"],"sourcesContent":["import { RunnableFunc } from \"@langchain/core/runnables\";\nimport { DynamicTool, ToolRunnableConfig } from \"@langchain/core/tools\";\nimport OpenAI from \"openai\";\nexport type CustomToolFields = Omit<OpenAI.Responses.CustomTool, \"type\">;\nexport declare function customTool(func: RunnableFunc<string, string, ToolRunnableConfig>, fields: CustomToolFields): DynamicTool<string>;\n"],"mappings":";;;;;KAGYI,gBAAAA,GAAmBG,KAAKJ,MAAAA,CAAOE,SAAAA,CAAUC;iBAC7BE,UAAAA,OAAiBR,6BAA6BE,6BAA6BE,mBAAmBH"}

package/dist/tools/dalle.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dalle.d.cts","names":["OpenAI","OpenAIClient","Tool","ToolParams","MessageContentComplex","OpenAIImageModelId","ImageModel","NonNullable","DallEAPIWrapperParams","DallEAPIWrapper","Promise"],"sources":["../../src/tools/dalle.d.ts"],"sourcesContent":["import { OpenAI as OpenAIClient } from \"openai\";\nimport { Tool, ToolParams } from \"@langchain/core/tools\";\nimport { MessageContentComplex } from \"@langchain/core/messages\";\n/**\n * @see https://platform.openai.com/docs/api-reference/images/create\n */\nexport type OpenAIImageModelId = OpenAIClient.ImageModel | (string & NonNullable<unknown>);\n/**\n * An interface for the Dall-E API Wrapper.\n */\nexport interface DallEAPIWrapperParams extends ToolParams {\n    /**\n     * The OpenAI API key\n     * Alias for `apiKey`\n     */\n    openAIApiKey?: string;\n    /**\n     * The OpenAI API key\n     */\n    apiKey?: string;\n    /**\n     * The model to use.\n     * Alias for `model`\n     * @params \"dall-e-2\" | \"dall-e-3\"\n     * @default \"dall-e-3\"\n     * @deprecated Use `model` instead.\n     */\n    modelName?: OpenAIImageModelId;\n    /**\n     * The model to use.\n     * @params \"dall-e-2\" | \"dall-e-3\"\n     * @default \"dall-e-3\"\n     */\n    model?: OpenAIImageModelId;\n    /**\n     * The style of the generated images. Must be one of vivid or natural.\n     * Vivid causes the model to lean towards generating hyper-real and dramatic images.\n     * Natural causes the model to produce more natural, less hyper-real looking images.\n     * @default \"vivid\"\n     */\n    style?: \"natural\" | \"vivid\";\n    /**\n     * The quality of the image that will be generated. ‘hd’ creates images with finer\n     * details and greater consistency across the image.\n     * @default \"standard\"\n     */\n    quality?: \"standard\" | \"hd\";\n    /**\n     * The number of images to generate.\n     * Must be between 1 and 10.\n     * For dall-e-3, only `n: 1` is supported.\n     * @default 1\n     */\n    n?: number;\n    /**\n     * The size of the generated images.\n     * Must be one of 256x256, 512x512, or 1024x1024 for DALL·E-2 models.\n     * Must be one of 1024x1024, 1792x1024, or 1024x1792 for DALL·E-3 models.\n     * @default \"1024x1024\"\n     */\n    size?: \"256x256\" | \"512x512\" | \"1024x1024\" | \"1792x1024\" | \"1024x1792\";\n    /**\n     * The format in which the generated images are returned.\n     * Must be one of \"url\" or \"b64_json\".\n     * @default \"url\"\n     */\n    dallEResponseFormat?: \"url\" | \"b64_json\";\n    /**\n     * @deprecated Use dallEResponseFormat instead for the Dall-E response type.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    responseFormat?: any;\n    /**\n     * A unique identifier representing your end-user, which will help\n     * OpenAI to monitor and detect abuse.\n     */\n    user?: string;\n    /**\n     * The organization to use\n     */\n    organization?: string;\n    /**\n     * The base URL of the OpenAI API.\n     */\n    baseUrl?: string;\n}\n/**\n * A tool for generating images with Open AIs Dall-E 2 or 3 API.\n */\nexport declare class DallEAPIWrapper extends Tool {\n    static lc_name(): string;\n    name: string;\n    description: string;\n    protected client: OpenAIClient;\n    static readonly toolName: string;\n    private model;\n    private style;\n    private quality;\n    private n;\n    private size;\n    private dallEResponseFormat;\n    private user?;\n    constructor(fields?: DallEAPIWrapperParams);\n    /**\n     * Processes the API response if multiple images are generated.\n     * Returns a list of MessageContentImageUrl objects. If the response\n     * format is `url`, then the `image_url` field will contain the URL.\n     * If it is `b64_json`, then the `image_url` field will contain an object\n     * with a `url` field with the base64 encoded image.\n     *\n     * @param {OpenAIClient.Images.ImagesResponse[]} response The API response\n     * @returns {MessageContentImageUrl[]}\n     */\n    private processMultipleGeneratedUrls;\n    /** @ignore */\n    _call(input: string): Promise<string | MessageContentComplex[]>;\n}\n"],"mappings":";;;;;;;;AAMA;AAA8B,KAAlBK,kBAAAA,GAAqBJ,QAAAA,CAAaK,UAAhB,GAAA,CAAA,MAAA,GAAuCC,WAAvC,CAAA,OAAA,CAAA,CAAA;;;AAAkD;AAI/DC,UAAAA,qBAAAA,SAA8BL,UAAT,CAAA;EAAA;;;;EAAmB,YAAA,CAAA,EAAA,MAAA;EA+EpCM;;;EAIa,MASTD,CAAAA,EAAAA,MAAAA;EAAqB;;;AAbG;;;;cA9DjCH;;;;;;UAMJA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwDSI,eAAAA,SAAwBP,IAAAA;;;;oBAIvBD;;;;;;;;;uBASGO;;;;;;;;;;;;;wBAaCE,iBAAiBN"}

package/dist/tools/dalle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dalle.d.ts","names":["OpenAI","OpenAIClient","Tool","ToolParams","MessageContentComplex","OpenAIImageModelId","ImageModel","NonNullable","DallEAPIWrapperParams","DallEAPIWrapper","Promise"],"sources":["../../src/tools/dalle.d.ts"],"sourcesContent":["import { OpenAI as OpenAIClient } from \"openai\";\nimport { Tool, ToolParams } from \"@langchain/core/tools\";\nimport { MessageContentComplex } from \"@langchain/core/messages\";\n/**\n * @see https://platform.openai.com/docs/api-reference/images/create\n */\nexport type OpenAIImageModelId = OpenAIClient.ImageModel | (string & NonNullable<unknown>);\n/**\n * An interface for the Dall-E API Wrapper.\n */\nexport interface DallEAPIWrapperParams extends ToolParams {\n    /**\n     * The OpenAI API key\n     * Alias for `apiKey`\n     */\n    openAIApiKey?: string;\n    /**\n     * The OpenAI API key\n     */\n    apiKey?: string;\n    /**\n     * The model to use.\n     * Alias for `model`\n     * @params \"dall-e-2\" | \"dall-e-3\"\n     * @default \"dall-e-3\"\n     * @deprecated Use `model` instead.\n     */\n    modelName?: OpenAIImageModelId;\n    /**\n     * The model to use.\n     * @params \"dall-e-2\" | \"dall-e-3\"\n     * @default \"dall-e-3\"\n     */\n    model?: OpenAIImageModelId;\n    /**\n     * The style of the generated images. Must be one of vivid or natural.\n     * Vivid causes the model to lean towards generating hyper-real and dramatic images.\n     * Natural causes the model to produce more natural, less hyper-real looking images.\n     * @default \"vivid\"\n     */\n    style?: \"natural\" | \"vivid\";\n    /**\n     * The quality of the image that will be generated. ‘hd’ creates images with finer\n     * details and greater consistency across the image.\n     * @default \"standard\"\n     */\n    quality?: \"standard\" | \"hd\";\n    /**\n     * The number of images to generate.\n     * Must be between 1 and 10.\n     * For dall-e-3, only `n: 1` is supported.\n     * @default 1\n     */\n    n?: number;\n    /**\n     * The size of the generated images.\n     * Must be one of 256x256, 512x512, or 1024x1024 for DALL·E-2 models.\n     * Must be one of 1024x1024, 1792x1024, or 1024x1792 for DALL·E-3 models.\n     * @default \"1024x1024\"\n     */\n    size?: \"256x256\" | \"512x512\" | \"1024x1024\" | \"1792x1024\" | \"1024x1792\";\n    /**\n     * The format in which the generated images are returned.\n     * Must be one of \"url\" or \"b64_json\".\n     * @default \"url\"\n     */\n    dallEResponseFormat?: \"url\" | \"b64_json\";\n    /**\n     * @deprecated Use dallEResponseFormat instead for the Dall-E response type.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    responseFormat?: any;\n    /**\n     * A unique identifier representing your end-user, which will help\n     * OpenAI to monitor and detect abuse.\n     */\n    user?: string;\n    /**\n     * The organization to use\n     */\n    organization?: string;\n    /**\n     * The base URL of the OpenAI API.\n     */\n    baseUrl?: string;\n}\n/**\n * A tool for generating images with Open AIs Dall-E 2 or 3 API.\n */\nexport declare class DallEAPIWrapper extends Tool {\n    static lc_name(): string;\n    name: string;\n    description: string;\n    protected client: OpenAIClient;\n    static readonly toolName: string;\n    private model;\n    private style;\n    private quality;\n    private n;\n    private size;\n    private dallEResponseFormat;\n    private user?;\n    constructor(fields?: DallEAPIWrapperParams);\n    /**\n     * Processes the API response if multiple images are generated.\n     * Returns a list of MessageContentImageUrl objects. If the response\n     * format is `url`, then the `image_url` field will contain the URL.\n     * If it is `b64_json`, then the `image_url` field will contain an object\n     * with a `url` field with the base64 encoded image.\n     *\n     * @param {OpenAIClient.Images.ImagesResponse[]} response The API response\n     * @returns {MessageContentImageUrl[]}\n     */\n    private processMultipleGeneratedUrls;\n    /** @ignore */\n    _call(input: string): Promise<string | MessageContentComplex[]>;\n}\n"],"mappings":";;;;;;;;AAMA;AAA8B,KAAlBK,kBAAAA,GAAqBJ,QAAAA,CAAaK,UAAhB,GAAA,CAAA,MAAA,GAAuCC,WAAvC,CAAA,OAAA,CAAA,CAAA;;;AAAkD;AAI/DC,UAAAA,qBAAAA,SAA8BL,UAAT,CAAA;EAAA;;;;EAAmB,YAAA,CAAA,EAAA,MAAA;EA+EpCM;;;EAIa,MASTD,CAAAA,EAAAA,MAAAA;EAAqB;;;AAbG;;;;cA9DjCH;;;;;;UAMJA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwDSI,eAAAA,SAAwBP,IAAAA;;;;oBAIvBD;;;;;;;;;uBASGO;;;;;;;;;;;;;wBAaCE,iBAAiBN"}

package/dist/types.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.cts","names":["OpenAI","OpenAIClient","ResponseFormatText","ResponseFormatJSONObject","ResponseFormatJSONSchema","ResponseFormatTextPython","ResponseFormatTextGrammar","TiktokenModel","BaseLanguageModelCallOptions","InteropZodObject","OpenAIChatModelId","ChatModel","NonNullable","OpenAIVerbosityParam","OpenAIBaseInput","Record","OpenAICoreRequestOptions","RequestOptions","OpenAICallOptions","OpenAIInput","OpenAIChatInput","Chat","ChatCompletionMessageParam","ChatCompletionModality","Array","ChatCompletionAudioParam","Reasoning","Responses","ResponseCreateParams","AzureOpenAIInput","Promise","AzureOpenAIChatInput","ChatOpenAIResponseFormatJSONSchema","Omit","ChatOpenAIReasoningSummary","ResponseReasoningItem","Summary","ChatOpenAIResponseFormat","ResponseFormatConfiguration"],"sources":["../src/types.d.ts"],"sourcesContent":["import type { OpenAI as OpenAIClient } from \"openai\";\nimport type { ResponseFormatText, ResponseFormatJSONObject, ResponseFormatJSONSchema, ResponseFormatTextPython, ResponseFormatTextGrammar } from \"openai/resources/shared\";\nimport { TiktokenModel } from \"js-tiktoken/lite\";\nimport type { BaseLanguageModelCallOptions } from \"@langchain/core/language_models/base\";\nimport { InteropZodObject } from \"@langchain/core/utils/types\";\n// reexport this type from the included package so we can easily override and extend it if needed in the future\n// also makes it easier for folks to import this type without digging around into the dependent packages\nexport type { TiktokenModel };\n/**\n * @see https://platform.openai.com/docs/models\n */\nexport type OpenAIChatModelId = OpenAIClient.ChatModel | (string & NonNullable<unknown>);\nexport type OpenAIVerbosityParam = \"low\" | \"medium\" | \"high\" | null;\nexport declare interface OpenAIBaseInput {\n    /** Sampling temperature to use */\n    temperature: number;\n    /**\n     * Maximum number of tokens to generate in the completion. -1 returns as many\n     * tokens as possible given the prompt and the model's maximum context size.\n     */\n    maxTokens?: number;\n    /**\n     * Maximum number of tokens to generate in the completion. -1 returns as many\n     * tokens as possible given the prompt and the model's maximum context size.\n     * Alias for `maxTokens` for reasoning models.\n     */\n    maxCompletionTokens?: number;\n    /** Total probability mass of tokens to consider at each step */\n    topP: number;\n    /** Penalizes repeated tokens according to frequency */\n    frequencyPenalty: number;\n    /** Penalizes repeated tokens */\n    presencePenalty: number;\n    /** Number of completions to generate for each prompt */\n    n: number;\n    /** Dictionary used to adjust the probability of specific tokens being generated */\n    logitBias?: Record<string, number>;\n    /** Unique string identifier representing your end-user, which can help OpenAI to monitor and detect abuse. */\n    user?: string;\n    /** Whether to stream the results or not. Enabling disables tokenUsage reporting */\n    streaming: boolean;\n    /**\n     * Whether or not to include token usage data in streamed chunks.\n     * @default true\n     */\n    streamUsage?: boolean;\n    /**\n     * Model name to use\n     * Alias for `model`\n     * @deprecated Use \"model\" instead.\n     */\n    modelName: string;\n    /** Model name to use */\n    model: OpenAIChatModelId;\n    /** Holds any additional parameters that are valid to pass to {@link\n     * https://platform.openai.com/docs/api-reference/completions/create |\n     * `openai.createCompletion`} that are not explicitly specified on this class.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    modelKwargs?: Record<string, any>;\n    /**\n     * List of stop words to use when generating\n     * Alias for `stopSequences`\n     */\n    stop?: string[];\n    /** List of stop words to use when generating */\n    stopSequences?: string[];\n    /**\n     * Timeout to use when making requests to OpenAI.\n     */\n    timeout?: number;\n    /**\n     * API key to use when making requests to OpenAI. Defaults to the value of\n     * `OPENAI_API_KEY` environment variable.\n     * Alias for `apiKey`\n     */\n    openAIApiKey?: string;\n    /**\n     * API key to use when making requests to OpenAI. Defaults to the value of\n     * `OPENAI_API_KEY` environment variable.\n     */\n    apiKey?: string;\n    /**\n     * The verbosity of the model's response.\n     */\n    verbosity?: OpenAIVerbosityParam;\n}\nexport type OpenAICoreRequestOptions = OpenAIClient.RequestOptions;\nexport interface OpenAICallOptions extends BaseLanguageModelCallOptions {\n    /**\n     * Additional options to pass to the underlying axios request.\n     */\n    options?: OpenAICoreRequestOptions;\n}\n/**\n * Input to OpenAI class.\n */\nexport declare interface OpenAIInput extends OpenAIBaseInput {\n    /** Generates `bestOf` completions server side and returns the \"best\" */\n    bestOf?: number;\n    /** Batch size to use when passing multiple documents to generate */\n    batchSize: number;\n}\nexport interface OpenAIChatInput extends OpenAIBaseInput {\n    /**\n     * Whether to return log probabilities of the output tokens or not.\n     * If true, returns the log probabilities of each output token returned in the content of message.\n     */\n    logprobs?: boolean;\n    /**\n     * An integer between 0 and 5 specifying the number of most likely tokens to return at each token position,\n     * each with an associated log probability. logprobs must be set to true if this parameter is used.\n     */\n    topLogprobs?: number;\n    /** ChatGPT messages to pass as a prefix to the prompt */\n    prefixMessages?: OpenAIClient.Chat.ChatCompletionMessageParam[];\n    /**\n     * Whether to include the raw OpenAI response in the output message's \"additional_kwargs\" field.\n     * Currently in experimental beta.\n     */\n    __includeRawResponse?: boolean;\n    /**\n     * Whether the model supports the `strict` argument when passing in tools.\n     * If `undefined` the `strict` argument will not be passed to OpenAI.\n     */\n    supportsStrictToolCalling?: boolean;\n    /**\n     * Output types that you would like the model to generate for this request. Most\n     * models are capable of generating text, which is the default:\n     *\n     * `[\"text\"]`\n     *\n     * The `gpt-4o-audio-preview` model can also be used to\n     * [generate audio](https://platform.openai.com/docs/guides/audio). To request that\n     * this model generate both text and audio responses, you can use:\n     *\n     * `[\"text\", \"audio\"]`\n     */\n    modalities?: Array<OpenAIClient.Chat.ChatCompletionModality>;\n    /**\n     * Parameters for audio output. Required when audio output is requested with\n     * `modalities: [\"audio\"]`.\n     * [Learn more](https://platform.openai.com/docs/guides/audio).\n     */\n    audio?: OpenAIClient.Chat.ChatCompletionAudioParam;\n    /**\n     * Options for reasoning models.\n     *\n     * Note that some options, like reasoning summaries, are only available when using the responses\n     * API. This option is ignored when not using a reasoning model.\n     */\n    reasoning?: OpenAIClient.Reasoning;\n    /**\n     * Should be set to `true` in tenancies with Zero Data Retention\n     * @see https://platform.openai.com/docs/guides/your-data\n     *\n     * @default false\n     */\n    zdrEnabled?: boolean;\n    /**\n     * Service tier to use for this request. Can be \"auto\", \"default\", or \"flex\" or \"priority\".\n     * Specifies the service tier for prioritization and latency optimization.\n     */\n    service_tier?: OpenAIClient.Responses.ResponseCreateParams[\"service_tier\"];\n    /**\n     * Used by OpenAI to cache responses for similar requests to optimize your cache\n     * hit rates. Replaces the `user` field.\n     * [Learn more](https://platform.openai.com/docs/guides/prompt-caching).\n     */\n    promptCacheKey?: string;\n}\nexport interface AzureOpenAIInput {\n    /**\n     * API version to use when making requests to Azure OpenAI.\n     */\n    azureOpenAIApiVersion?: string;\n    /**\n     * API key to use when making requests to Azure OpenAI.\n     */\n    azureOpenAIApiKey?: string;\n    /**\n     * Azure OpenAI API instance name to use when making requests to Azure OpenAI.\n     * this is the name of the instance you created in the Azure portal.\n     * e.g. \"my-openai-instance\"\n     * this will be used in the endpoint URL: https://my-openai-instance.openai.azure.com/openai/deployments/{DeploymentName}/\n     */\n    azureOpenAIApiInstanceName?: string;\n    /**\n     * Azure OpenAI API deployment name to use for completions when making requests to Azure OpenAI.\n     * This is the name of the deployment you created in the Azure portal.\n     * e.g. \"my-openai-deployment\"\n     * this will be used in the endpoint URL: https://{InstanceName}.openai.azure.com/openai/deployments/my-openai-deployment/\n     */\n    azureOpenAIApiDeploymentName?: string;\n    /**\n     * Azure OpenAI API deployment name to use for embedding when making requests to Azure OpenAI.\n     * This is the name of the deployment you created in the Azure portal.\n     * This will fallback to azureOpenAIApiDeploymentName if not provided.\n     * e.g. \"my-openai-deployment\"\n     * this will be used in the endpoint URL: https://{InstanceName}.openai.azure.com/openai/deployments/my-openai-deployment/\n     */\n    azureOpenAIApiEmbeddingsDeploymentName?: string;\n    /**\n     * Azure OpenAI API deployment name to use for completions when making requests to Azure OpenAI.\n     * Completions are only available for gpt-3.5-turbo and text-davinci-003 deployments.\n     * This is the name of the deployment you created in the Azure portal.\n     * This will fallback to azureOpenAIApiDeploymentName if not provided.\n     * e.g. \"my-openai-deployment\"\n     * this will be used in the endpoint URL: https://{InstanceName}.openai.azure.com/openai/deployments/my-openai-deployment/\n     */\n    azureOpenAIApiCompletionsDeploymentName?: string;\n    /**\n     * Custom base url for Azure OpenAI API. This is useful in case you have a deployment in another region.\n     * e.g. setting this value to \"https://westeurope.api.cognitive.microsoft.com/openai/deployments\"\n     * will be result in the endpoint URL: https://westeurope.api.cognitive.microsoft.com/openai/deployments/{DeploymentName}/\n     */\n    azureOpenAIBasePath?: string;\n    /**\n     * Custom endpoint for Azure OpenAI API. This is useful in case you have a deployment in another region.\n     * e.g. setting this value to \"https://westeurope.api.cognitive.microsoft.com/\"\n     * will be result in the endpoint URL: https://westeurope.api.cognitive.microsoft.com/openai/deployments/{DeploymentName}/\n     */\n    azureOpenAIEndpoint?: string;\n    /**\n     * A function that returns an access token for Microsoft Entra (formerly known as Azure Active Directory),\n     * which will be invoked on every request.\n     */\n    azureADTokenProvider?: () => Promise<string>;\n}\nexport interface AzureOpenAIChatInput extends OpenAIChatInput, AzureOpenAIInput {\n    openAIApiKey?: string;\n    openAIApiVersion?: string;\n    openAIBasePath?: string;\n    deploymentName?: string;\n}\ntype ChatOpenAIResponseFormatJSONSchema = Omit<ResponseFormatJSONSchema, \"json_schema\"> & {\n    json_schema: Omit<ResponseFormatJSONSchema[\"json_schema\"], \"schema\"> & {\n        /**\n         * The schema for the response format, described as a JSON Schema object\n         * or a Zod object.\n         */\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        schema: Record<string, any> | InteropZodObject;\n    };\n};\n/**\n * The summary of a model's reasoning step.\n */\nexport type ChatOpenAIReasoningSummary = Omit<OpenAIClient.Responses.ResponseReasoningItem, \"summary\"> & {\n    /**\n     * The summary of the reasoning step. The index field will be populated if the response was\n     * streamed. This allows LangChain to recompose the reasoning summary output correctly when the\n     * AIMessage is used as an input for future generation requests.\n     */\n    summary: Array<OpenAIClient.Responses.ResponseReasoningItem.Summary & {\n        index?: number;\n    }>;\n};\nexport type ChatOpenAIResponseFormat = ResponseFormatText | ResponseFormatJSONObject | ResponseFormatTextGrammar | ResponseFormatTextPython | ChatOpenAIResponseFormatJSONSchema;\nexport type ResponseFormatConfiguration = ResponseFormatText | ResponseFormatJSONObject | ResponseFormatJSONSchema;\n"],"mappings":";;;;;;;;;;;AAW8E,KAAlEU,iBAAAA,GAAoBT,QAAAA,CAAaU,SAAiC,GAAA,CAAA,MAAA,GAAXC,WAAW,CAAA,OAAA,CAAA,CAAA;AAClEC,KAAAA,oBAAAA,GAAoB,KAAA,GAAA,QAAA,GAAA,MAAA,GAAA,IAAA;AACPC,kBAAAA,eAAAA,CAAe;EAAA;EAAA,WAuBxBC,EAAAA,MAAAA;EAAM;;;AAiDc;EAExBC,SAAAA,CAAAA,EAAAA,MAAAA;EACKE;;;;AAAsD;EAS9CC,mBAAW,CAAA,EAAA,MAASL;EAM5BM;EAAe,IAAA,EAAA,MAAA;EAAA;EAYiC,gBAuB7BC,EAAKE,MAAAA;EAAsB;EAAzC,eAMGF,EAAKI,MAAAA;EAAwB;EAOhB,CAAA,EAYnBxB,MAAAA;EAA2C;EA5DN,SAAA,CAAA,EAnExCc,MAmEwC,CAAA,MAAA,EAAA,MAAA,CAAA;EAoEvCc;EA0DAE,IAAAA,CAAAA,EAAAA,MAAAA;EAAoB;EAAA,SAASX,EAAAA,OAAAA;EAAe;AAAkB;AAK9E;;EACsC,WAAQhB,CAAAA,EAAAA,OAAAA;EAAwB;;;;;EAOjB,SAAA,EAAA,MAAA;EAM1C8B;EAA0B,KAAA,EAnM3BxB,iBAmM2B;EAAA;;;;EAMpB;EAIN2B,WAAAA,CAAAA,EAvMMtB,MAuMNsB,CAAAA,MAAwB,EAAA,GAAA,CAAA;EAAA;;;;EAA4E,IAAGhC,CAAAA,EAAAA,MAAAA,EAAAA;EAAwB;EAAqC,aAAA,CAAA,EAAA,MAAA,EAAA;EACpKiC;;;EAAgD,OAAGnC,CAAAA,EAAAA,MAAAA;EAAwB;AAA2B;;;;;;;;;;;;;cA9KlGU;;KAEJG,wBAAAA,GAA2Bf,QAAAA,CAAagB;UACnCC,iBAAAA,SAA0BV;;;;YAI7BQ;;;;;kBAKWG,WAAAA,SAAoBL;;;;;;UAM5BM,eAAAA,SAAwBN;;;;;;;;;;;;mBAYpBb,QAAAA,CAAaoB,IAAAA,CAAKC;;;;;;;;;;;;;;;;;;;;;;;eAuBtBE,MAAMvB,QAAAA,CAAaoB,IAAAA,CAAKE;;;;;;UAM7BtB,QAAAA,CAAaoB,IAAAA,CAAKI;;;;;;;cAOdxB,QAAAA,CAAayB;;;;;;;;;;;;iBAYVzB,QAAAA,CAAa0B,SAAAA,CAAUC;;;;;;;;UAQzBC,gBAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAwDgBC;;UAEhBC,oBAAAA,SAA6BX,iBAAiBS;;;;;;KAM1DG,kCAAAA,GAAqCC,KAAK7B;eAC9B6B,KAAK7B;;;;;;YAMNW,sBAAsBN;;;;;;KAM1ByB,0BAAAA,GAA6BD,KAAKhC,QAAAA,CAAa0B,SAAAA,CAAUQ;;;;;;WAMxDX,MAAMvB,QAAAA,CAAa0B,SAAAA,CAAUQ,qBAAAA,CAAsBC;;;;KAIpDC,wBAAAA,GAA2BnC,qBAAqBC,2BAA2BG,4BAA4BD,2BAA2B2B;KAClIM,2BAAAA,GAA8BpC,qBAAqBC,2BAA2BC"}