@langchain/openai 1.0.0-alpha.3 → 1.0.0

package/dist/chat_models.js

@@ -1,1963 +0,0 @@
-import { iife, isReasoningModel, messageToOpenAIRole } from "./utils/misc.js";
-import { getEndpoint } from "./utils/azure.js";
-import { wrapOpenAIClientError } from "./utils/client.js";
-import { _convertToOpenAITool, convertCompletionsCustomTool, convertResponsesCustomTool, formatFunctionDefinitions, formatToOpenAIToolChoice, isBuiltInTool, isBuiltInToolChoice, isCustomTool, isCustomToolCall, isOpenAICustomTool, parseCustomToolCall } from "./utils/tools.js";
-import { _convertOpenAIResponsesUsageToLangChainUsage, getStructuredOutputMethod, handleMultiModalOutput, interopZodResponseFormat } from "./utils/output.js";
-import { _convertToResponsesMessageFromV1 } from "./utils/standard.js";
-import { _convertMessagesToOpenAIParams, completionsApiContentBlockConverter } from "./utils/message_inputs.js";
-import { OpenAI as OpenAI$1 } from "openai";
-import { AIMessage, AIMessageChunk, ChatMessage, ChatMessageChunk, FunctionMessageChunk, HumanMessageChunk, SystemMessageChunk, ToolMessageChunk, convertToProviderContentBlock, isAIMessage, isDataContentBlock } from "@langchain/core/messages";
-import { ChatGenerationChunk } from "@langchain/core/outputs";
-import { getEnvironmentVariable } from "@langchain/core/utils/env";
-import { BaseChatModel } from "@langchain/core/language_models/chat_models";
-import { isOpenAITool } from "@langchain/core/language_models/base";
-import { RunnableLambda, RunnablePassthrough, RunnableSequence } from "@langchain/core/runnables";
-import { JsonOutputParser, StructuredOutputParser } from "@langchain/core/output_parsers";
-import { JsonOutputKeyToolsParser, makeInvalidToolCall, parseToolCall } from "@langchain/core/output_parsers/openai_tools";
-import { getSchemaDescription, isInteropZodSchema } from "@langchain/core/utils/types";
-import { toJsonSchema } from "@langchain/core/utils/json_schema";
-
-//#region src/chat_models.ts
-const _FUNCTION_CALL_IDS_MAP_KEY = "__openai_function_call_ids__";
-/** @internal */
-var BaseChatOpenAI = class extends BaseChatModel {
-	temperature;
-	topP;
-	frequencyPenalty;
-	presencePenalty;
-	n;
-	logitBias;
-	model = "gpt-3.5-turbo";
-	modelKwargs;
-	stop;
-	stopSequences;
-	user;
-	timeout;
-	streaming = false;
-	streamUsage = true;
-	maxTokens;
-	logprobs;
-	topLogprobs;
-	apiKey;
-	organization;
-	__includeRawResponse;
-	/** @internal */
-	client;
-	/** @internal */
-	clientConfig;
-	/**
-	* Whether the model supports the `strict` argument when passing in tools.
-	* If `undefined` the `strict` argument will not be passed to OpenAI.
-	*/
-	supportsStrictToolCalling;
-	audio;
-	modalities;
-	reasoning;
-	/**
-	* Must be set to `true` in tenancies with Zero Data Retention. Setting to `true` will disable
-	* output storage in the Responses API, but this DOES NOT enable Zero Data Retention in your
-	* OpenAI organization or project. This must be configured directly with OpenAI.
-	*
-	* See:
-	* https://platform.openai.com/docs/guides/your-data
-	* https://platform.openai.com/docs/api-reference/responses/create#responses-create-store
-	*
-	* @default false
-	*/
-	zdrEnabled;
-	/**
-	* Service tier to use for this request. Can be "auto", "default", or "flex" or "priority".
-	* Specifies the service tier for prioritization and latency optimization.
-	*/
-	service_tier;
-	/**
-	* Used by OpenAI to cache responses for similar requests to optimize your cache
-	* hit rates.
-	* [Learn more](https://platform.openai.com/docs/guides/prompt-caching).
-	*/
-	promptCacheKey;
-	/**
-	* The verbosity of the model's response.
-	*/
-	verbosity;
-	defaultOptions;
-	_llmType() {
-		return "openai";
-	}
-	static lc_name() {
-		return "ChatOpenAI";
-	}
-	get callKeys() {
-		return [
-			...super.callKeys,
-			"options",
-			"function_call",
-			"functions",
-			"tools",
-			"tool_choice",
-			"promptIndex",
-			"response_format",
-			"seed",
-			"reasoning",
-			"service_tier"
-		];
-	}
-	lc_serializable = true;
-	get lc_secrets() {
-		return {
-			apiKey: "OPENAI_API_KEY",
-			organization: "OPENAI_ORGANIZATION"
-		};
-	}
-	get lc_aliases() {
-		return {
-			apiKey: "openai_api_key",
-			modelName: "model"
-		};
-	}
-	get lc_serializable_keys() {
-		return [
-			"configuration",
-			"logprobs",
-			"topLogprobs",
-			"prefixMessages",
-			"supportsStrictToolCalling",
-			"modalities",
-			"audio",
-			"temperature",
-			"maxTokens",
-			"topP",
-			"frequencyPenalty",
-			"presencePenalty",
-			"n",
-			"logitBias",
-			"user",
-			"streaming",
-			"streamUsage",
-			"model",
-			"modelName",
-			"modelKwargs",
-			"stop",
-			"stopSequences",
-			"timeout",
-			"apiKey",
-			"cache",
-			"maxConcurrency",
-			"maxRetries",
-			"verbose",
-			"callbacks",
-			"tags",
-			"metadata",
-			"disableStreaming",
-			"zdrEnabled",
-			"reasoning",
-			"promptCacheKey",
-			"verbosity"
-		];
-	}
-	getLsParams(options) {
-		const params = this.invocationParams(options);
-		return {
-			ls_provider: "openai",
-			ls_model_name: this.model,
-			ls_model_type: "chat",
-			ls_temperature: params.temperature ?? void 0,
-			ls_max_tokens: params.max_tokens ?? void 0,
-			ls_stop: options.stop
-		};
-	}
-	/** @ignore */
-	_identifyingParams() {
-		return {
-			model_name: this.model,
-			...this.invocationParams(),
-			...this.clientConfig
-		};
-	}
-	/**
-	* Get the identifying parameters for the model
-	*/
-	identifyingParams() {
-		return this._identifyingParams();
-	}
-	constructor(fields) {
-		super(fields ?? {});
-		this.apiKey = fields?.apiKey ?? fields?.configuration?.apiKey ?? getEnvironmentVariable("OPENAI_API_KEY");
-		this.organization = fields?.configuration?.organization ?? getEnvironmentVariable("OPENAI_ORGANIZATION");
-		this.model = fields?.model ?? fields?.modelName ?? this.model;
-		this.modelKwargs = fields?.modelKwargs ?? {};
-		this.timeout = fields?.timeout;
-		this.temperature = fields?.temperature ?? this.temperature;
-		this.topP = fields?.topP ?? this.topP;
-		this.frequencyPenalty = fields?.frequencyPenalty ?? this.frequencyPenalty;
-		this.presencePenalty = fields?.presencePenalty ?? this.presencePenalty;
-		this.logprobs = fields?.logprobs;
-		this.topLogprobs = fields?.topLogprobs;
-		this.n = fields?.n ?? this.n;
-		this.logitBias = fields?.logitBias;
-		this.stop = fields?.stopSequences ?? fields?.stop;
-		this.stopSequences = this.stop;
-		this.user = fields?.user;
-		this.__includeRawResponse = fields?.__includeRawResponse;
-		this.audio = fields?.audio;
-		this.modalities = fields?.modalities;
-		this.reasoning = fields?.reasoning;
-		this.maxTokens = fields?.maxCompletionTokens ?? fields?.maxTokens;
-		this.promptCacheKey = fields?.promptCacheKey ?? this.promptCacheKey;
-		this.verbosity = fields?.verbosity ?? this.verbosity;
-		this.disableStreaming = fields?.disableStreaming === true;
-		this.streaming = fields?.streaming === true;
-		if (this.disableStreaming) this.streaming = false;
-		if (fields?.streaming === false) this.disableStreaming = true;
-		this.streamUsage = fields?.streamUsage ?? this.streamUsage;
-		if (this.disableStreaming) this.streamUsage = false;
-		this.clientConfig = {
-			apiKey: this.apiKey,
-			organization: this.organization,
-			dangerouslyAllowBrowser: true,
-			...fields?.configuration
-		};
-		if (fields?.supportsStrictToolCalling !== void 0) this.supportsStrictToolCalling = fields.supportsStrictToolCalling;
-		if (fields?.service_tier !== void 0) this.service_tier = fields.service_tier;
-		this.zdrEnabled = fields?.zdrEnabled ?? false;
-	}
-	/**
-	* Returns backwards compatible reasoning parameters from constructor params and call options
-	* @internal
-	*/
-	_getReasoningParams(options) {
-		if (!isReasoningModel(this.model)) return;
-		let reasoning;
-		if (this.reasoning !== void 0) reasoning = {
-			...reasoning,
-			...this.reasoning
-		};
-		if (options?.reasoning !== void 0) reasoning = {
-			...reasoning,
-			...options.reasoning
-		};
-		return reasoning;
-	}
-	/**
-	* Returns an openai compatible response format from a set of options
-	* @internal
-	*/
-	_getResponseFormat(resFormat) {
-		if (resFormat && resFormat.type === "json_schema" && resFormat.json_schema.schema && isInteropZodSchema(resFormat.json_schema.schema)) return interopZodResponseFormat(resFormat.json_schema.schema, resFormat.json_schema.name, { description: resFormat.json_schema.description });
-		return resFormat;
-	}
-	_combineCallOptions(additionalOptions) {
-		return {
-			...this.defaultOptions,
-			...additionalOptions ?? {}
-		};
-	}
-	/** @internal */
-	_getClientOptions(options) {
-		if (!this.client) {
-			const openAIEndpointConfig = { baseURL: this.clientConfig.baseURL };
-			const endpoint = getEndpoint(openAIEndpointConfig);
-			const params = {
-				...this.clientConfig,
-				baseURL: endpoint,
-				timeout: this.timeout,
-				maxRetries: 0
-			};
-			if (!params.baseURL) delete params.baseURL;
-			this.client = new OpenAI$1(params);
-		}
-		const requestOptions = {
-			...this.clientConfig,
-			...options
-		};
-		return requestOptions;
-	}
-	_convertChatOpenAIToolToCompletionsTool(tool, fields) {
-		if (isCustomTool(tool)) return convertResponsesCustomTool(tool.metadata.customTool);
-		if (isOpenAITool(tool)) {
-			if (fields?.strict !== void 0) return {
-				...tool,
-				function: {
-					...tool.function,
-					strict: fields.strict
-				}
-			};
-			return tool;
-		}
-		return _convertToOpenAITool(tool, fields);
-	}
-	bindTools(tools, kwargs) {
-		let strict;
-		if (kwargs?.strict !== void 0) strict = kwargs.strict;
-		else if (this.supportsStrictToolCalling !== void 0) strict = this.supportsStrictToolCalling;
-		return this.withConfig({
-			tools: tools.map((tool) => isBuiltInTool(tool) ? tool : this._convertChatOpenAIToolToCompletionsTool(tool, { strict })),
-			...kwargs
-		});
-	}
-	async stream(input, options) {
-		return super.stream(input, this._combineCallOptions(options));
-	}
-	async invoke(input, options) {
-		return super.invoke(input, this._combineCallOptions(options));
-	}
-	/** @ignore */
-	_combineLLMOutput(...llmOutputs) {
-		return llmOutputs.reduce((acc, llmOutput) => {
-			if (llmOutput && llmOutput.tokenUsage) {
-				acc.tokenUsage.completionTokens += llmOutput.tokenUsage.completionTokens ?? 0;
-				acc.tokenUsage.promptTokens += llmOutput.tokenUsage.promptTokens ?? 0;
-				acc.tokenUsage.totalTokens += llmOutput.tokenUsage.totalTokens ?? 0;
-			}
-			return acc;
-		}, { tokenUsage: {
-			completionTokens: 0,
-			promptTokens: 0,
-			totalTokens: 0
-		} });
-	}
-	async getNumTokensFromMessages(messages) {
-		let totalCount = 0;
-		let tokensPerMessage = 0;
-		let tokensPerName = 0;
-		if (this.model === "gpt-3.5-turbo-0301") {
-			tokensPerMessage = 4;
-			tokensPerName = -1;
-		} else {
-			tokensPerMessage = 3;
-			tokensPerName = 1;
-		}
-		const countPerMessage = await Promise.all(messages.map(async (message) => {
-			const textCount = await this.getNumTokens(message.content);
-			const roleCount = await this.getNumTokens(messageToOpenAIRole(message));
-			const nameCount = message.name !== void 0 ? tokensPerName + await this.getNumTokens(message.name) : 0;
-			let count = textCount + tokensPerMessage + roleCount + nameCount;
-			const openAIMessage = message;
-			if (openAIMessage._getType() === "function") count -= 2;
-			if (openAIMessage.additional_kwargs?.function_call) count += 3;
-			if (openAIMessage?.additional_kwargs.function_call?.name) count += await this.getNumTokens(openAIMessage.additional_kwargs.function_call?.name);
-			if (openAIMessage.additional_kwargs.function_call?.arguments) try {
-				count += await this.getNumTokens(JSON.stringify(JSON.parse(openAIMessage.additional_kwargs.function_call?.arguments)));
-			} catch (error) {
-				console.error("Error parsing function arguments", error, JSON.stringify(openAIMessage.additional_kwargs.function_call));
-				count += await this.getNumTokens(openAIMessage.additional_kwargs.function_call?.arguments);
-			}
-			totalCount += count;
-			return count;
-		}));
-		totalCount += 3;
-		return {
-			totalCount,
-			countPerMessage
-		};
-	}
-	/** @internal */
-	async _getNumTokensFromGenerations(generations) {
-		const generationUsages = await Promise.all(generations.map(async (generation) => {
-			if (generation.message.additional_kwargs?.function_call) return (await this.getNumTokensFromMessages([generation.message])).countPerMessage[0];
-			else return await this.getNumTokens(generation.message.content);
-		}));
-		return generationUsages.reduce((a, b) => a + b, 0);
-	}
-	/** @internal */
-	async _getEstimatedTokenCountFromPrompt(messages, functions, function_call) {
-		let tokens = (await this.getNumTokensFromMessages(messages)).totalCount;
-		if (functions && function_call !== "auto") {
-			const promptDefinitions = formatFunctionDefinitions(functions);
-			tokens += await this.getNumTokens(promptDefinitions);
-			tokens += 9;
-		}
-		if (functions && messages.find((m) => m._getType() === "system")) tokens -= 4;
-		if (function_call === "none") tokens += 1;
-		else if (typeof function_call === "object") tokens += await this.getNumTokens(function_call.name) + 4;
-		return tokens;
-	}
-	/** @internal */
-	_getStructuredOutputMethod(config) {
-		const ensuredConfig = { ...config };
-		if (!this.model.startsWith("gpt-3") && !this.model.startsWith("gpt-4-") && this.model !== "gpt-4") {
-			if (ensuredConfig?.method === void 0) return "jsonSchema";
-		} else if (ensuredConfig.method === "jsonSchema") console.warn(`[WARNING]: JSON Schema is not supported for model "${this.model}". Falling back to tool calling.`);
-		return ensuredConfig.method;
-	}
-	/**
-	* Add structured output to the model.
-	*
-	* The OpenAI model family supports the following structured output methods:
-	* - `jsonSchema`: Use the `response_format` field in the response to return a JSON schema. Only supported with the `gpt-4o-mini`,
-	*   `gpt-4o-mini-2024-07-18`, and `gpt-4o-2024-08-06` model snapshots and later.
-	* - `functionCalling`: Function calling is useful when you are building an application that bridges the models and functionality
-	*   of your application.
-	* - `jsonMode`: JSON mode is a more basic version of the Structured Outputs feature. While JSON mode ensures that model
-	*   output is valid JSON, Structured Outputs reliably matches the model's output to the schema you specify.
-	*   We recommend you use `functionCalling` or `jsonSchema` if it is supported for your use case.
-	*
-	* The default method is `functionCalling`.
-	*
-	* @see https://platform.openai.com/docs/guides/structured-outputs
-	* @param outputSchema - The schema to use for structured output.
-	* @param config - The structured output method options.
-	* @returns The model with structured output.
-	*/
-	withStructuredOutput(outputSchema, config) {
-		let llm;
-		let outputParser;
-		const { schema, name, includeRaw } = {
-			...config,
-			schema: outputSchema
-		};
-		if (config?.strict !== void 0 && config.method === "jsonMode") throw new Error("Argument `strict` is only supported for `method` = 'function_calling'");
-		const method = getStructuredOutputMethod(this.model, config?.method);
-		if (method === "jsonMode") {
-			if (isInteropZodSchema(schema)) outputParser = StructuredOutputParser.fromZodSchema(schema);
-			else outputParser = new JsonOutputParser();
-			const asJsonSchema = toJsonSchema(schema);
-			llm = this.withConfig({
-				response_format: { type: "json_object" },
-				ls_structured_output_format: {
-					kwargs: { method: "json_mode" },
-					schema: {
-						title: name ?? "extract",
-						...asJsonSchema
-					}
-				}
-			});
-		} else if (method === "jsonSchema") {
-			const openaiJsonSchemaParams = {
-				name: name ?? "extract",
-				description: getSchemaDescription(schema),
-				schema,
-				strict: config?.strict
-			};
-			const asJsonSchema = toJsonSchema(openaiJsonSchemaParams.schema);
-			llm = this.withConfig({
-				response_format: {
-					type: "json_schema",
-					json_schema: openaiJsonSchemaParams
-				},
-				ls_structured_output_format: {
-					kwargs: { method: "json_schema" },
-					schema: {
-						title: openaiJsonSchemaParams.name,
-						description: openaiJsonSchemaParams.description,
-						...asJsonSchema
-					}
-				}
-			});
-			if (isInteropZodSchema(schema)) {
-				const altParser = StructuredOutputParser.fromZodSchema(schema);
-				outputParser = RunnableLambda.from((aiMessage) => {
-					if ("parsed" in aiMessage.additional_kwargs) return aiMessage.additional_kwargs.parsed;
-					return altParser;
-				});
-			} else outputParser = new JsonOutputParser();
-		} else {
-			let functionName = name ?? "extract";
-			if (isInteropZodSchema(schema)) {
-				const asJsonSchema = toJsonSchema(schema);
-				llm = this.withConfig({
-					tools: [{
-						type: "function",
-						function: {
-							name: functionName,
-							description: asJsonSchema.description,
-							parameters: asJsonSchema
-						}
-					}],
-					tool_choice: {
-						type: "function",
-						function: { name: functionName }
-					},
-					ls_structured_output_format: {
-						kwargs: { method: "function_calling" },
-						schema: {
-							title: functionName,
-							...asJsonSchema
-						}
-					},
-					...config?.strict !== void 0 ? { strict: config.strict } : {}
-				});
-				outputParser = new JsonOutputKeyToolsParser({
-					returnSingle: true,
-					keyName: functionName,
-					zodSchema: schema
-				});
-			} else {
-				let openAIFunctionDefinition;
-				if (typeof schema.name === "string" && typeof schema.parameters === "object" && schema.parameters != null) {
-					openAIFunctionDefinition = schema;
-					functionName = schema.name;
-				} else {
-					functionName = schema.title ?? functionName;
-					openAIFunctionDefinition = {
-						name: functionName,
-						description: schema.description ?? "",
-						parameters: schema
-					};
-				}
-				const asJsonSchema = toJsonSchema(schema);
-				llm = this.withConfig({
-					tools: [{
-						type: "function",
-						function: openAIFunctionDefinition
-					}],
-					tool_choice: {
-						type: "function",
-						function: { name: functionName }
-					},
-					ls_structured_output_format: {
-						kwargs: { method: "function_calling" },
-						schema: {
-							title: functionName,
-							...asJsonSchema
-						}
-					},
-					...config?.strict !== void 0 ? { strict: config.strict } : {}
-				});
-				outputParser = new JsonOutputKeyToolsParser({
-					returnSingle: true,
-					keyName: functionName
-				});
-			}
-		}
-		if (!includeRaw) return llm.pipe(outputParser);
-		const parserAssign = RunnablePassthrough.assign({ parsed: (input, config$1) => outputParser.invoke(input.raw, config$1) });
-		const parserNone = RunnablePassthrough.assign({ parsed: () => null });
-		const parsedWithFallback = parserAssign.withFallbacks({ fallbacks: [parserNone] });
-		return RunnableSequence.from([{ raw: llm }, parsedWithFallback]);
-	}
-};
-/**
-* OpenAI Responses API implementation.
-*
-* Will be exported in a later version of @langchain/openai.
-*
-* @internal
-*/
-var ChatOpenAIResponses = class extends BaseChatOpenAI {
-	invocationParams(options) {
-		let strict;
-		if (options?.strict !== void 0) strict = options.strict;
-		else if (this.supportsStrictToolCalling !== void 0) strict = this.supportsStrictToolCalling;
-		const params = {
-			model: this.model,
-			temperature: this.temperature,
-			top_p: this.topP,
-			user: this.user,
-			stream: this.streaming,
-			previous_response_id: options?.previous_response_id,
-			truncation: options?.truncation,
-			include: options?.include,
-			tools: options?.tools?.length ? this._reduceChatOpenAITools(options.tools, {
-				stream: this.streaming,
-				strict
-			}) : void 0,
-			tool_choice: isBuiltInToolChoice(options?.tool_choice) ? options?.tool_choice : (() => {
-				const formatted = formatToOpenAIToolChoice(options?.tool_choice);
-				if (typeof formatted === "object" && "type" in formatted) {
-					if (formatted.type === "function") return {
-						type: "function",
-						name: formatted.function.name
-					};
-					else if (formatted.type === "allowed_tools") return {
-						type: "allowed_tools",
-						mode: formatted.allowed_tools.mode,
-						tools: formatted.allowed_tools.tools
-					};
-					else if (formatted.type === "custom") return {
-						type: "custom",
-						name: formatted.custom.name
-					};
-				}
-				return void 0;
-			})(),
-			text: (() => {
-				if (options?.text) return options.text;
-				const format = this._getResponseFormat(options?.response_format);
-				if (format?.type === "json_schema") {
-					if (format.json_schema.schema != null) return {
-						format: {
-							type: "json_schema",
-							schema: format.json_schema.schema,
-							description: format.json_schema.description,
-							name: format.json_schema.name,
-							strict: format.json_schema.strict
-						},
-						verbosity: options?.verbosity
-					};
-					return void 0;
-				}
-				return {
-					format,
-					verbosity: options?.verbosity
-				};
-			})(),
-			parallel_tool_calls: options?.parallel_tool_calls,
-			max_output_tokens: this.maxTokens === -1 ? void 0 : this.maxTokens,
-			prompt_cache_key: options?.promptCacheKey ?? this.promptCacheKey,
-			...this.zdrEnabled ? { store: false } : {},
-			...this.modelKwargs
-		};
-		const reasoning = this._getReasoningParams(options);
-		if (reasoning !== void 0) params.reasoning = reasoning;
-		return params;
-	}
-	async _generate(messages, options) {
-		const invocationParams = this.invocationParams(options);
-		if (invocationParams.stream) {
-			const stream = this._streamResponseChunks(messages, options);
-			let finalChunk;
-			for await (const chunk of stream) {
-				chunk.message.response_metadata = {
-					...chunk.generationInfo,
-					...chunk.message.response_metadata
-				};
-				finalChunk = finalChunk?.concat(chunk) ?? chunk;
-			}
-			return {
-				generations: finalChunk ? [finalChunk] : [],
-				llmOutput: { estimatedTokenUsage: (finalChunk?.message)?.usage_metadata }
-			};
-		} else {
-			const input = this._convertMessagesToResponsesParams(messages);
-			const data = await this.completionWithRetry({
-				input,
-				...invocationParams,
-				stream: false
-			}, {
-				signal: options?.signal,
-				...options?.options
-			});
-			return {
-				generations: [{
-					text: data.output_text,
-					message: this._convertResponsesMessageToBaseMessage(data)
-				}],
-				llmOutput: {
-					id: data.id,
-					estimatedTokenUsage: data.usage ? {
-						promptTokens: data.usage.input_tokens,
-						completionTokens: data.usage.output_tokens,
-						totalTokens: data.usage.total_tokens
-					} : void 0
-				}
-			};
-		}
-	}
-	async *_streamResponseChunks(messages, options, runManager) {
-		const streamIterable = await this.completionWithRetry({
-			...this.invocationParams(options),
-			input: this._convertMessagesToResponsesParams(messages),
-			stream: true
-		}, options);
-		for await (const data of streamIterable) {
-			const chunk = this._convertResponsesDeltaToBaseMessageChunk(data);
-			if (chunk == null) continue;
-			yield chunk;
-			await runManager?.handleLLMNewToken(chunk.text || "", {
-				prompt: options.promptIndex ?? 0,
-				completion: 0
-			}, void 0, void 0, void 0, { chunk });
-		}
-	}
-	async completionWithRetry(request, requestOptions) {
-		return this.caller.call(async () => {
-			const clientOptions = this._getClientOptions(requestOptions);
-			try {
-				if (request.text?.format?.type === "json_schema" && !request.stream) return await this.client.responses.parse(request, clientOptions);
-				return await this.client.responses.create(request, clientOptions);
-			} catch (e) {
-				const error = wrapOpenAIClientError(e);
-				throw error;
-			}
-		});
-	}
-	/** @internal */
-	_convertResponsesMessageToBaseMessage(response) {
-		if (response.error) {
-			const error = new Error(response.error.message);
-			error.name = response.error.code;
-			throw error;
-		}
-		let messageId;
-		const content = [];
-		const tool_calls = [];
-		const invalid_tool_calls = [];
-		const response_metadata = {
-			model_provider: "openai",
-			model: response.model,
-			created_at: response.created_at,
-			id: response.id,
-			incomplete_details: response.incomplete_details,
-			metadata: response.metadata,
-			object: response.object,
-			status: response.status,
-			user: response.user,
-			service_tier: response.service_tier,
-			model_name: response.model
-		};
-		const additional_kwargs = {};
-		for (const item of response.output) if (item.type === "message") {
-			messageId = item.id;
-			content.push(...item.content.flatMap((part) => {
-				if (part.type === "output_text") {
-					if ("parsed" in part && part.parsed != null) additional_kwargs.parsed = part.parsed;
-					return {
-						type: "text",
-						text: part.text,
-						annotations: part.annotations
-					};
-				}
-				if (part.type === "refusal") {
-					additional_kwargs.refusal = part.refusal;
-					return [];
-				}
-				return part;
-			}));
-		} else if (item.type === "function_call") {
-			const fnAdapter = {
-				function: {
-					name: item.name,
-					arguments: item.arguments
-				},
-				id: item.call_id
-			};
-			try {
-				tool_calls.push(parseToolCall(fnAdapter, { returnId: true }));
-			} catch (e) {
-				let errMessage;
-				if (typeof e === "object" && e != null && "message" in e && typeof e.message === "string") errMessage = e.message;
-				invalid_tool_calls.push(makeInvalidToolCall(fnAdapter, errMessage));
-			}
-			additional_kwargs[_FUNCTION_CALL_IDS_MAP_KEY] ??= {};
-			if (item.id) additional_kwargs[_FUNCTION_CALL_IDS_MAP_KEY][item.call_id] = item.id;
-		} else if (item.type === "reasoning") additional_kwargs.reasoning = item;
-		else if (item.type === "custom_tool_call") {
-			const parsed = parseCustomToolCall(item);
-			if (parsed) tool_calls.push(parsed);
-			else invalid_tool_calls.push(makeInvalidToolCall(item, "Malformed custom tool call"));
-		} else {
-			additional_kwargs.tool_outputs ??= [];
-			additional_kwargs.tool_outputs.push(item);
-		}
-		return new AIMessage({
-			id: messageId,
-			content,
-			tool_calls,
-			invalid_tool_calls,
-			usage_metadata: _convertOpenAIResponsesUsageToLangChainUsage(response.usage),
-			additional_kwargs,
-			response_metadata
-		});
-	}
-	/** @internal */
-	_convertResponsesDeltaToBaseMessageChunk(chunk) {
-		const content = [];
-		let generationInfo = {};
-		let usage_metadata;
-		const tool_call_chunks = [];
-		const response_metadata = { model_provider: "openai" };
-		const additional_kwargs = {};
-		let id;
-		if (chunk.type === "response.output_text.delta") content.push({
-			type: "text",
-			text: chunk.delta,
-			index: chunk.content_index
-		});
-		else if (chunk.type === "response.output_text.annotation.added") content.push({
-			type: "text",
-			text: "",
-			annotations: [chunk.annotation],
-			index: chunk.content_index
-		});
-		else if (chunk.type === "response.output_item.added" && chunk.item.type === "message") id = chunk.item.id;
-		else if (chunk.type === "response.output_item.added" && chunk.item.type === "function_call") {
-			tool_call_chunks.push({
-				type: "tool_call_chunk",
-				name: chunk.item.name,
-				args: chunk.item.arguments,
-				id: chunk.item.call_id,
-				index: chunk.output_index
-			});
-			additional_kwargs[_FUNCTION_CALL_IDS_MAP_KEY] = { [chunk.item.call_id]: chunk.item.id };
-		} else if (chunk.type === "response.output_item.done" && [
-			"web_search_call",
-			"file_search_call",
-			"computer_call",
-			"code_interpreter_call",
-			"mcp_call",
-			"mcp_list_tools",
-			"mcp_approval_request",
-			"image_generation_call",
-			"custom_tool_call"
-		].includes(chunk.item.type)) additional_kwargs.tool_outputs = [chunk.item];
-		else if (chunk.type === "response.created") {
-			response_metadata.id = chunk.response.id;
-			response_metadata.model_name = chunk.response.model;
-			response_metadata.model = chunk.response.model;
-		} else if (chunk.type === "response.completed") {
-			const msg = this._convertResponsesMessageToBaseMessage(chunk.response);
-			usage_metadata = _convertOpenAIResponsesUsageToLangChainUsage(chunk.response.usage);
-			if (chunk.response.text?.format?.type === "json_schema") additional_kwargs.parsed ??= JSON.parse(msg.text);
-			for (const [key, value] of Object.entries(chunk.response)) if (key !== "id") response_metadata[key] = value;
-		} else if (chunk.type === "response.function_call_arguments.delta" || chunk.type === "response.custom_tool_call_input.delta") tool_call_chunks.push({
-			type: "tool_call_chunk",
-			args: chunk.delta,
-			index: chunk.output_index
-		});
-		else if (chunk.type === "response.web_search_call.completed" || chunk.type === "response.file_search_call.completed") generationInfo = { tool_outputs: {
-			id: chunk.item_id,
-			type: chunk.type.replace("response.", "").replace(".completed", ""),
-			status: "completed"
-		} };
-		else if (chunk.type === "response.refusal.done") additional_kwargs.refusal = chunk.refusal;
-		else if (chunk.type === "response.output_item.added" && "item" in chunk && chunk.item.type === "reasoning") {
-			const summary = chunk.item.summary ? chunk.item.summary.map((s, index) => ({
-				...s,
-				index
-			})) : void 0;
-			additional_kwargs.reasoning = {
-				id: chunk.item.id,
-				type: chunk.item.type,
-				...summary ? { summary } : {}
-			};
-		} else if (chunk.type === "response.reasoning_summary_part.added") additional_kwargs.reasoning = {
-			type: "reasoning",
-			summary: [{
-				...chunk.part,
-				index: chunk.summary_index
-			}]
-		};
-		else if (chunk.type === "response.reasoning_summary_text.delta") additional_kwargs.reasoning = {
-			type: "reasoning",
-			summary: [{
-				text: chunk.delta,
-				type: "summary_text",
-				index: chunk.summary_index
-			}]
-		};
-		else if (chunk.type === "response.image_generation_call.partial_image") return null;
-		else return null;
-		return new ChatGenerationChunk({
-			text: content.map((part) => part.text).join(""),
-			message: new AIMessageChunk({
-				id,
-				content,
-				tool_call_chunks,
-				usage_metadata,
-				additional_kwargs,
-				response_metadata
-			}),
-			generationInfo
-		});
-	}
-	/** @internal */
-	_convertMessagesToResponsesParams(messages) {
-		return messages.flatMap((lcMsg) => {
-			const responseMetadata = lcMsg.response_metadata;
-			if (responseMetadata?.output_version === "v1") return _convertToResponsesMessageFromV1(lcMsg);
-			const additional_kwargs = lcMsg.additional_kwargs;
-			let role = messageToOpenAIRole(lcMsg);
-			if (role === "system" && isReasoningModel(this.model)) role = "developer";
-			if (role === "function") throw new Error("Function messages are not supported in Responses API");
-			if (role === "tool") {
-				const toolMessage = lcMsg;
-				if (additional_kwargs?.type === "computer_call_output") {
-					const output = (() => {
-						if (typeof toolMessage.content === "string") return {
-							type: "computer_screenshot",
-							image_url: toolMessage.content
-						};
-						if (Array.isArray(toolMessage.content)) {
-							const oaiScreenshot = toolMessage.content.find((i) => i.type === "computer_screenshot");
-							if (oaiScreenshot) return oaiScreenshot;
-							const lcImage = toolMessage.content.find((i) => i.type === "image_url");
-							if (lcImage) return {
-								type: "computer_screenshot",
-								image_url: typeof lcImage.image_url === "string" ? lcImage.image_url : lcImage.image_url.url
-							};
-						}
-						throw new Error("Invalid computer call output");
-					})();
-					return {
-						type: "computer_call_output",
-						output,
-						call_id: toolMessage.tool_call_id
-					};
-				}
-				if (toolMessage.additional_kwargs?.customTool) return {
-					type: "custom_tool_call_output",
-					call_id: toolMessage.tool_call_id,
-					output: toolMessage.content
-				};
-				return {
-					type: "function_call_output",
-					call_id: toolMessage.tool_call_id,
-					id: toolMessage.id?.startsWith("fc_") ? toolMessage.id : void 0,
-					output: typeof toolMessage.content !== "string" ? JSON.stringify(toolMessage.content) : toolMessage.content
-				};
-			}
-			if (role === "assistant") {
-				if (!this.zdrEnabled && responseMetadata?.output != null && Array.isArray(responseMetadata?.output) && responseMetadata?.output.length > 0 && responseMetadata?.output.every((item) => "type" in item)) return responseMetadata?.output;
-				const input = [];
-				if (additional_kwargs?.reasoning && !this.zdrEnabled) {
-					const reasoningItem = this._convertReasoningSummary(additional_kwargs.reasoning);
-					input.push(reasoningItem);
-				}
-				let { content } = lcMsg;
-				if (additional_kwargs?.refusal) {
-					if (typeof content === "string") content = [{
-						type: "output_text",
-						text: content,
-						annotations: []
-					}];
-					content = [...content, {
-						type: "refusal",
-						refusal: additional_kwargs.refusal
-					}];
-				}
-				if (typeof content === "string" || content.length > 0) input.push({
-					type: "message",
-					role: "assistant",
-					...lcMsg.id && !this.zdrEnabled && lcMsg.id.startsWith("msg_") ? { id: lcMsg.id } : {},
-					content: iife(() => {
-						if (typeof content === "string") return content;
-						return content.flatMap((item) => {
-							if (item.type === "text") return {
-								type: "output_text",
-								text: item.text,
-								annotations: item.annotations ?? []
-							};
-							if (item.type === "output_text" || item.type === "refusal") return item;
-							return [];
-						});
-					})
-				});
-				const functionCallIds = additional_kwargs?.[_FUNCTION_CALL_IDS_MAP_KEY];
-				if (isAIMessage(lcMsg) && !!lcMsg.tool_calls?.length) input.push(...lcMsg.tool_calls.map((toolCall) => {
-					if (isCustomToolCall(toolCall)) return {
-						type: "custom_tool_call",
-						id: toolCall.call_id,
-						call_id: toolCall.id ?? "",
-						input: toolCall.args.input,
-						name: toolCall.name
-					};
-					return {
-						type: "function_call",
-						name: toolCall.name,
-						arguments: JSON.stringify(toolCall.args),
-						call_id: toolCall.id,
-						...this.zdrEnabled ? { id: functionCallIds?.[toolCall.id] } : {}
-					};
-				}));
-				else if (additional_kwargs?.tool_calls) input.push(...additional_kwargs.tool_calls.map((toolCall) => ({
-					type: "function_call",
-					name: toolCall.function.name,
-					call_id: toolCall.id,
-					arguments: toolCall.function.arguments,
-					...this.zdrEnabled ? { id: functionCallIds?.[toolCall.id] } : {}
-				})));
-				const toolOutputs = (responseMetadata?.output)?.length ? responseMetadata?.output : additional_kwargs.tool_outputs;
-				const fallthroughCallTypes = [
-					"computer_call",
-					"mcp_call",
-					"code_interpreter_call",
-					"image_generation_call"
-				];
-				if (toolOutputs != null) {
-					const castToolOutputs = toolOutputs;
-					const fallthroughCalls = castToolOutputs?.filter((item) => fallthroughCallTypes.includes(item.type));
-					if (fallthroughCalls.length > 0) input.push(...fallthroughCalls);
-				}
-				return input;
-			}
-			if (role === "user" || role === "system" || role === "developer") {
-				if (typeof lcMsg.content === "string") return {
-					type: "message",
-					role,
-					content: lcMsg.content
-				};
-				const messages$1 = [];
-				const content = lcMsg.content.flatMap((item) => {
-					if (item.type === "mcp_approval_response") messages$1.push({
-						type: "mcp_approval_response",
-						approval_request_id: item.approval_request_id,
-						approve: item.approve
-					});
-					if (isDataContentBlock(item)) return convertToProviderContentBlock(item, completionsApiContentBlockConverter);
-					if (item.type === "text") return {
-						type: "input_text",
-						text: item.text
-					};
-					if (item.type === "image_url") {
-						const imageUrl = iife(() => {
-							if (typeof item.image_url === "string") return item.image_url;
-							else if (typeof item.image_url === "object" && item.image_url !== null && "url" in item.image_url) return item.image_url.url;
-							return void 0;
-						});
-						const detail = iife(() => {
-							if (typeof item.image_url === "string") return "auto";
-							else if (typeof item.image_url === "object" && item.image_url !== null && "detail" in item.image_url) return item.image_url.detail;
-							return void 0;
-						});
-						return {
-							type: "input_image",
-							image_url: imageUrl,
-							detail
-						};
-					}
-					if (item.type === "input_text" || item.type === "input_image" || item.type === "input_file") return item;
-					return [];
-				});
-				if (content.length > 0) messages$1.push({
-					type: "message",
-					role,
-					content
-				});
-				return messages$1;
-			}
-			console.warn(`Unsupported role found when converting to OpenAI Responses API: ${role}`);
-			return [];
-		});
-	}
-	/** @internal */
-	_convertReasoningSummary(reasoning) {
-		const summary = (reasoning.summary.length > 1 ? reasoning.summary.reduce((acc, curr) => {
-			const last = acc.at(-1);
-			if (last.index === curr.index) last.text += curr.text;
-			else acc.push(curr);
-			return acc;
-		}, [{ ...reasoning.summary[0] }]) : reasoning.summary).map((s) => Object.fromEntries(Object.entries(s).filter(([k]) => k !== "index")));
-		return {
-			...reasoning,
-			summary
-		};
-	}
-	/** @internal */
-	_reduceChatOpenAITools(tools, fields) {
-		const reducedTools = [];
-		for (const tool of tools) if (isBuiltInTool(tool)) {
-			if (tool.type === "image_generation" && fields?.stream) tool.partial_images = 1;
-			reducedTools.push(tool);
-		} else if (isOpenAITool(tool)) reducedTools.push({
-			type: "function",
-			name: tool.function.name,
-			parameters: tool.function.parameters,
-			description: tool.function.description,
-			strict: fields?.strict ?? null
-		});
-		else if (isOpenAICustomTool(tool)) reducedTools.push(convertCompletionsCustomTool(tool));
-		return reducedTools;
-	}
-};
-/**
-* OpenAI Completions API implementation.
-* @internal
-*/
-var ChatOpenAICompletions = class extends BaseChatOpenAI {
-	/** @internal */
-	invocationParams(options, extra) {
-		let strict;
-		if (options?.strict !== void 0) strict = options.strict;
-		else if (this.supportsStrictToolCalling !== void 0) strict = this.supportsStrictToolCalling;
-		let streamOptionsConfig = {};
-		if (options?.stream_options !== void 0) streamOptionsConfig = { stream_options: options.stream_options };
-		else if (this.streamUsage && (this.streaming || extra?.streaming)) streamOptionsConfig = { stream_options: { include_usage: true } };
-		const params = {
-			model: this.model,
-			temperature: this.temperature,
-			top_p: this.topP,
-			frequency_penalty: this.frequencyPenalty,
-			presence_penalty: this.presencePenalty,
-			logprobs: this.logprobs,
-			top_logprobs: this.topLogprobs,
-			n: this.n,
-			logit_bias: this.logitBias,
-			stop: options?.stop ?? this.stopSequences,
-			user: this.user,
-			stream: this.streaming,
-			functions: options?.functions,
-			function_call: options?.function_call,
-			tools: options?.tools?.length ? options.tools.map((tool) => this._convertChatOpenAIToolToCompletionsTool(tool, { strict })) : void 0,
-			tool_choice: formatToOpenAIToolChoice(options?.tool_choice),
-			response_format: this._getResponseFormat(options?.response_format),
-			seed: options?.seed,
-			...streamOptionsConfig,
-			parallel_tool_calls: options?.parallel_tool_calls,
-			...this.audio || options?.audio ? { audio: this.audio || options?.audio } : {},
-			...this.modalities || options?.modalities ? { modalities: this.modalities || options?.modalities } : {},
-			...this.modelKwargs,
-			prompt_cache_key: options?.promptCacheKey ?? this.promptCacheKey,
-			verbosity: options?.verbosity ?? this.verbosity
-		};
-		if (options?.prediction !== void 0) params.prediction = options.prediction;
-		if (this.service_tier !== void 0) params.service_tier = this.service_tier;
-		if (options?.service_tier !== void 0) params.service_tier = options.service_tier;
-		const reasoning = this._getReasoningParams(options);
-		if (reasoning !== void 0 && reasoning.effort !== void 0) params.reasoning_effort = reasoning.effort;
-		if (isReasoningModel(params.model)) params.max_completion_tokens = this.maxTokens === -1 ? void 0 : this.maxTokens;
-		else params.max_tokens = this.maxTokens === -1 ? void 0 : this.maxTokens;
-		return params;
-	}
-	async _generate(messages, options, runManager) {
-		const usageMetadata = {};
-		const params = this.invocationParams(options);
-		const messagesMapped = _convertMessagesToOpenAIParams(messages, this.model);
-		if (params.stream) {
-			const stream = this._streamResponseChunks(messages, options, runManager);
-			const finalChunks = {};
-			for await (const chunk of stream) {
-				chunk.message.response_metadata = {
-					...chunk.generationInfo,
-					...chunk.message.response_metadata
-				};
-				const index = chunk.generationInfo?.completion ?? 0;
-				if (finalChunks[index] === void 0) finalChunks[index] = chunk;
-				else finalChunks[index] = finalChunks[index].concat(chunk);
-			}
-			const generations = Object.entries(finalChunks).sort(([aKey], [bKey]) => parseInt(aKey, 10) - parseInt(bKey, 10)).map(([_, value]) => value);
-			const { functions, function_call } = this.invocationParams(options);
-			const promptTokenUsage = await this._getEstimatedTokenCountFromPrompt(messages, functions, function_call);
-			const completionTokenUsage = await this._getNumTokensFromGenerations(generations);
-			usageMetadata.input_tokens = promptTokenUsage;
-			usageMetadata.output_tokens = completionTokenUsage;
-			usageMetadata.total_tokens = promptTokenUsage + completionTokenUsage;
-			return {
-				generations,
-				llmOutput: { estimatedTokenUsage: {
-					promptTokens: usageMetadata.input_tokens,
-					completionTokens: usageMetadata.output_tokens,
-					totalTokens: usageMetadata.total_tokens
-				} }
-			};
-		} else {
-			const data = await this.completionWithRetry({
-				...params,
-				stream: false,
-				messages: messagesMapped
-			}, {
-				signal: options?.signal,
-				...options?.options
-			});
-			const { completion_tokens: completionTokens, prompt_tokens: promptTokens, total_tokens: totalTokens, prompt_tokens_details: promptTokensDetails, completion_tokens_details: completionTokensDetails } = data?.usage ?? {};
-			if (completionTokens) usageMetadata.output_tokens = (usageMetadata.output_tokens ?? 0) + completionTokens;
-			if (promptTokens) usageMetadata.input_tokens = (usageMetadata.input_tokens ?? 0) + promptTokens;
-			if (totalTokens) usageMetadata.total_tokens = (usageMetadata.total_tokens ?? 0) + totalTokens;
-			if (promptTokensDetails?.audio_tokens !== null || promptTokensDetails?.cached_tokens !== null) usageMetadata.input_token_details = {
-				...promptTokensDetails?.audio_tokens !== null && { audio: promptTokensDetails?.audio_tokens },
-				...promptTokensDetails?.cached_tokens !== null && { cache_read: promptTokensDetails?.cached_tokens }
-			};
-			if (completionTokensDetails?.audio_tokens !== null || completionTokensDetails?.reasoning_tokens !== null) usageMetadata.output_token_details = {
-				...completionTokensDetails?.audio_tokens !== null && { audio: completionTokensDetails?.audio_tokens },
-				...completionTokensDetails?.reasoning_tokens !== null && { reasoning: completionTokensDetails?.reasoning_tokens }
-			};
-			const generations = [];
-			for (const part of data?.choices ?? []) {
-				const text = part.message?.content ?? "";
-				const generation = {
-					text,
-					message: this._convertCompletionsMessageToBaseMessage(part.message ?? { role: "assistant" }, data)
-				};
-				generation.generationInfo = {
-					...part.finish_reason ? { finish_reason: part.finish_reason } : {},
-					...part.logprobs ? { logprobs: part.logprobs } : {}
-				};
-				if (isAIMessage(generation.message)) generation.message.usage_metadata = usageMetadata;
-				generation.message = new AIMessage(Object.fromEntries(Object.entries(generation.message).filter(([key]) => !key.startsWith("lc_"))));
-				generations.push(generation);
-			}
-			return {
-				generations,
-				llmOutput: { tokenUsage: {
-					promptTokens: usageMetadata.input_tokens,
-					completionTokens: usageMetadata.output_tokens,
-					totalTokens: usageMetadata.total_tokens
-				} }
-			};
-		}
-	}
-	async *_streamResponseChunks(messages, options, runManager) {
-		const messagesMapped = _convertMessagesToOpenAIParams(messages, this.model);
-		const params = {
-			...this.invocationParams(options, { streaming: true }),
-			messages: messagesMapped,
-			stream: true
-		};
-		let defaultRole;
-		const streamIterable = await this.completionWithRetry(params, options);
-		let usage;
-		for await (const data of streamIterable) {
-			const choice = data?.choices?.[0];
-			if (data.usage) usage = data.usage;
-			if (!choice) continue;
-			const { delta } = choice;
-			if (!delta) continue;
-			const chunk = this._convertCompletionsDeltaToBaseMessageChunk(delta, data, defaultRole);
-			defaultRole = delta.role ?? defaultRole;
-			const newTokenIndices = {
-				prompt: options.promptIndex ?? 0,
-				completion: choice.index ?? 0
-			};
-			if (typeof chunk.content !== "string") {
-				console.log("[WARNING]: Received non-string content from OpenAI. This is currently not supported.");
-				continue;
-			}
-			const generationInfo = { ...newTokenIndices };
-			if (choice.finish_reason != null) {
-				generationInfo.finish_reason = choice.finish_reason;
-				generationInfo.system_fingerprint = data.system_fingerprint;
-				generationInfo.model_name = data.model;
-				generationInfo.service_tier = data.service_tier;
-			}
-			if (this.logprobs) generationInfo.logprobs = choice.logprobs;
-			const generationChunk = new ChatGenerationChunk({
-				message: chunk,
-				text: chunk.content,
-				generationInfo
-			});
-			yield generationChunk;
-			await runManager?.handleLLMNewToken(generationChunk.text ?? "", newTokenIndices, void 0, void 0, void 0, { chunk: generationChunk });
-		}
-		if (usage) {
-			const inputTokenDetails = {
-				...usage.prompt_tokens_details?.audio_tokens !== null && { audio: usage.prompt_tokens_details?.audio_tokens },
-				...usage.prompt_tokens_details?.cached_tokens !== null && { cache_read: usage.prompt_tokens_details?.cached_tokens }
-			};
-			const outputTokenDetails = {
-				...usage.completion_tokens_details?.audio_tokens !== null && { audio: usage.completion_tokens_details?.audio_tokens },
-				...usage.completion_tokens_details?.reasoning_tokens !== null && { reasoning: usage.completion_tokens_details?.reasoning_tokens }
-			};
-			const generationChunk = new ChatGenerationChunk({
-				message: new AIMessageChunk({
-					content: "",
-					response_metadata: { usage: { ...usage } },
-					usage_metadata: {
-						input_tokens: usage.prompt_tokens,
-						output_tokens: usage.completion_tokens,
-						total_tokens: usage.total_tokens,
-						...Object.keys(inputTokenDetails).length > 0 && { input_token_details: inputTokenDetails },
-						...Object.keys(outputTokenDetails).length > 0 && { output_token_details: outputTokenDetails }
-					}
-				}),
-				text: ""
-			});
-			yield generationChunk;
-		}
-		if (options.signal?.aborted) throw new Error("AbortError");
-	}
-	async completionWithRetry(request, requestOptions) {
-		const clientOptions = this._getClientOptions(requestOptions);
-		const isParseableFormat = request.response_format && request.response_format.type === "json_schema";
-		return this.caller.call(async () => {
-			try {
-				if (isParseableFormat && !request.stream) return await this.client.chat.completions.parse(request, clientOptions);
-				else return await this.client.chat.completions.create(request, clientOptions);
-			} catch (e) {
-				const error = wrapOpenAIClientError(e);
-				throw error;
-			}
-		});
-	}
-	/** @internal */
-	_convertCompletionsMessageToBaseMessage(message, rawResponse) {
-		const rawToolCalls = message.tool_calls;
-		switch (message.role) {
-			case "assistant": {
-				const toolCalls = [];
-				const invalidToolCalls = [];
-				for (const rawToolCall of rawToolCalls ?? []) try {
-					toolCalls.push(parseToolCall(rawToolCall, { returnId: true }));
-				} catch (e) {
-					invalidToolCalls.push(makeInvalidToolCall(rawToolCall, e.message));
-				}
-				const additional_kwargs = {
-					function_call: message.function_call,
-					tool_calls: rawToolCalls
-				};
-				if (this.__includeRawResponse !== void 0) additional_kwargs.__raw_response = rawResponse;
-				const response_metadata = {
-					model_provider: "openai",
-					model_name: rawResponse.model,
-					...rawResponse.system_fingerprint ? {
-						usage: { ...rawResponse.usage },
-						system_fingerprint: rawResponse.system_fingerprint
-					} : {}
-				};
-				if (message.audio) additional_kwargs.audio = message.audio;
-				const content = handleMultiModalOutput(message.content || "", rawResponse.choices?.[0]?.message);
-				return new AIMessage({
-					content,
-					tool_calls: toolCalls,
-					invalid_tool_calls: invalidToolCalls,
-					additional_kwargs,
-					response_metadata,
-					id: rawResponse.id
-				});
-			}
-			default: return new ChatMessage(message.content || "", message.role ?? "unknown");
-		}
-	}
-	/** @internal */
-	_convertCompletionsDeltaToBaseMessageChunk(delta, rawResponse, defaultRole) {
-		const role = delta.role ?? defaultRole;
-		const content = delta.content ?? "";
-		let additional_kwargs;
-		if (delta.function_call) additional_kwargs = { function_call: delta.function_call };
-		else if (delta.tool_calls) additional_kwargs = { tool_calls: delta.tool_calls };
-		else additional_kwargs = {};
-		if (this.__includeRawResponse) additional_kwargs.__raw_response = rawResponse;
-		if (delta.audio) additional_kwargs.audio = {
-			...delta.audio,
-			index: rawResponse.choices[0].index
-		};
-		const response_metadata = {
-			model_provider: "openai",
-			usage: { ...rawResponse.usage }
-		};
-		if (role === "user") return new HumanMessageChunk({
-			content,
-			response_metadata
-		});
-		else if (role === "assistant") {
-			const toolCallChunks = [];
-			if (Array.isArray(delta.tool_calls)) for (const rawToolCall of delta.tool_calls) toolCallChunks.push({
-				name: rawToolCall.function?.name,
-				args: rawToolCall.function?.arguments,
-				id: rawToolCall.id,
-				index: rawToolCall.index,
-				type: "tool_call_chunk"
-			});
-			return new AIMessageChunk({
-				content,
-				tool_call_chunks: toolCallChunks,
-				additional_kwargs,
-				id: rawResponse.id,
-				response_metadata
-			});
-		} else if (role === "system") return new SystemMessageChunk({
-			content,
-			response_metadata
-		});
-		else if (role === "developer") return new SystemMessageChunk({
-			content,
-			response_metadata,
-			additional_kwargs: { __openai_role__: "developer" }
-		});
-		else if (role === "function") return new FunctionMessageChunk({
-			content,
-			additional_kwargs,
-			name: delta.name,
-			response_metadata
-		});
-		else if (role === "tool") return new ToolMessageChunk({
-			content,
-			additional_kwargs,
-			tool_call_id: delta.tool_call_id,
-			response_metadata
-		});
-		else return new ChatMessageChunk({
-			content,
-			role,
-			response_metadata
-		});
-	}
-};
-/**
-* OpenAI chat model integration.
-*
-* To use with Azure, import the `AzureChatOpenAI` class.
-*
-* Setup:
-* Install `@langchain/openai` and set an environment variable named `OPENAI_API_KEY`.
-*
-* ```bash
-* npm install @langchain/openai
-* export OPENAI_API_KEY="your-api-key"
-* ```
-*
-* ## [Constructor args](https://api.js.langchain.com/classes/langchain_openai.ChatOpenAI.html#constructor)
-*
-* ## [Runtime args](https://api.js.langchain.com/interfaces/langchain_openai.ChatOpenAICallOptions.html)
-*
-* Runtime args can be passed as the second argument to any of the base runnable methods `.invoke`. `.stream`, `.batch`, etc.
-* They can also be passed via `.withConfig`, or the second arg in `.bindTools`, like shown in the examples below:
-*
-* ```typescript
-* // When calling `.withConfig`, call options should be passed via the first argument
-* const llmWithArgsBound = llm.withConfig({
-*   stop: ["\n"],
-*   tools: [...],
-* });
-*
-* // When calling `.bindTools`, call options should be passed via the second argument
-* const llmWithTools = llm.bindTools(
-*   [...],
-*   {
-*     tool_choice: "auto",
-*   }
-* );
-* ```
-*
-* ## Examples
-*
-* <details open>
-* <summary><strong>Instantiate</strong></summary>
-*
-* ```typescript
-* import { ChatOpenAI } from '@langchain/openai';
-*
-* const llm = new ChatOpenAI({
-*   model: "gpt-4o-mini",
-*   temperature: 0,
-*   maxTokens: undefined,
-*   timeout: undefined,
-*   maxRetries: 2,
-*   // apiKey: "...",
-*   // configuration: {
-*   //   baseURL: "...",
-*   // }
-*   // organization: "...",
-*   // other params...
-* });
-* ```
-* </details>
-*
-* <br />
-*
-* <details>
-* <summary><strong>Invoking</strong></summary>
-*
-* ```typescript
-* const input = `Translate "I love programming" into French.`;
-*
-* // Models also accept a list of chat messages or a formatted prompt
-* const result = await llm.invoke(input);
-* console.log(result);
-* ```
-*
-* ```txt
-* AIMessage {
-*   "id": "chatcmpl-9u4Mpu44CbPjwYFkTbeoZgvzB00Tz",
-*   "content": "J'adore la programmation.",
-*   "response_metadata": {
-*     "tokenUsage": {
-*       "completionTokens": 5,
-*       "promptTokens": 28,
-*       "totalTokens": 33
-*     },
-*     "finish_reason": "stop",
-*     "system_fingerprint": "fp_3aa7262c27"
-*   },
-*   "usage_metadata": {
-*     "input_tokens": 28,
-*     "output_tokens": 5,
-*     "total_tokens": 33
-*   }
-* }
-* ```
-* </details>
-*
-* <br />
-*
-* <details>
-* <summary><strong>Streaming Chunks</strong></summary>
-*
-* ```typescript
-* for await (const chunk of await llm.stream(input)) {
-*   console.log(chunk);
-* }
-* ```
-*
-* ```txt
-* AIMessageChunk {
-*   "id": "chatcmpl-9u4NWB7yUeHCKdLr6jP3HpaOYHTqs",
-*   "content": ""
-* }
-* AIMessageChunk {
-*   "content": "J"
-* }
-* AIMessageChunk {
-*   "content": "'adore"
-* }
-* AIMessageChunk {
-*   "content": " la"
-* }
-* AIMessageChunk {
-*   "content": " programmation",,
-* }
-* AIMessageChunk {
-*   "content": ".",,
-* }
-* AIMessageChunk {
-*   "content": "",
-*   "response_metadata": {
-*     "finish_reason": "stop",
-*     "system_fingerprint": "fp_c9aa9c0491"
-*   },
-* }
-* AIMessageChunk {
-*   "content": "",
-*   "usage_metadata": {
-*     "input_tokens": 28,
-*     "output_tokens": 5,
-*     "total_tokens": 33
-*   }
-* }
-* ```
-* </details>
-*
-* <br />
-*
-* <details>
-* <summary><strong>Aggregate Streamed Chunks</strong></summary>
-*
-* ```typescript
-* import { AIMessageChunk } from '@langchain/core/messages';
-* import { concat } from '@langchain/core/utils/stream';
-*
-* const stream = await llm.stream(input);
-* let full: AIMessageChunk | undefined;
-* for await (const chunk of stream) {
-*   full = !full ? chunk : concat(full, chunk);
-* }
-* console.log(full);
-* ```
-*
-* ```txt
-* AIMessageChunk {
-*   "id": "chatcmpl-9u4PnX6Fy7OmK46DASy0bH6cxn5Xu",
-*   "content": "J'adore la programmation.",
-*   "response_metadata": {
-*     "prompt": 0,
-*     "completion": 0,
-*     "finish_reason": "stop",
-*   },
-*   "usage_metadata": {
-*     "input_tokens": 28,
-*     "output_tokens": 5,
-*     "total_tokens": 33
-*   }
-* }
-* ```
-* </details>
-*
-* <br />
-*
-* <details>
-* <summary><strong>Bind tools</strong></summary>
-*
-* ```typescript
-* import { z } from 'zod';
-*
-* const GetWeather = {
-*   name: "GetWeather",
-*   description: "Get the current weather in a given location",
-*   schema: z.object({
-*     location: z.string().describe("The city and state, e.g. San Francisco, CA")
-*   }),
-* }
-*
-* const GetPopulation = {
-*   name: "GetPopulation",
-*   description: "Get the current population in a given location",
-*   schema: z.object({
-*     location: z.string().describe("The city and state, e.g. San Francisco, CA")
-*   }),
-* }
-*
-* const llmWithTools = llm.bindTools(
-*   [GetWeather, GetPopulation],
-*   {
-*     // strict: true  // enforce tool args schema is respected
-*   }
-* );
-* const aiMsg = await llmWithTools.invoke(
-*   "Which city is hotter today and which is bigger: LA or NY?"
-* );
-* console.log(aiMsg.tool_calls);
-* ```
-*
-* ```txt
-* [
-*   {
-*     name: 'GetWeather',
-*     args: { location: 'Los Angeles, CA' },
-*     type: 'tool_call',
-*     id: 'call_uPU4FiFzoKAtMxfmPnfQL6UK'
-*   },
-*   {
-*     name: 'GetWeather',
-*     args: { location: 'New York, NY' },
-*     type: 'tool_call',
-*     id: 'call_UNkEwuQsHrGYqgDQuH9nPAtX'
-*   },
-*   {
-*     name: 'GetPopulation',
-*     args: { location: 'Los Angeles, CA' },
-*     type: 'tool_call',
-*     id: 'call_kL3OXxaq9OjIKqRTpvjaCH14'
-*   },
-*   {
-*     name: 'GetPopulation',
-*     args: { location: 'New York, NY' },
-*     type: 'tool_call',
-*     id: 'call_s9KQB1UWj45LLGaEnjz0179q'
-*   }
-* ]
-* ```
-* </details>
-*
-* <br />
-*
-* <details>
-* <summary><strong>Structured Output</strong></summary>
-*
-* ```typescript
-* import { z } from 'zod';
-*
-* const Joke = z.object({
-*   setup: z.string().describe("The setup of the joke"),
-*   punchline: z.string().describe("The punchline to the joke"),
-*   rating: z.number().nullable().describe("How funny the joke is, from 1 to 10")
-* }).describe('Joke to tell user.');
-*
-* const structuredLlm = llm.withStructuredOutput(Joke, {
-*   name: "Joke",
-*   strict: true, // Optionally enable OpenAI structured outputs
-* });
-* const jokeResult = await structuredLlm.invoke("Tell me a joke about cats");
-* console.log(jokeResult);
-* ```
-*
-* ```txt
-* {
-*   setup: 'Why was the cat sitting on the computer?',
-*   punchline: 'Because it wanted to keep an eye on the mouse!',
-*   rating: 7
-* }
-* ```
-* </details>
-*
-* <br />
-*
-* <details>
-* <summary><strong>JSON Object Response Format</strong></summary>
-*
-* ```typescript
-* const jsonLlm = llm.withConfig({ response_format: { type: "json_object" } });
-* const jsonLlmAiMsg = await jsonLlm.invoke(
-*   "Return a JSON object with key 'randomInts' and a value of 10 random ints in [0-99]"
-* );
-* console.log(jsonLlmAiMsg.content);
-* ```
-*
-* ```txt
-* {
-*   "randomInts": [23, 87, 45, 12, 78, 34, 56, 90, 11, 67]
-* }
-* ```
-* </details>
-*
-* <br />
-*
-* <details>
-* <summary><strong>Multimodal</strong></summary>
-*
-* ```typescript
-* import { HumanMessage } from '@langchain/core/messages';
-*
-* const imageUrl = "https://example.com/image.jpg";
-* const imageData = await fetch(imageUrl).then(res => res.arrayBuffer());
-* const base64Image = Buffer.from(imageData).toString('base64');
-*
-* const message = new HumanMessage({
-*   content: [
-*     { type: "text", text: "describe the weather in this image" },
-*     {
-*       type: "image_url",
-*       image_url: { url: `data:image/jpeg;base64,${base64Image}` },
-*     },
-*   ]
-* });
-*
-* const imageDescriptionAiMsg = await llm.invoke([message]);
-* console.log(imageDescriptionAiMsg.content);
-* ```
-*
-* ```txt
-* The weather in the image appears to be clear and sunny. The sky is mostly blue with a few scattered white clouds, indicating fair weather. The bright sunlight is casting shadows on the green, grassy hill, suggesting it is a pleasant day with good visibility. There are no signs of rain or stormy conditions.
-* ```
-* </details>
-*
-* <br />
-*
-* <details>
-* <summary><strong>Usage Metadata</strong></summary>
-*
-* ```typescript
-* const aiMsgForMetadata = await llm.invoke(input);
-* console.log(aiMsgForMetadata.usage_metadata);
-* ```
-*
-* ```txt
-* { input_tokens: 28, output_tokens: 5, total_tokens: 33 }
-* ```
-* </details>
-*
-* <br />
-*
-* <details>
-* <summary><strong>Logprobs</strong></summary>
-*
-* ```typescript
-* const logprobsLlm = new ChatOpenAI({ model: "gpt-4o-mini", logprobs: true });
-* const aiMsgForLogprobs = await logprobsLlm.invoke(input);
-* console.log(aiMsgForLogprobs.response_metadata.logprobs);
-* ```
-*
-* ```txt
-* {
-*   content: [
-*     {
-*       token: 'J',
-*       logprob: -0.000050616763,
-*       bytes: [Array],
-*       top_logprobs: []
-*     },
-*     {
-*       token: "'",
-*       logprob: -0.01868736,
-*       bytes: [Array],
-*       top_logprobs: []
-*     },
-*     {
-*       token: 'ad',
-*       logprob: -0.0000030545007,
-*       bytes: [Array],
-*       top_logprobs: []
-*     },
-*     { token: 'ore', logprob: 0, bytes: [Array], top_logprobs: [] },
-*     {
-*       token: ' la',
-*       logprob: -0.515404,
-*       bytes: [Array],
-*       top_logprobs: []
-*     },
-*     {
-*       token: ' programm',
-*       logprob: -0.0000118755715,
-*       bytes: [Array],
-*       top_logprobs: []
-*     },
-*     { token: 'ation', logprob: 0, bytes: [Array], top_logprobs: [] },
-*     {
-*       token: '.',
-*       logprob: -0.0000037697225,
-*       bytes: [Array],
-*       top_logprobs: []
-*     }
-*   ],
-*   refusal: null
-* }
-* ```
-* </details>
-*
-* <br />
-*
-* <details>
-* <summary><strong>Response Metadata</strong></summary>
-*
-* ```typescript
-* const aiMsgForResponseMetadata = await llm.invoke(input);
-* console.log(aiMsgForResponseMetadata.response_metadata);
-* ```
-*
-* ```txt
-* {
-*   tokenUsage: { completionTokens: 5, promptTokens: 28, totalTokens: 33 },
-*   finish_reason: 'stop',
-*   system_fingerprint: 'fp_3aa7262c27'
-* }
-* ```
-* </details>
-*
-* <br />
-*
-* <details>
-* <summary><strong>JSON Schema Structured Output</strong></summary>
-*
-* ```typescript
-* const llmForJsonSchema = new ChatOpenAI({
-*   model: "gpt-4o-2024-08-06",
-* }).withStructuredOutput(
-*   z.object({
-*     command: z.string().describe("The command to execute"),
-*     expectedOutput: z.string().describe("The expected output of the command"),
-*     options: z
-*       .array(z.string())
-*       .describe("The options you can pass to the command"),
-*   }),
-*   {
-*     method: "jsonSchema",
-*     strict: true, // Optional when using the `jsonSchema` method
-*   }
-* );
-*
-* const jsonSchemaRes = await llmForJsonSchema.invoke(
-*   "What is the command to list files in a directory?"
-* );
-* console.log(jsonSchemaRes);
-* ```
-*
-* ```txt
-* {
-*   command: 'ls',
-*   expectedOutput: 'A list of files and subdirectories within the specified directory.',
-*   options: [
-*     '-a: include directory entries whose names begin with a dot (.).',
-*     '-l: use a long listing format.',
-*     '-h: with -l, print sizes in human readable format (e.g., 1K, 234M, 2G).',
-*     '-t: sort by time, newest first.',
-*     '-r: reverse order while sorting.',
-*     '-S: sort by file size, largest first.',
-*     '-R: list subdirectories recursively.'
-*   ]
-* }
-* ```
-* </details>
-*
-* <br />
-*
-* <details>
-* <summary><strong>Audio Outputs</strong></summary>
-*
-* ```typescript
-* import { ChatOpenAI } from "@langchain/openai";
-*
-* const modelWithAudioOutput = new ChatOpenAI({
-*   model: "gpt-4o-audio-preview",
-*   // You may also pass these fields to `.withConfig` as a call argument.
-*   modalities: ["text", "audio"], // Specifies that the model should output audio.
-*   audio: {
-*     voice: "alloy",
-*     format: "wav",
-*   },
-* });
-*
-* const audioOutputResult = await modelWithAudioOutput.invoke("Tell me a joke about cats.");
-* const castMessageContent = audioOutputResult.content[0] as Record<string, any>;
-*
-* console.log({
-*   ...castMessageContent,
-*   data: castMessageContent.data.slice(0, 100) // Sliced for brevity
-* })
-* ```
-*
-* ```txt
-* {
-*   id: 'audio_67117718c6008190a3afad3e3054b9b6',
-*   data: 'UklGRqYwBgBXQVZFZm10IBAAAAABAAEAwF0AAIC7AAACABAATElTVBoAAABJTkZPSVNGVA4AAABMYXZmNTguMjkuMTAwAGRhdGFg',
-*   expires_at: 1729201448,
-*   transcript: 'Sure! Why did the cat sit on the computer? Because it wanted to keep an eye on the mouse!'
-* }
-* ```
-* </details>
-*
-* <br />
-*
-* <details>
-* <summary><strong>Audio Outputs</strong></summary>
-*
-* ```typescript
-* import { ChatOpenAI } from "@langchain/openai";
-*
-* const modelWithAudioOutput = new ChatOpenAI({
-*   model: "gpt-4o-audio-preview",
-*   // You may also pass these fields to `.withConfig` as a call argument.
-*   modalities: ["text", "audio"], // Specifies that the model should output audio.
-*   audio: {
-*     voice: "alloy",
-*     format: "wav",
-*   },
-* });
-*
-* const audioOutputResult = await modelWithAudioOutput.invoke("Tell me a joke about cats.");
-* const castAudioContent = audioOutputResult.additional_kwargs.audio as Record<string, any>;
-*
-* console.log({
-*   ...castAudioContent,
-*   data: castAudioContent.data.slice(0, 100) // Sliced for brevity
-* })
-* ```
-*
-* ```txt
-* {
-*   id: 'audio_67117718c6008190a3afad3e3054b9b6',
-*   data: 'UklGRqYwBgBXQVZFZm10IBAAAAABAAEAwF0AAIC7AAACABAATElTVBoAAABJTkZPSVNGVA4AAABMYXZmNTguMjkuMTAwAGRhdGFg',
-*   expires_at: 1729201448,
-*   transcript: 'Sure! Why did the cat sit on the computer? Because it wanted to keep an eye on the mouse!'
-* }
-* ```
-* </details>
-*
-* <br />
-*/
-var ChatOpenAI = class ChatOpenAI extends BaseChatOpenAI {
-	/**
-	* Whether to use the responses API for all requests. If `false` the responses API will be used
-	* only when required in order to fulfill the request.
-	*/
-	useResponsesApi = false;
-	responses;
-	completions;
-	get lc_serializable_keys() {
-		return [...super.lc_serializable_keys, "useResponsesApi"];
-	}
-	constructor(fields) {
-		super(fields);
-		this.fields = fields;
-		this.useResponsesApi = fields?.useResponsesApi ?? false;
-		this.responses = fields?.responses ?? new ChatOpenAIResponses(fields);
-		this.completions = fields?.completions ?? new ChatOpenAICompletions(fields);
-	}
-	_useResponsesApi(options) {
-		const usesBuiltInTools = options?.tools?.some(isBuiltInTool);
-		const hasResponsesOnlyKwargs = options?.previous_response_id != null || options?.text != null || options?.truncation != null || options?.include != null || options?.reasoning?.summary != null || this.reasoning?.summary != null;
-		const hasCustomTools = options?.tools?.some(isOpenAICustomTool);
-		return this.useResponsesApi || usesBuiltInTools || hasResponsesOnlyKwargs || hasCustomTools;
-	}
-	getLsParams(options) {
-		const optionsWithDefaults = this._combineCallOptions(options);
-		if (this._useResponsesApi(options)) return this.responses.getLsParams(optionsWithDefaults);
-		return this.completions.getLsParams(optionsWithDefaults);
-	}
-	invocationParams(options) {
-		const optionsWithDefaults = this._combineCallOptions(options);
-		if (this._useResponsesApi(options)) return this.responses.invocationParams(optionsWithDefaults);
-		return this.completions.invocationParams(optionsWithDefaults);
-	}
-	/** @ignore */
-	async _generate(messages, options, runManager) {
-		if (this._useResponsesApi(options)) return this.responses._generate(messages, options);
-		return this.completions._generate(messages, options, runManager);
-	}
-	async *_streamResponseChunks(messages, options, runManager) {
-		if (this._useResponsesApi(options)) {
-			yield* this.responses._streamResponseChunks(messages, this._combineCallOptions(options), runManager);
-			return;
-		}
-		yield* this.completions._streamResponseChunks(messages, this._combineCallOptions(options), runManager);
-	}
-	withConfig(config) {
-		const newModel = new ChatOpenAI(this.fields);
-		newModel.defaultOptions = {
-			...this.defaultOptions,
-			...config
-		};
-		return newModel;
-	}
-};
-
-//#endregion
-export { BaseChatOpenAI, ChatOpenAI, ChatOpenAICompletions, ChatOpenAIResponses };
-//# sourceMappingURL=chat_models.js.map