@langchain/openai 1.1.2 → 1.1.3

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","OpenAIApiKey","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\";\nimport type { OpenAIApiKey } from \"./types.js\";\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    protected apiKey?: OpenAIApiKey;\n    constructor(fields?: Partial<OpenAIEmbeddingsParams> & {\n        verbose?: boolean;\n        /**\n         * The OpenAI API key to use.\n         * Alias for `apiKey`.\n         */\n        openAIApiKey?: OpenAIApiKey;\n        /** The OpenAI API key to use. */\n        apiKey?: OpenAIApiKey;\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":";;;;;;;;AAMA;AAAkC,KAAtBM,sBAAAA,GAAyBJ,QAAAA,CAAaK,cAAhB,GAAA,CAAA,MAAA,GAA2CC,WAA3C,CAAA,OAAA,CAAA,CAAA;;;AAAsD;AAKxF;AAAuC,UAAtBC,sBAAAA,SAA+BL,gBAAT,CAAA;EAAA;;;AAAyB;AAkDhE;EAAqC,SAAA,EA5CtBE,sBA4CsB;EAAA;EAA+C,KAAqBG,EA1C9FH,sBA0C8FG;EAAsB;;;;EAkBxE,UAA9BG,CAAAA,EAAAA,MAAAA;EAAO;;;EASK,OASQD,CAAAA,EAAAA,MAAAA;EAAO;;;;EAewB,SAAWT,CAAAA,EAAaa,MAAAA;EAAuB;;;AAnDnB;;;;;;;;;;;;;;;;;;;;;;;;cAAnFL,6CAA6CP,WAAWQ,oBAAoBC,QAAQH;;;;;;;;;;;;;;;oBAenFP;0BACMF;qBACLK;uBACEO,QAAQH;;;;;;mBAMVJ;;aAENA;oBACOL;;;;;;;;;mCASaa,QAAQF;;;;;;;4BAOfE,QAAQF;;;;;;;;wCAQIT,QAAAA,CAAaY,wBAAwBD,QAAQX,QAAAA,CAAaa"}

package/dist/embeddings.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"embeddings.d.ts","names":["ClientOptions","OpenAI","OpenAIClient","Embeddings","EmbeddingsParams","OpenAIApiKey","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\";\nimport type { OpenAIApiKey } from \"./types.js\";\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    protected apiKey?: OpenAIApiKey;\n    constructor(fields?: Partial<OpenAIEmbeddingsParams> & {\n        verbose?: boolean;\n        /**\n         * The OpenAI API key to use.\n         * Alias for `apiKey`.\n         */\n        openAIApiKey?: OpenAIApiKey;\n        /** The OpenAI API key to use. */\n        apiKey?: OpenAIApiKey;\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":";;;;;;;;AAMA;AAAkC,KAAtBM,sBAAAA,GAAyBJ,QAAAA,CAAaK,cAAhB,GAAA,CAAA,MAAA,GAA2CC,WAA3C,CAAA,OAAA,CAAA,CAAA;;;AAAsD;AAKxF;AAAuC,UAAtBC,sBAAAA,SAA+BL,gBAAT,CAAA;EAAA;;;AAAyB;AAkDhE;EAAqC,SAAA,EA5CtBE,sBA4CsB;EAAA;EAA+C,KAAqBG,EA1C9FH,sBA0C8FG;EAAsB;;;;EAkBxE,UAA9BG,CAAAA,EAAAA,MAAAA;EAAO;;;EASK,OASQD,CAAAA,EAAAA,MAAAA;EAAO;;;;EAewB,SAAWT,CAAAA,EAAaa,MAAAA;EAAuB;;;AAnDnB;;;;;;;;;;;;;;;;;;;;;;;;cAAnFL,6CAA6CP,WAAWQ,oBAAoBC,QAAQH;;;;;;;;;;;;;;;oBAenFP;0BACMF;qBACLK;uBACEO,QAAQH;;;;;;mBAMVJ;;aAENA;oBACOL;;;;;;;;;mCASaa,QAAQF;;;;;;;4BAOfE,QAAQF;;;;;;;;wCAQIT,QAAAA,CAAaY,wBAAwBD,QAAQX,QAAAA,CAAaa"}

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","OpenAIApiKey","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 { OpenAIApiKey, 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?: OpenAIApiKey;\n    apiKey?: OpenAIApiKey;\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;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgE6GiB,cAhExFhB,QAgEwFgB,CAAAA,oBAhE7DR,iBAgE6DQ,GAhEzCR,iBAgEyCQ,CAAAA,SAhEdX,OAgEcW,CAhENL,WAgEMK,CAAAA,YAhEkBH,OAgElBG,CAhE0BN,WAgE1BM,CAAAA,CAAAA;EAAO,OAE1Bd,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAwB,IAAkBC,QAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAe,eAA9Bc,EAAAA,OAAAA;EAAc,IAOlGhB,UAAaiB,CAAAA,CAAAA,EAAAA;IAA2CT,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EAAAA,MAAAA;EAAwB,CAAA,GAAyBR,SAAakB;EAAU,IAArCC,UAAAA,CAAAA,CAAAA,EAlEtGR,MAkEsGQ,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAAa,WAArBJ,CAAAA,EAAAA,MAAAA;EAAO,SAC1Ff,CAAAA,EAAaoB,MAAAA;EAAkC,IAAYZ,CAAAA,EAAAA,MAAAA;EAAwB,gBAAwBa,CAAAA,EAAAA,MAAYH;EAAU,eAA3CH,CAAAA,EAAAA,MAAAA;EAAO,CAAA,EAOrFP,MAAAA;EAAwB,MAAeA,CAAAA,EAAAA,MAAAA;EAAwB,SAjFTJ,CAAAA,EAe/EO,MAf+EP,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAAO,KAAyBQ,EAAAA,MAAAA;EAAO;;gBAmBpHH;;;;;;;iBAOCH;WACNA;;oBAESN;0BACMF;uBACHc,QAAQH,eAAeJ;oBACxBP;;;;;yDAKmCgB,KAAKd,QAAAA,CAAaa;;wBAEnDC,KAAKd,QAAAA,CAAaa;;MAEpCf;;;;uBAIiBgB,KAAKd,QAAAA,CAAaa;;MAEnCf;;;;;;;;;;;;;;;;;gFAiB0EG,2BAA2Bc,QAAQZ;;wFAE3BF,2BAA2Be,eAAed;;;;;;;+BAOnGF,QAAAA,CAAaiB,2CAA2CT,2BAA2BO,QAAQI,cAAcnB,QAAAA,CAAakB;+BACtHlB,QAAAA,CAAaoB,8CAA8CZ,2BAA2BO,QAAQf,QAAAA,CAAaqB,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","OpenAIApiKey","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 { OpenAIApiKey, 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?: OpenAIApiKey;\n    apiKey?: OpenAIApiKey;\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;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgE6GiB,cAhExFhB,QAgEwFgB,CAAAA,oBAhE7DR,iBAgE6DQ,GAhEzCR,iBAgEyCQ,CAAAA,SAhEdX,OAgEcW,CAhENL,WAgEMK,CAAAA,YAhEkBH,OAgElBG,CAhE0BN,WAgE1BM,CAAAA,CAAAA;EAAO,OAE1Bd,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAwB,IAAkBC,QAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAe,eAA9Bc,EAAAA,OAAAA;EAAc,IAOlGhB,UAAaiB,CAAAA,CAAAA,EAAAA;IAA2CT,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EAAAA,MAAAA;EAAwB,CAAA,GAAyBR,SAAakB;EAAU,IAArCC,UAAAA,CAAAA,CAAAA,EAlEtGR,MAkEsGQ,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAAa,WAArBJ,CAAAA,EAAAA,MAAAA;EAAO,SAC1Ff,CAAAA,EAAaoB,MAAAA;EAAkC,IAAYZ,CAAAA,EAAAA,MAAAA;EAAwB,gBAAwBa,CAAAA,EAAAA,MAAYH;EAAU,eAA3CH,CAAAA,EAAAA,MAAAA;EAAO,CAAA,EAOrFP,MAAAA;EAAwB,MAAeA,CAAAA,EAAAA,MAAAA;EAAwB,SAjFTJ,CAAAA,EAe/EO,MAf+EP,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAAO,KAAyBQ,EAAAA,MAAAA;EAAO;;gBAmBpHH;;;;;;;iBAOCH;WACNA;;oBAESN;0BACMF;uBACHc,QAAQH,eAAeJ;oBACxBP;;;;;yDAKmCgB,KAAKd,QAAAA,CAAaa;;wBAEnDC,KAAKd,QAAAA,CAAaa;;MAEpCf;;;;uBAIiBgB,KAAKd,QAAAA,CAAaa;;MAEnCf;;;;;;;;;;;;;;;;;gFAiB0EG,2BAA2Bc,QAAQZ;;wFAE3BF,2BAA2Be,eAAed;;;;;;;+BAOnGF,QAAAA,CAAaiB,2CAA2CT,2BAA2BO,QAAQI,cAAcnB,QAAAA,CAAakB;+BACtHlB,QAAAA,CAAaoB,8CAA8CZ,2BAA2BO,QAAQf,QAAAA,CAAaqB,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","ClientOptions","ResponseFormatText","ResponseFormatJSONObject","ResponseFormatJSONSchema","ResponseFormatTextPython","ResponseFormatTextGrammar","TiktokenModel","BaseLanguageModelCallOptions","InteropZodObject","OpenAIChatModelId","ChatModel","NonNullable","OpenAIVerbosityParam","OpenAIApiKey","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, ClientOptions } 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 type OpenAIApiKey = ClientOptions[\"apiKey\"];\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?: OpenAIApiKey;\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?: OpenAIApiKey;\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    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,KAAlEW,iBAAAA,GAAoBV,QAAAA,CAAaW,SAAiC,GAAA,CAAA,MAAA,GAAXC,WAAW,CAAA,OAAA,CAAA,CAAA;AAClEC,KAAAA,oBAAAA,GAAoB,KAAA,GAAA,QAAA,GAAA,MAAA,GAAA,IAAA;AACpBC,KAAAA,YAAAA,GAAeb,aAAAA,CAAAA,QAAa,CAAA;AACfc,kBAAAA,eAAAA,CAAe;EAAA;EAAA,WAuBxBC,EAAAA,MAAAA;EAAM;;;;EA6CG,SAITH,CAAAA,EAAAA,MAAAA;EAAoB;AAEpC;AACA;;;EAIsC,mBAJKL,CAAAA,EAAAA,MAAAA;EAA4B;EAS9CY,IAAAA,EAAAA,MAAAA;EAMRC;EAAe,gBAAA,EAAA,MAAA;EAAA;EAYiC,eAuB7BC,EAAKE,MAAAA;EAAsB;EAAzC,CAAA,EAMVxB,MAAAA;EAA0C;EAOhB,SAYnBA,CAAAA,EA/HHgB,MA+HgBY,CAAAA,MAAUC,EAAAA,MAAAA,CAAAA;EAAoB;EA5DN,IAAA,CAAA,EAAA,MAAA;EAoEvCC;EA0DAE,SAAAA,EAAAA,OAAAA;EAAoB;;;AAA0C;EAK1EC,WAAAA,CAAAA,EAAAA,OAAAA;EAAkC;;;;;EAClB,SAMLjB,EAAAA,MAAAA;EAAM;EAAgC,KAAA,EA5L3CN,iBA4L2C;EAM1CyB;;;;EAAiC;EAM0B,WAA1DV,CAAAA,EAlMKT,MAkMLS,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;EAAK;AAIlB;;;EAAyD,IAAGtB,CAAAA,EAAAA,MAAAA,EAAAA;EAAwB;EAA4B,aAAGE,CAAAA,EAAAA,MAAAA,EAAAA;EAAwB;AAAqC;AAChL;EAAuC,OAAA,CAAA,EAAA,MAAA;EAAA;;;AAA2E;;iBAtL/FS;;;;;WAKNA;;;;cAIGD;;KAEJI,wBAAAA,GAA2BjB,QAAAA,CAAakB;UACnCC,iBAAAA,SAA0BX;;;;YAI7BS;;;;;kBAKWG,WAAAA,SAAoBL;;;;;;UAM5BM,eAAAA,SAAwBN;;;;;;;;;;;;mBAYpBf,QAAAA,CAAasB,IAAAA,CAAKC;;;;;;;;;;;;;;;;;;;;;;;eAuBtBE,MAAMzB,QAAAA,CAAasB,IAAAA,CAAKE;;;;;;UAM7BxB,QAAAA,CAAasB,IAAAA,CAAKI;;;;;;;cAOd1B,QAAAA,CAAa2B;;;;;;;;;;;;iBAYV3B,QAAAA,CAAa4B,SAAAA,CAAUC;;;;;;;;UAQzBC,gBAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAwDgBC;;UAEhBC,oBAAAA,SAA6BX,iBAAiBS;;;;;KAK1DG,kCAAAA,GAAqCC,KAAK9B;eAC9B8B,KAAK9B;;;;;;YAMNY,sBAAsBP;;;;;;KAM1B0B,0BAAAA,GAA6BD,KAAKlC,QAAAA,CAAa4B,SAAAA,CAAUQ;;;;;;WAMxDX,MAAMzB,QAAAA,CAAa4B,SAAAA,CAAUQ,qBAAAA,CAAsBC;;;;KAIpDC,wBAAAA,GAA2BpC,qBAAqBC,2BAA2BG,4BAA4BD,2BAA2B4B;KAClIM,2BAAAA,GAA8BrC,qBAAqBC,2BAA2BC"}

package/dist/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","names":["OpenAI","OpenAIClient","ClientOptions","ResponseFormatText","ResponseFormatJSONObject","ResponseFormatJSONSchema","ResponseFormatTextPython","ResponseFormatTextGrammar","TiktokenModel","BaseLanguageModelCallOptions","InteropZodObject","OpenAIChatModelId","ChatModel","NonNullable","OpenAIVerbosityParam","OpenAIApiKey","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, ClientOptions } 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 type OpenAIApiKey = ClientOptions[\"apiKey\"];\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?: OpenAIApiKey;\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?: OpenAIApiKey;\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    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,KAAlEW,iBAAAA,GAAoBV,QAAAA,CAAaW,SAAiC,GAAA,CAAA,MAAA,GAAXC,WAAW,CAAA,OAAA,CAAA,CAAA;AAClEC,KAAAA,oBAAAA,GAAoB,KAAA,GAAA,QAAA,GAAA,MAAA,GAAA,IAAA;AACpBC,KAAAA,YAAAA,GAAeb,aAAAA,CAAAA,QAAa,CAAA;AACfc,kBAAAA,eAAAA,CAAe;EAAA;EAAA,WAuBxBC,EAAAA,MAAAA;EAAM;;;;EA6CG,SAITH,CAAAA,EAAAA,MAAAA;EAAoB;AAEpC;AACA;;;EAIsC,mBAJKL,CAAAA,EAAAA,MAAAA;EAA4B;EAS9CY,IAAAA,EAAAA,MAAAA;EAMRC;EAAe,gBAAA,EAAA,MAAA;EAAA;EAYiC,eAuB7BC,EAAKE,MAAAA;EAAsB;EAAzC,CAAA,EAMVxB,MAAAA;EAA0C;EAOhB,SAYnBA,CAAAA,EA/HHgB,MA+HgBY,CAAAA,MAAUC,EAAAA,MAAAA,CAAAA;EAAoB;EA5DN,IAAA,CAAA,EAAA,MAAA;EAoEvCC;EA0DAE,SAAAA,EAAAA,OAAAA;EAAoB;;;AAA0C;EAK1EC,WAAAA,CAAAA,EAAAA,OAAAA;EAAkC;;;;;EAClB,SAMLjB,EAAAA,MAAAA;EAAM;EAAgC,KAAA,EA5L3CN,iBA4L2C;EAM1CyB;;;;EAAiC;EAM0B,WAA1DV,CAAAA,EAlMKT,MAkMLS,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;EAAK;AAIlB;;;EAAyD,IAAGtB,CAAAA,EAAAA,MAAAA,EAAAA;EAAwB;EAA4B,aAAGE,CAAAA,EAAAA,MAAAA,EAAAA;EAAwB;AAAqC;AAChL;EAAuC,OAAA,CAAA,EAAA,MAAA;EAAA;;;AAA2E;;iBAtL/FS;;;;;WAKNA;;;;cAIGD;;KAEJI,wBAAAA,GAA2BjB,QAAAA,CAAakB;UACnCC,iBAAAA,SAA0BX;;;;YAI7BS;;;;;kBAKWG,WAAAA,SAAoBL;;;;;;UAM5BM,eAAAA,SAAwBN;;;;;;;;;;;;mBAYpBf,QAAAA,CAAasB,IAAAA,CAAKC;;;;;;;;;;;;;;;;;;;;;;;eAuBtBE,MAAMzB,QAAAA,CAAasB,IAAAA,CAAKE;;;;;;UAM7BxB,QAAAA,CAAasB,IAAAA,CAAKI;;;;;;;cAOd1B,QAAAA,CAAa2B;;;;;;;;;;;;iBAYV3B,QAAAA,CAAa4B,SAAAA,CAAUC;;;;;;;;UAQzBC,gBAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAwDgBC;;UAEhBC,oBAAAA,SAA6BX,iBAAiBS;;;;;KAK1DG,kCAAAA,GAAqCC,KAAK9B;eAC9B8B,KAAK9B;;;;;;YAMNY,sBAAsBP;;;;;;KAM1B0B,0BAAAA,GAA6BD,KAAKlC,QAAAA,CAAa4B,SAAAA,CAAUQ;;;;;;WAMxDX,MAAMzB,QAAAA,CAAa4B,SAAAA,CAAUQ,qBAAAA,CAAsBC;;;;KAIpDC,wBAAAA,GAA2BpC,qBAAqBC,2BAA2BG,4BAA4BD,2BAA2B4B;KAClIM,2BAAAA,GAA8BrC,qBAAqBC,2BAA2BC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"azure.d.cts","names":["OpenAIEndpointConfig","Promise","getEndpoint","HeaderValue","HeadersLike","Headers","Record","isHeaders","normalizeHeaders","getFormattedEnv","getHeadersWithUserAgent"],"sources":["../../src/utils/azure.d.ts"],"sourcesContent":["export interface OpenAIEndpointConfig {\n    azureOpenAIApiDeploymentName?: string;\n    azureOpenAIApiInstanceName?: string;\n    azureOpenAIApiKey?: string;\n    azureADTokenProvider?: () => Promise<string>;\n    azureOpenAIBasePath?: string;\n    baseURL?: string | null;\n    azureOpenAIEndpoint?: string;\n}\n/**\n * This function generates an endpoint URL for (Azure) OpenAI\n * based on the configuration parameters provided.\n *\n * @param {OpenAIEndpointConfig} config - The configuration object for the (Azure) endpoint.\n *\n * @property {string} config.azureOpenAIApiDeploymentName - The deployment name of Azure OpenAI.\n * @property {string} config.azureOpenAIApiInstanceName - The instance name of Azure OpenAI, e.g. `example-resource`.\n * @property {string} config.azureOpenAIApiKey - The API Key for Azure OpenAI.\n * @property {string} config.azureOpenAIBasePath - The base path for Azure OpenAI, e.g. `https://example-resource.azure.openai.com/openai/deployments/`.\n * @property {string} config.baseURL - Some other custom base path URL.\n * @property {string} config.azureOpenAIEndpoint - The endpoint for the Azure OpenAI instance, e.g. `https://example-resource.azure.openai.com/`.\n *\n * The function operates as follows:\n * - If both `azureOpenAIBasePath` and `azureOpenAIApiDeploymentName` (plus `azureOpenAIApiKey`) are provided, it returns an URL combining these two parameters (`${azureOpenAIBasePath}/${azureOpenAIApiDeploymentName}`).\n * - If both `azureOpenAIEndpoint` and `azureOpenAIApiDeploymentName` (plus `azureOpenAIApiKey`) are provided, it returns an URL combining these two parameters (`${azureOpenAIEndpoint}/openai/deployments/${azureOpenAIApiDeploymentName}`).\n * - If `azureOpenAIApiKey` is provided, it checks for `azureOpenAIApiInstanceName` and `azureOpenAIApiDeploymentName` and throws an error if any of these is missing. If both are provided, it generates an URL incorporating these parameters.\n * - If none of the above conditions are met, return any custom `baseURL`.\n * - The function returns the generated URL as a string, or undefined if no custom paths are specified.\n *\n * @throws Will throw an error if the necessary parameters for generating the URL are missing.\n *\n * @returns {string | undefined} The generated (Azure) OpenAI endpoint URL.\n */\nexport declare function getEndpoint(config: OpenAIEndpointConfig): string | null | undefined;\ntype HeaderValue = string | undefined | null;\nexport type HeadersLike = Headers | readonly HeaderValue[][] | Record<string, HeaderValue | readonly HeaderValue[]> | undefined | null\n// NullableHeaders\n | {\n    values: Headers;\n    [key: string]: unknown;\n};\nexport declare function isHeaders(headers: unknown): headers is Headers;\n/**\n * Normalizes various header formats into a consistent Record format.\n *\n * This function accepts headers in multiple formats and converts them to a\n * Record<string, HeaderValue | readonly HeaderValue[]> for consistent handling.\n *\n * @param headers - The headers to normalize. Can be:\n *   - A Headers instance\n *   - An array of [key, value] pairs\n *   - A plain object with string keys\n *   - A NullableHeaders-like object with a 'values' property containing Headers\n *   - null or undefined\n * @returns A normalized Record containing the header key-value pairs\n *\n * @example\n * ```ts\n * // With Headers instance\n * const headers1 = new Headers([['content-type', 'application/json']]);\n * const normalized1 = normalizeHeaders(headers1);\n *\n * // With plain object\n * const headers2 = { 'content-type': 'application/json' };\n * const normalized2 = normalizeHeaders(headers2);\n *\n * // With array of pairs\n * const headers3 = [['content-type', 'application/json']];\n * const normalized3 = normalizeHeaders(headers3);\n * ```\n */\nexport declare function normalizeHeaders(headers: HeadersLike): Record<string, HeaderValue | readonly HeaderValue[]>;\nexport declare function getFormattedEnv(): string;\n// Note: ideally version would be imported from package.json, but there's\n// currently no good way to do that for all supported environments (Node, Deno, Browser).\nexport declare function getHeadersWithUserAgent(headers: HeadersLike, isAzure?: boolean, version?: string): Record<string, string>;\nexport {};\n"],"mappings":";UAAiBA,oBAAAA;EAAAA,4BAAoB,CAAA,EAAA,MAIJC;EA6BTC,0BAAoBF,CAAAA,EAAAA,MAAAA;EACvCG,iBAAW,CAAA,EAAA,MAAA;EACJC,oBAAW,CAAA,EAAA,GAAA,GA/BUH,OA+BV,CAAA,MAAA,CAAA;EAAA,mBAAA,CAAA,EAAA,MAAA;EAAA,OAAGI,CAAAA,EAAAA,MAAAA,GAAAA,IAAAA;EAAO,mBAAYF,CAAAA,EAAAA,MAAAA;;;;;AAG1B;AAGnB;AA8BA;;;;;;AAAsE;AACtE;AAGA;;;;AAAkH;;;;;;;iBA1C1FD,WAAAA,SAAoBF;KACvCG,WAAAA;KACOC,WAAAA,GAAcC,mBAAmBF,kBAAkBG,eAAeH,uBAAuBA;;;UAGzFE;;;iBAGYE,SAAAA,+BAAwCF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8BxCG,gBAAAA,UAA0BJ,cAAcE,eAAeH,uBAAuBA;iBAC9EM,eAAAA,CAAAA;;;iBAGAC,uBAAAA,UAAiCN,mDAAmDE"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"azure.d.ts","names":["OpenAIEndpointConfig","Promise","getEndpoint","HeaderValue","HeadersLike","Headers","Record","isHeaders","normalizeHeaders","getFormattedEnv","getHeadersWithUserAgent"],"sources":["../../src/utils/azure.d.ts"],"sourcesContent":["export interface OpenAIEndpointConfig {\n    azureOpenAIApiDeploymentName?: string;\n    azureOpenAIApiInstanceName?: string;\n    azureOpenAIApiKey?: string;\n    azureADTokenProvider?: () => Promise<string>;\n    azureOpenAIBasePath?: string;\n    baseURL?: string | null;\n    azureOpenAIEndpoint?: string;\n}\n/**\n * This function generates an endpoint URL for (Azure) OpenAI\n * based on the configuration parameters provided.\n *\n * @param {OpenAIEndpointConfig} config - The configuration object for the (Azure) endpoint.\n *\n * @property {string} config.azureOpenAIApiDeploymentName - The deployment name of Azure OpenAI.\n * @property {string} config.azureOpenAIApiInstanceName - The instance name of Azure OpenAI, e.g. `example-resource`.\n * @property {string} config.azureOpenAIApiKey - The API Key for Azure OpenAI.\n * @property {string} config.azureOpenAIBasePath - The base path for Azure OpenAI, e.g. `https://example-resource.azure.openai.com/openai/deployments/`.\n * @property {string} config.baseURL - Some other custom base path URL.\n * @property {string} config.azureOpenAIEndpoint - The endpoint for the Azure OpenAI instance, e.g. `https://example-resource.azure.openai.com/`.\n *\n * The function operates as follows:\n * - If both `azureOpenAIBasePath` and `azureOpenAIApiDeploymentName` (plus `azureOpenAIApiKey`) are provided, it returns an URL combining these two parameters (`${azureOpenAIBasePath}/${azureOpenAIApiDeploymentName}`).\n * - If both `azureOpenAIEndpoint` and `azureOpenAIApiDeploymentName` (plus `azureOpenAIApiKey`) are provided, it returns an URL combining these two parameters (`${azureOpenAIEndpoint}/openai/deployments/${azureOpenAIApiDeploymentName}`).\n * - If `azureOpenAIApiKey` is provided, it checks for `azureOpenAIApiInstanceName` and `azureOpenAIApiDeploymentName` and throws an error if any of these is missing. If both are provided, it generates an URL incorporating these parameters.\n * - If none of the above conditions are met, return any custom `baseURL`.\n * - The function returns the generated URL as a string, or undefined if no custom paths are specified.\n *\n * @throws Will throw an error if the necessary parameters for generating the URL are missing.\n *\n * @returns {string | undefined} The generated (Azure) OpenAI endpoint URL.\n */\nexport declare function getEndpoint(config: OpenAIEndpointConfig): string | null | undefined;\ntype HeaderValue = string | undefined | null;\nexport type HeadersLike = Headers | readonly HeaderValue[][] | Record<string, HeaderValue | readonly HeaderValue[]> | undefined | null\n// NullableHeaders\n | {\n    values: Headers;\n    [key: string]: unknown;\n};\nexport declare function isHeaders(headers: unknown): headers is Headers;\n/**\n * Normalizes various header formats into a consistent Record format.\n *\n * This function accepts headers in multiple formats and converts them to a\n * Record<string, HeaderValue | readonly HeaderValue[]> for consistent handling.\n *\n * @param headers - The headers to normalize. Can be:\n *   - A Headers instance\n *   - An array of [key, value] pairs\n *   - A plain object with string keys\n *   - A NullableHeaders-like object with a 'values' property containing Headers\n *   - null or undefined\n * @returns A normalized Record containing the header key-value pairs\n *\n * @example\n * ```ts\n * // With Headers instance\n * const headers1 = new Headers([['content-type', 'application/json']]);\n * const normalized1 = normalizeHeaders(headers1);\n *\n * // With plain object\n * const headers2 = { 'content-type': 'application/json' };\n * const normalized2 = normalizeHeaders(headers2);\n *\n * // With array of pairs\n * const headers3 = [['content-type', 'application/json']];\n * const normalized3 = normalizeHeaders(headers3);\n * ```\n */\nexport declare function normalizeHeaders(headers: HeadersLike): Record<string, HeaderValue | readonly HeaderValue[]>;\nexport declare function getFormattedEnv(): string;\n// Note: ideally version would be imported from package.json, but there's\n// currently no good way to do that for all supported environments (Node, Deno, Browser).\nexport declare function getHeadersWithUserAgent(headers: HeadersLike, isAzure?: boolean, version?: string): Record<string, string>;\nexport {};\n"],"mappings":";UAAiBA,oBAAAA;EAAAA,4BAAoB,CAAA,EAAA,MAIJC;EA6BTC,0BAAoBF,CAAAA,EAAAA,MAAAA;EACvCG,iBAAW,CAAA,EAAA,MAAA;EACJC,oBAAW,CAAA,EAAA,GAAA,GA/BUH,OA+BV,CAAA,MAAA,CAAA;EAAA,mBAAA,CAAA,EAAA,MAAA;EAAA,OAAGI,CAAAA,EAAAA,MAAAA,GAAAA,IAAAA;EAAO,mBAAYF,CAAAA,EAAAA,MAAAA;;;;;AAG1B;AAGnB;AA8BA;;;;;;AAAsE;AACtE;AAGA;;;;AAAkH;;;;;;;iBA1C1FD,WAAAA,SAAoBF;KACvCG,WAAAA;KACOC,WAAAA,GAAcC,mBAAmBF,kBAAkBG,eAAeH,uBAAuBA;;;UAGzFE;;;iBAGYE,SAAAA,+BAAwCF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8BxCG,gBAAAA,UAA0BJ,cAAcE,eAAeH,uBAAuBA;iBAC9EM,eAAAA,CAAAA;;;iBAGAC,uBAAAA,UAAiCN,mDAAmDE"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.cts","names":["wrapOpenAIClientError"],"sources":["../../src/utils/client.d.ts"],"sourcesContent":["export declare function wrapOpenAIClientError(e: unknown): any;\n"],"mappings":";iBAAwBA,qBAAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","names":["wrapOpenAIClientError"],"sources":["../../src/utils/client.d.ts"],"sourcesContent":["export declare function wrapOpenAIClientError(e: unknown): any;\n"],"mappings":";iBAAwBA,qBAAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"misc.d.cts","names":["OpenAI","OpenAIClient","BaseMessage","ChatMessage","iife","T","isReasoningModel","extractGenericMessageCustomRole","ChatCompletionRole","messageToOpenAIRole"],"sources":["../../src/utils/misc.d.ts"],"sourcesContent":["import type { OpenAI as OpenAIClient } from \"openai\";\nimport { BaseMessage, ChatMessage } from \"@langchain/core/messages\";\nexport declare const iife: <T>(fn: () => T) => T;\nexport declare function isReasoningModel(model?: string): boolean;\nexport declare function extractGenericMessageCustomRole(message: ChatMessage): OpenAIClient.ChatCompletionRole;\nexport declare function messageToOpenAIRole(message: BaseMessage): OpenAIClient.ChatCompletionRole;\n"],"mappings":";;;;;AAK2C,iBAAnBS,mBAAAA,CAAmB,OAAA,EAAUP,WAAV,CAAA,EAAwBD,QAAAA,CAAaO,kBAArC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"misc.d.ts","names":["OpenAI","OpenAIClient","BaseMessage","ChatMessage","iife","T","isReasoningModel","extractGenericMessageCustomRole","ChatCompletionRole","messageToOpenAIRole"],"sources":["../../src/utils/misc.d.ts"],"sourcesContent":["import type { OpenAI as OpenAIClient } from \"openai\";\nimport { BaseMessage, ChatMessage } from \"@langchain/core/messages\";\nexport declare const iife: <T>(fn: () => T) => T;\nexport declare function isReasoningModel(model?: string): boolean;\nexport declare function extractGenericMessageCustomRole(message: ChatMessage): OpenAIClient.ChatCompletionRole;\nexport declare function messageToOpenAIRole(message: BaseMessage): OpenAIClient.ChatCompletionRole;\n"],"mappings":";;;;;AAK2C,iBAAnBS,mBAAAA,CAAmB,OAAA,EAAUP,WAAV,CAAA,EAAwBD,QAAAA,CAAaO,kBAArC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"prompts.d.cts","names":["BasePromptValue","OpenAI","convertPromptToOpenAI","Chat","ChatCompletionMessageParam"],"sources":["../../src/utils/prompts.d.ts"],"sourcesContent":["import type { BasePromptValue } from \"@langchain/core/prompt_values\";\nimport type { OpenAI } from \"openai\";\n/**\n * Convert a formatted LangChain prompt (e.g. pulled from the hub) into\n * a format expected by OpenAI's JS SDK.\n *\n * Requires the \"@langchain/openai\" package to be installed in addition\n * to the OpenAI SDK.\n *\n * @example\n * ```ts\n * import { convertPromptToOpenAI } from \"langsmith/utils/hub/openai\";\n * import { pull } from \"langchain/hub\";\n *\n * import OpenAI from 'openai';\n *\n * const prompt = await pull(\"jacob/joke-generator\");\n * const formattedPrompt = await prompt.invoke({\n *   topic: \"cats\",\n * });\n *\n * const { messages } = convertPromptToOpenAI(formattedPrompt);\n *\n * const openAIClient = new OpenAI();\n *\n * const openaiResponse = await openAIClient.chat.completions.create({\n *   model: \"gpt-4o-mini\",\n *   messages,\n * });\n * ```\n * @param formattedPrompt\n * @returns A partial OpenAI payload.\n */\n// TODO: make this a converter\nexport declare function convertPromptToOpenAI(formattedPrompt: BasePromptValue): {\n    messages: OpenAI.Chat.ChatCompletionMessageParam[];\n};\n"],"mappings":";;;;;;;AAkCA;;;;AACoD;;;;;;;;;;;;;;;;;;;;;;;;;;iBAD5BE,qBAAAA,kBAAuCF;YACjDC,QAAAA,CAAOE,IAAAA,CAAKC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"prompts.d.ts","names":["BasePromptValue","OpenAI","convertPromptToOpenAI","Chat","ChatCompletionMessageParam"],"sources":["../../src/utils/prompts.d.ts"],"sourcesContent":["import type { BasePromptValue } from \"@langchain/core/prompt_values\";\nimport type { OpenAI } from \"openai\";\n/**\n * Convert a formatted LangChain prompt (e.g. pulled from the hub) into\n * a format expected by OpenAI's JS SDK.\n *\n * Requires the \"@langchain/openai\" package to be installed in addition\n * to the OpenAI SDK.\n *\n * @example\n * ```ts\n * import { convertPromptToOpenAI } from \"langsmith/utils/hub/openai\";\n * import { pull } from \"langchain/hub\";\n *\n * import OpenAI from 'openai';\n *\n * const prompt = await pull(\"jacob/joke-generator\");\n * const formattedPrompt = await prompt.invoke({\n *   topic: \"cats\",\n * });\n *\n * const { messages } = convertPromptToOpenAI(formattedPrompt);\n *\n * const openAIClient = new OpenAI();\n *\n * const openaiResponse = await openAIClient.chat.completions.create({\n *   model: \"gpt-4o-mini\",\n *   messages,\n * });\n * ```\n * @param formattedPrompt\n * @returns A partial OpenAI payload.\n */\n// TODO: make this a converter\nexport declare function convertPromptToOpenAI(formattedPrompt: BasePromptValue): {\n    messages: OpenAI.Chat.ChatCompletionMessageParam[];\n};\n"],"mappings":";;;;;;;AAkCA;;;;AACoD;;;;;;;;;;;;;;;;;;;;;;;;;;iBAD5BE,qBAAAA,kBAAuCF;YACjDC,QAAAA,CAAOE,IAAAA,CAAKC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"tools.d.cts","names":["OpenAI","OpenAIClient","ToolDefinition","BindToolsInput","DynamicTool","StructuredToolInterface","ToolCall","_convertToOpenAITool","ChatCompletionTool","OpenAIFunction","Chat","ChatCompletionCreateParams","Function","FunctionDef","ObjectProp","Omit","Prop","AnyOfProp","formatFunctionDefinitions","formatToOpenAIAssistantTool","OpenAIToolChoice","ChatCompletionToolChoiceOption","ResponsesToolChoice","Responses","ResponseCreateParams","NonNullable","ChatOpenAIToolType","ResponsesTool","formatToOpenAIToolChoice","isBuiltInTool","isBuiltInToolChoice","CustomToolCall","LangchainCustomTool","CustomTool","isCustomTool","isOpenAICustomTool","ChatCompletionCustomTool","parseCustomToolCall","Record","isCustomToolCall","convertCompletionsCustomTool","convertResponsesCustomTool"],"sources":["../../src/utils/tools.d.ts"],"sourcesContent":["import { OpenAI as OpenAIClient } from \"openai\";\nimport { ToolDefinition } from \"@langchain/core/language_models/base\";\nimport { BindToolsInput } from \"@langchain/core/language_models/chat_models\";\nimport { DynamicTool, StructuredToolInterface } from \"@langchain/core/tools\";\nimport { ToolCall } from \"@langchain/core/messages/tool\";\n/**\n * Formats a tool in either OpenAI format, or LangChain structured tool format\n * into an OpenAI tool format. If the tool is already in OpenAI format, return without\n * any changes. If it is in LangChain structured tool format, convert it to OpenAI tool format\n * using OpenAI's `zodFunction` util, falling back to `convertToOpenAIFunction` if the parameters\n * returned from the `zodFunction` util are not defined.\n *\n * @param {BindToolsInput} tool The tool to convert to an OpenAI tool.\n * @param {Object} [fields] Additional fields to add to the OpenAI tool.\n * @returns {ToolDefinition} The inputted tool in OpenAI tool format.\n */\nexport declare function _convertToOpenAITool(tool: BindToolsInput, fields?: {\n    /**\n     * If `true`, model output is guaranteed to exactly match the JSON Schema\n     * provided in the function definition.\n     */\n    strict?: boolean;\n}): OpenAIClient.ChatCompletionTool;\ntype OpenAIFunction = OpenAIClient.Chat.ChatCompletionCreateParams.Function;\n// Types representing the OpenAI function definitions. While the OpenAI client library\n// does have types for function definitions, the properties are just Record<string, unknown>,\n// which isn't very useful for type checking this formatting code.\nexport interface FunctionDef extends Omit<OpenAIFunction, \"parameters\"> {\n    name: string;\n    description?: string;\n    parameters: ObjectProp;\n}\ninterface ObjectProp {\n    type: \"object\";\n    properties?: {\n        [key: string]: Prop;\n    };\n    required?: string[];\n}\ninterface AnyOfProp {\n    anyOf: Prop[];\n}\ntype Prop = {\n    description?: string;\n} & (AnyOfProp | ObjectProp | {\n    type: \"string\";\n    enum?: string[];\n} | {\n    type: \"number\" | \"integer\";\n    minimum?: number;\n    maximum?: number;\n    enum?: number[];\n} | {\n    type: \"boolean\";\n} | {\n    type: \"null\";\n} | {\n    type: \"array\";\n    items?: Prop;\n});\n// When OpenAI use functions in the prompt, they format them as TypeScript definitions rather than OpenAPI JSON schemas.\n// This function converts the JSON schemas into TypeScript definitions.\nexport declare function formatFunctionDefinitions(functions: FunctionDef[]): string;\nexport declare function formatToOpenAIAssistantTool(tool: StructuredToolInterface): ToolDefinition;\nexport type OpenAIToolChoice = OpenAIClient.ChatCompletionToolChoiceOption | \"any\" | string;\nexport type ResponsesToolChoice = NonNullable<OpenAIClient.Responses.ResponseCreateParams[\"tool_choice\"]>;\nexport type ChatOpenAIToolType = BindToolsInput | OpenAIClient.Chat.ChatCompletionTool | ResponsesTool;\nexport type ResponsesTool = NonNullable<OpenAIClient.Responses.ResponseCreateParams[\"tools\"]>[number];\nexport declare function formatToOpenAIToolChoice(toolChoice?: OpenAIToolChoice): OpenAIClient.ChatCompletionToolChoiceOption | undefined;\nexport declare function isBuiltInTool(tool: ChatOpenAIToolType): tool is ResponsesTool;\nexport declare function isBuiltInToolChoice(tool_choice: OpenAIToolChoice | ResponsesToolChoice | undefined): tool_choice is ResponsesToolChoice;\nexport type CustomToolCall = ToolCall & {\n    call_id: string;\n    isCustomTool: true;\n};\ntype LangchainCustomTool = DynamicTool<string> & {\n    metadata: {\n        customTool: OpenAIClient.Responses.CustomTool;\n    };\n};\nexport declare function isCustomTool(tool: unknown): tool is LangchainCustomTool;\nexport declare function isOpenAICustomTool(tool: ChatOpenAIToolType): tool is OpenAIClient.Chat.ChatCompletionCustomTool;\nexport declare function parseCustomToolCall(\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nrawToolCall: Record<string, any>): CustomToolCall | undefined;\nexport declare function isCustomToolCall(toolCall: ToolCall): toolCall is CustomToolCall;\nexport declare function convertCompletionsCustomTool(tool: OpenAIClient.Chat.ChatCompletionCustomTool): OpenAIClient.Responses.CustomTool;\nexport declare function convertResponsesCustomTool(tool: OpenAIClient.Responses.CustomTool): OpenAIClient.Chat.ChatCompletionCustomTool;\nexport {};\n"],"mappings":";;;;;;KAgEYoB,gBAAAA,GAAmBnB,QAAAA,CAAaoB;KAChCC,mBAAAA,GAAsBG,YAAYxB,QAAAA,CAAasB,SAAAA,CAAUC;KACzDE,kBAAAA,GAAqBvB,iBAAiBF,QAAAA,CAAaS,IAAAA,CAAKF,qBAAqBmB;KAC7EA,aAAAA,GAAgBF,YAAYxB,QAAAA,CAAasB,SAAAA,CAAUC"}