@langchain/openai 0.6.8 → 1.0.0-alpha.1

package/dist/chat_models.d.ts

@@ -1,275 +1,300 @@
-import { type ClientOptions, OpenAI as OpenAIClient } from "openai";
-import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
-import { AIMessageChunk, type BaseMessage, ChatMessageChunk, FunctionMessageChunk, HumanMessageChunk, SystemMessageChunk, ToolMessageChunk } from "@langchain/core/messages";
-import { ChatGenerationChunk, type ChatGeneration, type ChatResult } from "@langchain/core/outputs";
-import { BaseChatModel, type LangSmithParams, type BaseChatModelParams } from "@langchain/core/language_models/chat_models";
-import { type BaseFunctionCallOptions, type BaseLanguageModelInput, type StructuredOutputMethodOptions } from "@langchain/core/language_models/base";
+import { IterableReadableStream } from "./langchain-core/dist/utils/stream.js";
+import { ChatOpenAIReasoningSummary, ChatOpenAIResponseFormat, OpenAICallOptions, OpenAIChatInput, OpenAICoreRequestOptions, OpenAIVerbosityParam, ResponseFormatConfiguration } from "./types.js";
+import { ChatOpenAIToolType, OpenAIToolChoice, ResponsesTool, ResponsesToolChoice } from "./utils/tools.js";
+import { ClientOptions, OpenAI as OpenAI$1 } from "openai";
+import { AIMessageChunk, BaseMessage, ChatMessageChunk, FunctionMessageChunk, HumanMessageChunk, SystemMessageChunk, ToolMessageChunk } from "@langchain/core/messages";
+import { ChatGeneration, ChatGenerationChunk, ChatResult } from "@langchain/core/outputs";
+import { BaseChatModel, BaseChatModelParams, LangSmithParams } from "@langchain/core/language_models/chat_models";
+import { BaseFunctionCallOptions, BaseLanguageModelInput, StructuredOutputMethodOptions } from "@langchain/core/language_models/base";
 import { Runnable } from "@langchain/core/runnables";
 import { InteropZodType } from "@langchain/core/utils/types";
-import { type OpenAICallOptions, type OpenAIChatInput, type OpenAICoreRequestOptions, type ChatOpenAIResponseFormat, ChatOpenAIReasoningSummary, ResponseFormatConfiguration } from "./types.js";
-import { OpenAIToolChoice } from "./utils/openai.js";
-import { ChatOpenAIToolType, ResponsesTool, ResponsesToolChoice } from "./utils/tools.js";
+import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
+
+//#region src/chat_models.d.ts
 interface OpenAILLMOutput {
-    tokenUsage: {
-        completionTokens?: number;
-        promptTokens?: number;
-        totalTokens?: number;
-    };
+  tokenUsage: {
+    completionTokens?: number;
+    promptTokens?: number;
+    totalTokens?: number;
+  };
 }
-export type { OpenAICallOptions, OpenAIChatInput };
-export declare function messageToOpenAIRole(message: BaseMessage): OpenAIClient.ChatCompletionRole;
-export declare function _convertMessagesToOpenAIParams(messages: BaseMessage[], model?: string): OpenAIClient.Chat.Completions.ChatCompletionMessageParam[];
-export interface BaseChatOpenAICallOptions extends OpenAICallOptions, BaseFunctionCallOptions {
-    /**
-     * A list of tools that the model may use to generate responses.
-     * Each tool can be a function, a built-in tool, or a custom tool definition.
-     * If not provided, the model will not use any tools.
-     */
-    tools?: ChatOpenAIToolType[];
-    /**
-     * Specifies which tool the model should use to respond.
-     * Can be an {@link OpenAIToolChoice} or a {@link ResponsesToolChoice}.
-     * If not set, the model will decide which tool to use automatically.
-     */
-    tool_choice?: OpenAIToolChoice | ResponsesToolChoice;
-    /**
-     * Adds a prompt index to prompts passed to the model to track
-     * what prompt is being used for a given generation.
-     */
-    promptIndex?: number;
-    /**
-     * An object specifying the format that the model must output.
-     */
-    response_format?: ChatOpenAIResponseFormat;
-    /**
-     * When provided, the completions API will make a best effort to sample
-     * deterministically, such that repeated requests with the same `seed`
-     * and parameters should return the same result.
-     */
-    seed?: number;
-    /**
-     * Additional options to pass to streamed completions.
-     * If provided, this takes precedence over "streamUsage" set at
-     * initialization time.
-     */
-    stream_options?: OpenAIClient.Chat.ChatCompletionStreamOptions;
-    /**
-     * The model may choose to call multiple functions in a single turn. You can
-     * set parallel_tool_calls to false which ensures only one tool is called at most.
-     * [Learn more](https://platform.openai.com/docs/guides/function-calling#parallel-function-calling)
-     */
-    parallel_tool_calls?: boolean;
-    /**
-     * If `true`, model output is guaranteed to exactly match the JSON Schema
-     * provided in the tool definition. If `true`, the input schema will also be
-     * validated according to
-     * https://platform.openai.com/docs/guides/structured-outputs/supported-schemas.
-     *
-     * If `false`, input schema will not be validated and model output will not
-     * be validated.
-     *
-     * If `undefined`, `strict` argument will not be passed to the model.
-     */
-    strict?: boolean;
-    /**
-     * Output types that you would like the model to generate for this request. Most
-     * models are capable of generating text, which is the default:
-     *
-     * `["text"]`
-     *
-     * The `gpt-4o-audio-preview` model can also be used to
-     * [generate audio](https://platform.openai.com/docs/guides/audio). To request that
-     * this model generate both text and audio responses, you can use:
-     *
-     * `["text", "audio"]`
-     */
-    modalities?: Array<OpenAIClient.Chat.ChatCompletionModality>;
-    /**
-     * Parameters for audio output. Required when audio output is requested with
-     * `modalities: ["audio"]`.
-     * [Learn more](https://platform.openai.com/docs/guides/audio).
-     */
-    audio?: OpenAIClient.Chat.ChatCompletionAudioParam;
-    /**
-     * Static predicted output content, such as the content of a text file that is being regenerated.
-     * [Learn more](https://platform.openai.com/docs/guides/latency-optimization#use-predicted-outputs).
-     */
-    prediction?: OpenAIClient.ChatCompletionPredictionContent;
-    /**
-     * Options for reasoning models.
-     *
-     * Note that some options, like reasoning summaries, are only available when using the responses
-     * API. If these options are set, the responses API will be used to fulfill the request.
-     *
-     * These options will be ignored when not using a reasoning model.
-     */
-    reasoning?: OpenAIClient.Reasoning;
-    /**
-     * Service tier to use for this request. Can be "auto", "default", or "flex"
-     * Specifies the service tier for prioritization and latency optimization.
-     */
-    service_tier?: OpenAIClient.Chat.ChatCompletionCreateParams["service_tier"];
-    /**
-     * Used by OpenAI to cache responses for similar requests to optimize your cache
-     * hit rates. Replaces the `user` field.
-     * [Learn more](https://platform.openai.com/docs/guides/prompt-caching).
-     */
-    promptCacheKey?: string;
+interface BaseChatOpenAICallOptions extends OpenAICallOptions, BaseFunctionCallOptions {
+  /**
+   * A list of tools that the model may use to generate responses.
+   * Each tool can be a function, a built-in tool, or a custom tool definition.
+   * If not provided, the model will not use any tools.
+   */
+  tools?: ChatOpenAIToolType[];
+  /**
+   * Specifies which tool the model should use to respond.
+   * Can be an {@link OpenAIToolChoice} or a {@link ResponsesToolChoice}.
+   * If not set, the model will decide which tool to use automatically.
+   */
+  // TODO: break OpenAIToolChoice and ResponsesToolChoice into options sub classes
+  tool_choice?: OpenAIToolChoice | ResponsesToolChoice;
+  /**
+   * Adds a prompt index to prompts passed to the model to track
+   * what prompt is being used for a given generation.
+   */
+  promptIndex?: number;
+  /**
+   * An object specifying the format that the model must output.
+   */
+  response_format?: ChatOpenAIResponseFormat;
+  /**
+   * When provided, the completions API will make a best effort to sample
+   * deterministically, such that repeated requests with the same `seed`
+   * and parameters should return the same result.
+   */
+  seed?: number;
+  /**
+   * Additional options to pass to streamed completions.
+   * If provided, this takes precedence over "streamUsage" set at
+   * initialization time.
+   */
+  stream_options?: OpenAI$1.Chat.ChatCompletionStreamOptions;
+  /**
+   * The model may choose to call multiple functions in a single turn. You can
+   * set parallel_tool_calls to false which ensures only one tool is called at most.
+   * [Learn more](https://platform.openai.com/docs/guides/function-calling#parallel-function-calling)
+   */
+  parallel_tool_calls?: boolean;
+  /**
+   * If `true`, model output is guaranteed to exactly match the JSON Schema
+   * provided in the tool definition. If `true`, the input schema will also be
+   * validated according to
+   * https://platform.openai.com/docs/guides/structured-outputs/supported-schemas.
+   *
+   * If `false`, input schema will not be validated and model output will not
+   * be validated.
+   *
+   * If `undefined`, `strict` argument will not be passed to the model.
+   */
+  strict?: boolean;
+  /**
+   * Output types that you would like the model to generate for this request. Most
+   * models are capable of generating text, which is the default:
+   *
+   * `["text"]`
+   *
+   * The `gpt-4o-audio-preview` model can also be used to
+   * [generate audio](https://platform.openai.com/docs/guides/audio). To request that
+   * this model generate both text and audio responses, you can use:
+   *
+   * `["text", "audio"]`
+   */
+  modalities?: Array<OpenAI$1.Chat.ChatCompletionModality>;
+  /**
+   * Parameters for audio output. Required when audio output is requested with
+   * `modalities: ["audio"]`.
+   * [Learn more](https://platform.openai.com/docs/guides/audio).
+   */
+  audio?: OpenAI$1.Chat.ChatCompletionAudioParam;
+  /**
+   * Static predicted output content, such as the content of a text file that is being regenerated.
+   * [Learn more](https://platform.openai.com/docs/guides/latency-optimization#use-predicted-outputs).
+   */
+  prediction?: OpenAI$1.ChatCompletionPredictionContent;
+  /**
+   * Options for reasoning models.
+   *
+   * Note that some options, like reasoning summaries, are only available when using the responses
+   * API. If these options are set, the responses API will be used to fulfill the request.
+   *
+   * These options will be ignored when not using a reasoning model.
+   */
+  reasoning?: OpenAI$1.Reasoning;
+  /**
+   * Service tier to use for this request. Can be "auto", "default", or "flex"
+   * Specifies the service tier for prioritization and latency optimization.
+   */
+  service_tier?: OpenAI$1.Chat.ChatCompletionCreateParams["service_tier"];
+  /**
+   * Used by OpenAI to cache responses for similar requests to optimize your cache
+   * hit rates. Replaces the `user` field.
+   * [Learn more](https://platform.openai.com/docs/guides/prompt-caching).
+   */
+  promptCacheKey?: string;
+  /**
+   * The verbosity of the model's response.
+   */
+  verbosity?: OpenAIVerbosityParam;
 }
-export interface BaseChatOpenAIFields extends Partial<OpenAIChatInput>, BaseChatModelParams {
-    /**
-     * Optional configuration options for the OpenAI client.
-     */
-    configuration?: ClientOptions;
+interface BaseChatOpenAIFields extends Partial<OpenAIChatInput>, BaseChatModelParams {
+  /**
+   * Optional configuration options for the OpenAI client.
+   */
+  configuration?: ClientOptions;
 }
 /** @internal */
-export declare abstract class BaseChatOpenAI<CallOptions extends BaseChatOpenAICallOptions> extends BaseChatModel<CallOptions, AIMessageChunk> implements Partial<OpenAIChatInput> {
-    temperature?: number;
-    topP?: number;
-    frequencyPenalty?: number;
-    presencePenalty?: number;
-    n?: number;
-    logitBias?: Record<string, number>;
-    model: string;
-    modelKwargs?: OpenAIChatInput["modelKwargs"];
-    stop?: string[];
-    stopSequences?: string[];
-    user?: string;
-    timeout?: number;
-    streaming: boolean;
-    streamUsage: boolean;
-    maxTokens?: number;
-    logprobs?: boolean;
-    topLogprobs?: number;
-    apiKey?: string;
-    organization?: string;
-    __includeRawResponse?: boolean;
-    /** @internal */
-    client: OpenAIClient;
-    /** @internal */
-    clientConfig: ClientOptions;
-    /**
-     * Whether the model supports the `strict` argument when passing in tools.
-     * If `undefined` the `strict` argument will not be passed to OpenAI.
-     */
-    supportsStrictToolCalling?: boolean;
-    audio?: OpenAIClient.Chat.ChatCompletionAudioParam;
-    modalities?: Array<OpenAIClient.Chat.ChatCompletionModality>;
-    reasoning?: OpenAIClient.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://help.openai.com/en/articles/10503543-data-residency-for-the-openai-api
-     * https://platform.openai.com/docs/api-reference/responses/create#responses-create-store
-     *
-     * @default false
-     */
-    zdrEnabled?: boolean | undefined;
-    /**
-     * 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?: OpenAIClient.Chat.ChatCompletionCreateParams["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: string;
-    protected defaultOptions: CallOptions;
-    _llmType(): string;
-    static lc_name(): string;
-    get callKeys(): string[];
-    lc_serializable: boolean;
-    get lc_secrets(): {
-        [key: string]: string;
-    } | undefined;
-    get lc_aliases(): Record<string, string>;
-    get lc_serializable_keys(): string[];
-    getLsParams(options: this["ParsedCallOptions"]): LangSmithParams;
-    /** @ignore */
-    _identifyingParams(): Omit<OpenAIClient.Chat.ChatCompletionCreateParams, "messages"> & {
-        model_name: string;
-    } & ClientOptions;
-    /**
-     * Get the identifying parameters for the model
-     */
-    identifyingParams(): Omit<OpenAIClient.Chat.Completions.ChatCompletionCreateParams, "messages"> & {
-        model_name: string;
-    } & ClientOptions;
-    constructor(fields?: BaseChatOpenAIFields);
-    /**
-     * Returns backwards compatible reasoning parameters from constructor params and call options
-     * @internal
-     */
-    protected _getReasoningParams(options?: this["ParsedCallOptions"]): OpenAIClient.Reasoning | undefined;
-    /**
-     * Returns an openai compatible response format from a set of options
-     * @internal
-     */
-    protected _getResponseFormat(resFormat?: CallOptions["response_format"]): ResponseFormatConfiguration | undefined;
-    protected _combineCallOptions(additionalOptions?: this["ParsedCallOptions"]): this["ParsedCallOptions"];
-    /** @internal */
-    _getClientOptions(options: OpenAICoreRequestOptions | undefined): OpenAICoreRequestOptions;
-    protected _convertChatOpenAIToolToCompletionsTool(tool: ChatOpenAIToolType, fields?: {
-        strict?: boolean;
-    }): OpenAIClient.ChatCompletionTool;
-    bindTools(tools: ChatOpenAIToolType[], kwargs?: Partial<CallOptions>): Runnable<BaseLanguageModelInput, AIMessageChunk, CallOptions>;
-    stream(input: BaseLanguageModelInput, options?: CallOptions): Promise<import("@langchain/core/utils/stream").IterableReadableStream<AIMessageChunk>>;
-    invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<AIMessageChunk>;
-    /** @ignore */
-    _combineLLMOutput(...llmOutputs: OpenAILLMOutput[]): OpenAILLMOutput;
-    getNumTokensFromMessages(messages: BaseMessage[]): Promise<{
-        totalCount: number;
-        countPerMessage: number[];
-    }>;
-    /** @internal */
-    protected _getNumTokensFromGenerations(generations: ChatGeneration[]): Promise<number>;
-    /** @internal */
-    protected _getEstimatedTokenCountFromPrompt(messages: BaseMessage[], functions?: OpenAIClient.Chat.ChatCompletionCreateParams.Function[], function_call?: "none" | "auto" | OpenAIClient.Chat.ChatCompletionFunctionCallOption): Promise<number>;
-    /** @internal */
-    protected _getStructuredOutputMethod(config: StructuredOutputMethodOptions<boolean>): string | undefined;
-    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: InteropZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
-    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: InteropZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
-        raw: BaseMessage;
-        parsed: RunOutput;
-    }>;
-    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: InteropZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<boolean>): Runnable<BaseLanguageModelInput, RunOutput> | Runnable<BaseLanguageModelInput, {
-        raw: BaseMessage;
-        parsed: RunOutput;
-    }>;
+declare abstract class BaseChatOpenAI<CallOptions extends BaseChatOpenAICallOptions> extends BaseChatModel<CallOptions, AIMessageChunk> implements Partial<OpenAIChatInput> {
+  temperature?: number;
+  topP?: number;
+  frequencyPenalty?: number;
+  presencePenalty?: number;
+  n?: number;
+  logitBias?: Record<string, number>;
+  model: string;
+  modelKwargs?: OpenAIChatInput["modelKwargs"];
+  stop?: string[];
+  stopSequences?: string[];
+  user?: string;
+  timeout?: number;
+  streaming: boolean;
+  streamUsage: boolean;
+  maxTokens?: number;
+  logprobs?: boolean;
+  topLogprobs?: number;
+  apiKey?: string;
+  organization?: string;
+  __includeRawResponse?: boolean;
+  /** @internal */
+  client: OpenAI$1;
+  /** @internal */
+  clientConfig: ClientOptions;
+  /**
+   * Whether the model supports the `strict` argument when passing in tools.
+   * If `undefined` the `strict` argument will not be passed to OpenAI.
+   */
+  supportsStrictToolCalling?: boolean;
+  audio?: OpenAI$1.Chat.ChatCompletionAudioParam;
+  modalities?: Array<OpenAI$1.Chat.ChatCompletionModality>;
+  reasoning?: OpenAI$1.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://help.openai.com/en/articles/10503543-data-residency-for-the-openai-api
+   * https://platform.openai.com/docs/api-reference/responses/create#responses-create-store
+   *
+   * @default false
+   */
+  zdrEnabled?: boolean | undefined;
+  /**
+   * 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?: OpenAI$1.Chat.ChatCompletionCreateParams["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: string;
+  /**
+   * The verbosity of the model's response.
+   */
+  verbosity?: OpenAIVerbosityParam;
+  protected defaultOptions: CallOptions;
+  _llmType(): string;
+  static lc_name(): string;
+  get callKeys(): string[];
+  lc_serializable: boolean;
+  get lc_secrets(): {
+    [key: string]: string;
+  } | undefined;
+  get lc_aliases(): Record<string, string>;
+  get lc_serializable_keys(): string[];
+  getLsParams(options: this["ParsedCallOptions"]): LangSmithParams;
+  /** @ignore */
+  _identifyingParams(): Omit<OpenAI$1.Chat.ChatCompletionCreateParams, "messages"> & {
+    model_name: string;
+  } & ClientOptions;
+  /**
+   * Get the identifying parameters for the model
+   */
+  identifyingParams(): Omit<OpenAI$1.ChatCompletionCreateParams, "messages"> & {
+    model_name: string;
+  } & ClientOptions;
+  constructor(fields?: BaseChatOpenAIFields);
+  /**
+   * Returns backwards compatible reasoning parameters from constructor params and call options
+   * @internal
+   */
+  protected _getReasoningParams(options?: this["ParsedCallOptions"]): OpenAI$1.Reasoning | undefined;
+  /**
+   * Returns an openai compatible response format from a set of options
+   * @internal
+   */
+  protected _getResponseFormat(resFormat?: CallOptions["response_format"]): ResponseFormatConfiguration | undefined;
+  protected _combineCallOptions(additionalOptions?: this["ParsedCallOptions"]): this["ParsedCallOptions"];
+  /** @internal */
+  _getClientOptions(options: OpenAICoreRequestOptions | undefined): OpenAICoreRequestOptions;
+  // TODO: move to completions class
+  protected _convertChatOpenAIToolToCompletionsTool(tool: ChatOpenAIToolType, fields?: {
+    strict?: boolean;
+  }): OpenAI$1.ChatCompletionTool;
+  bindTools(tools: ChatOpenAIToolType[], kwargs?: Partial<CallOptions>): Runnable<BaseLanguageModelInput, AIMessageChunk, CallOptions>;
+  stream(input: BaseLanguageModelInput, options?: CallOptions): Promise<IterableReadableStream<AIMessageChunk>>;
+  invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<AIMessageChunk>;
+  /** @ignore */
+  _combineLLMOutput(...llmOutputs: OpenAILLMOutput[]): OpenAILLMOutput;
+  getNumTokensFromMessages(messages: BaseMessage[]): Promise<{
+    totalCount: number;
+    countPerMessage: number[];
+  }>;
+  /** @internal */
+  protected _getNumTokensFromGenerations(generations: ChatGeneration[]): Promise<number>;
+  /** @internal */
+  protected _getEstimatedTokenCountFromPrompt(messages: BaseMessage[], functions?: OpenAI$1.Chat.ChatCompletionCreateParams.Function[], function_call?: "none" | "auto" | OpenAI$1.Chat.ChatCompletionFunctionCallOption): Promise<number>;
+  /** @internal */
+  protected _getStructuredOutputMethod(config: StructuredOutputMethodOptions<boolean>): string | undefined;
+  withStructuredOutput<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: InteropZodType<RunOutput>
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
+  withStructuredOutput<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: InteropZodType<RunOutput>
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
+    raw: BaseMessage;
+    parsed: RunOutput;
+  }>;
+  withStructuredOutput<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: InteropZodType<RunOutput>
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  | Record<string, any>, config?: StructuredOutputMethodOptions<boolean>): Runnable<BaseLanguageModelInput, RunOutput> | Runnable<BaseLanguageModelInput, {
+    raw: BaseMessage;
+    parsed: RunOutput;
+  }>;
 }
+interface ChatOpenAIResponsesCallOptions extends BaseChatOpenAICallOptions {
+  /**
+   * Configuration options for a text response from the model. Can be plain text or
+   * structured JSON data.
+   */
+  text?: OpenAI$1.Responses.ResponseCreateParams["text"];
+  /**
+   * The truncation strategy to use for the model response.
+   */
+  truncation?: OpenAI$1.Responses.ResponseCreateParams["truncation"];
+  /**
+   * Specify additional output data to include in the model response.
+   */
+  include?: OpenAI$1.Responses.ResponseCreateParams["include"];
+  /**
+   * The unique ID of the previous response to the model. Use this to create multi-turn
+   * conversations.
+   */
+  previous_response_id?: OpenAI$1.Responses.ResponseCreateParams["previous_response_id"];
+  /**
+   * The verbosity of the model's response.
+   */
+  verbosity?: OpenAIVerbosityParam;
+}
+type ChatResponsesInvocationParams = Omit<OpenAI$1.Responses.ResponseCreateParams, "input">;
 type ExcludeController<T> = T extends {
-    controller: unknown;
+  controller: unknown;
 } ? never : T;
-type ResponsesCreate = OpenAIClient.Responses["create"];
-type ResponsesParse = OpenAIClient.Responses["parse"];
+type ResponsesCreate = OpenAI$1.Responses["create"];
+type ResponsesParse = OpenAI$1.Responses["parse"];
 type ResponsesCreateInvoke = ExcludeController<Awaited<ReturnType<ResponsesCreate>>>;
 type ResponsesParseInvoke = ExcludeController<Awaited<ReturnType<ResponsesParse>>>;
-export interface ChatOpenAIResponsesCallOptions extends BaseChatOpenAICallOptions {
-    /**
-     * Configuration options for a text response from the model. Can be plain text or
-     * structured JSON data.
-     */
-    text?: OpenAIClient.Responses.ResponseCreateParams["text"];
-    /**
-     * The truncation strategy to use for the model response.
-     */
-    truncation?: OpenAIClient.Responses.ResponseCreateParams["truncation"];
-    /**
-     * Specify additional output data to include in the model response.
-     */
-    include?: OpenAIClient.Responses.ResponseCreateParams["include"];
-    /**
-     * The unique ID of the previous response to the model. Use this to create multi-turn
-     * conversations.
-     */
-    previous_response_id?: OpenAIClient.Responses.ResponseCreateParams["previous_response_id"];
-}
-type ChatResponsesInvocationParams = Omit<OpenAIClient.Responses.ResponseCreateParams, "input">;
 /**
  * OpenAI Responses API implementation.
  *
@@ -277,70 +302,71 @@ type ChatResponsesInvocationParams = Omit<OpenAIClient.Responses.ResponseCreateP
  *
  * @internal
  */
-export declare class ChatOpenAIResponses<CallOptions extends ChatOpenAIResponsesCallOptions = ChatOpenAIResponsesCallOptions> extends BaseChatOpenAI<CallOptions> {
-    invocationParams(options?: this["ParsedCallOptions"]): ChatResponsesInvocationParams;
-    _generate(messages: BaseMessage[], options: this["ParsedCallOptions"]): Promise<ChatResult>;
-    _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
-    /**
-     * Calls the Responses API with retry logic in case of failures.
-     * @param request The request to send to the OpenAI API.
-     * @param options Optional configuration for the API call.
-     * @returns The response from the OpenAI API.
-     */
-    completionWithRetry(request: OpenAIClient.Responses.ResponseCreateParamsStreaming, requestOptions?: OpenAIClient.RequestOptions): Promise<AsyncIterable<OpenAIClient.Responses.ResponseStreamEvent>>;
-    completionWithRetry(request: OpenAIClient.Responses.ResponseCreateParamsNonStreaming, requestOptions?: OpenAIClient.RequestOptions): Promise<OpenAIClient.Responses.Response>;
-    /** @internal */
-    protected _convertResponsesMessageToBaseMessage(response: ResponsesCreateInvoke | ResponsesParseInvoke): BaseMessage;
-    /** @internal */
-    protected _convertResponsesDeltaToBaseMessageChunk(chunk: OpenAIClient.Responses.ResponseStreamEvent): ChatGenerationChunk | null;
-    /** @internal */
-    protected _convertMessagesToResponsesParams(messages: BaseMessage[]): (OpenAIClient.Responses.ResponseReasoningItem | OpenAIClient.Responses.EasyInputMessage | OpenAIClient.Responses.ResponseInputItem.Message | OpenAIClient.Responses.ResponseOutputMessage | OpenAIClient.Responses.ResponseFileSearchToolCall | OpenAIClient.Responses.ResponseComputerToolCall | OpenAIClient.Responses.ResponseInputItem.ComputerCallOutput | OpenAIClient.Responses.ResponseFunctionWebSearch | OpenAIClient.Responses.ResponseFunctionToolCall | OpenAIClient.Responses.ResponseInputItem.FunctionCallOutput | OpenAIClient.Responses.ResponseInputItem.ImageGenerationCall | OpenAIClient.Responses.ResponseCodeInterpreterToolCall | OpenAIClient.Responses.ResponseInputItem.LocalShellCall | OpenAIClient.Responses.ResponseInputItem.LocalShellCallOutput | OpenAIClient.Responses.ResponseInputItem.McpListTools | OpenAIClient.Responses.ResponseInputItem.McpApprovalRequest | OpenAIClient.Responses.ResponseInputItem.McpApprovalResponse | OpenAIClient.Responses.ResponseInputItem.McpCall | OpenAIClient.Responses.ResponseCustomToolCallOutput | OpenAIClient.Responses.ResponseCustomToolCall | OpenAIClient.Responses.ResponseInputItem.ItemReference)[];
-    /** @internal */
-    protected _convertReasoningSummary(reasoning: ChatOpenAIReasoningSummary): OpenAIClient.Responses.ResponseReasoningItem;
-    /** @internal */
-    protected _reduceChatOpenAITools(tools: ChatOpenAIToolType[], fields: {
-        stream?: boolean;
-        strict?: boolean;
-    }): ResponsesTool[];
-}
-export interface ChatOpenAICompletionsCallOptions extends BaseChatOpenAICallOptions {
+declare class ChatOpenAIResponses<CallOptions extends ChatOpenAIResponsesCallOptions = ChatOpenAIResponsesCallOptions> extends BaseChatOpenAI<CallOptions> {
+  invocationParams(options?: this["ParsedCallOptions"]): ChatResponsesInvocationParams;
+  _generate(messages: BaseMessage[], options: this["ParsedCallOptions"]): Promise<ChatResult>;
+  _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+  /**
+   * Calls the Responses API with retry logic in case of failures.
+   * @param request The request to send to the OpenAI API.
+   * @param options Optional configuration for the API call.
+   * @returns The response from the OpenAI API.
+   */
+  completionWithRetry(request: OpenAI$1.Responses.ResponseCreateParamsStreaming, requestOptions?: OpenAI$1.RequestOptions): Promise<AsyncIterable<OpenAI$1.Responses.ResponseStreamEvent>>;
+  completionWithRetry(request: OpenAI$1.Responses.ResponseCreateParamsNonStreaming, requestOptions?: OpenAI$1.RequestOptions): Promise<OpenAI$1.Responses.Response>;
+  /** @internal */
+  protected _convertResponsesMessageToBaseMessage(response: ResponsesCreateInvoke | ResponsesParseInvoke): BaseMessage;
+  /** @internal */
+  protected _convertResponsesDeltaToBaseMessageChunk(chunk: OpenAI$1.Responses.ResponseStreamEvent): ChatGenerationChunk | null;
+  /** @internal */
+  protected _convertMessagesToResponsesParams(messages: BaseMessage[]): (OpenAI$1.Responses.ResponseInputItem.ComputerCallOutput | OpenAI$1.Responses.EasyInputMessage | OpenAI$1.Responses.ResponseInputItem.FunctionCallOutput | OpenAI$1.Responses.ResponseInputItem.ImageGenerationCall | OpenAI$1.Responses.ResponseInputItem.ItemReference | OpenAI$1.Responses.ResponseInputItem.LocalShellCall | OpenAI$1.Responses.ResponseInputItem.LocalShellCallOutput | OpenAI$1.Responses.ResponseInputItem.McpApprovalRequest | OpenAI$1.Responses.ResponseInputItem.McpApprovalResponse | OpenAI$1.Responses.ResponseInputItem.McpCall | OpenAI$1.Responses.ResponseInputItem.McpListTools | OpenAI$1.Responses.ResponseInputItem.Message | OpenAI$1.Responses.ResponseCodeInterpreterToolCall | OpenAI$1.Responses.ResponseComputerToolCall | OpenAI$1.Responses.ResponseCustomToolCall | OpenAI$1.Responses.ResponseCustomToolCallOutput | OpenAI$1.Responses.ResponseFileSearchToolCall | OpenAI$1.Responses.ResponseFunctionToolCall | OpenAI$1.Responses.ResponseFunctionWebSearch | OpenAI$1.Responses.ResponseOutputMessage | OpenAI$1.Responses.ResponseReasoningItem)[];
+  /** @internal */
+  protected _convertReasoningSummary(reasoning: ChatOpenAIReasoningSummary): OpenAI$1.Responses.ResponseReasoningItem;
+  /** @internal */
+  protected _reduceChatOpenAITools(tools: ChatOpenAIToolType[], fields: {
+    stream?: boolean;
+    strict?: boolean;
+  }): ResponsesTool[];
 }
-type ChatCompletionsInvocationParams = Omit<OpenAIClient.Chat.Completions.ChatCompletionCreateParams, "messages">;
+interface ChatOpenAICompletionsCallOptions extends BaseChatOpenAICallOptions {}
+type ChatCompletionsInvocationParams = Omit<OpenAI$1.Chat.Completions.ChatCompletionCreateParams, "messages">;
 /**
  * OpenAI Completions API implementation.
  * @internal
  */
-export declare class ChatOpenAICompletions<CallOptions extends ChatOpenAICompletionsCallOptions = ChatOpenAICompletionsCallOptions> extends BaseChatOpenAI<CallOptions> {
-    /** @internal */
-    invocationParams(options?: this["ParsedCallOptions"], extra?: {
-        streaming?: boolean;
-    }): ChatCompletionsInvocationParams;
-    _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
-    _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
-    completionWithRetry(request: OpenAIClient.Chat.ChatCompletionCreateParamsStreaming, requestOptions?: OpenAIClient.RequestOptions): Promise<AsyncIterable<OpenAIClient.Chat.Completions.ChatCompletionChunk>>;
-    completionWithRetry(request: OpenAIClient.Chat.ChatCompletionCreateParamsNonStreaming, requestOptions?: OpenAIClient.RequestOptions): Promise<OpenAIClient.Chat.Completions.ChatCompletion>;
-    /** @internal */
-    protected _convertCompletionsMessageToBaseMessage(message: OpenAIClient.Chat.Completions.ChatCompletionMessage, rawResponse: OpenAIClient.Chat.Completions.ChatCompletion): BaseMessage;
-    /** @internal */
-    protected _convertCompletionsDeltaToBaseMessageChunk(delta: Record<string, any>, rawResponse: OpenAIClient.Chat.Completions.ChatCompletionChunk, defaultRole?: OpenAIClient.Chat.ChatCompletionRole): AIMessageChunk | HumanMessageChunk | SystemMessageChunk | FunctionMessageChunk | ToolMessageChunk | ChatMessageChunk;
+declare class ChatOpenAICompletions<CallOptions extends ChatOpenAICompletionsCallOptions = ChatOpenAICompletionsCallOptions> extends BaseChatOpenAI<CallOptions> {
+  /** @internal */
+  invocationParams(options?: this["ParsedCallOptions"], extra?: {
+    streaming?: boolean;
+  }): ChatCompletionsInvocationParams;
+  _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+  _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+  completionWithRetry(request: OpenAI$1.Chat.ChatCompletionCreateParamsStreaming, requestOptions?: OpenAI$1.RequestOptions): Promise<AsyncIterable<OpenAI$1.Chat.Completions.ChatCompletionChunk>>;
+  completionWithRetry(request: OpenAI$1.Chat.ChatCompletionCreateParamsNonStreaming, requestOptions?: OpenAI$1.RequestOptions): Promise<OpenAI$1.Chat.Completions.ChatCompletion>;
+  /** @internal */
+  protected _convertCompletionsMessageToBaseMessage(message: OpenAI$1.Chat.Completions.ChatCompletionMessage, rawResponse: OpenAI$1.Chat.Completions.ChatCompletion): BaseMessage;
+  /** @internal */
+  protected _convertCompletionsDeltaToBaseMessageChunk(
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  delta: Record<string, any>, rawResponse: OpenAI$1.Chat.Completions.ChatCompletionChunk, defaultRole?: OpenAI$1.Chat.ChatCompletionRole): AIMessageChunk | ChatMessageChunk | FunctionMessageChunk | HumanMessageChunk | SystemMessageChunk | ToolMessageChunk;
 }
-export type ChatOpenAICallOptions = ChatOpenAICompletionsCallOptions & ChatOpenAIResponsesCallOptions;
-export interface ChatOpenAIFields extends BaseChatOpenAIFields {
-    /**
-     * 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?: boolean;
-    /**
-     * The completions chat instance
-     * @internal
-     */
-    completions?: ChatOpenAICompletions;
-    /**
-     * The responses chat instance
-     * @internal
-     */
-    responses?: ChatOpenAIResponses;
+type ChatOpenAICallOptions = ChatOpenAICompletionsCallOptions & ChatOpenAIResponsesCallOptions;
+interface ChatOpenAIFields extends BaseChatOpenAIFields {
+  /**
+   * 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?: boolean;
+  /**
+   * The completions chat instance
+   * @internal
+   */
+  completions?: ChatOpenAICompletions;
+  /**
+   * The responses chat instance
+   * @internal
+   */
+  responses?: ChatOpenAIResponses;
 }
 /**
  * OpenAI chat model integration.
@@ -880,22 +906,25 @@ export interface ChatOpenAIFields extends BaseChatOpenAIFields {
  *
  * <br />
  */
-export declare class ChatOpenAI<CallOptions extends ChatOpenAICallOptions = ChatOpenAICallOptions> extends BaseChatOpenAI<CallOptions> {
-    protected fields?: ChatOpenAIFields | undefined;
-    /**
-     * 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: boolean;
-    protected responses: ChatOpenAIResponses;
-    protected completions: ChatOpenAICompletions;
-    get lc_serializable_keys(): string[];
-    constructor(fields?: ChatOpenAIFields | undefined);
-    protected _useResponsesApi(options: this["ParsedCallOptions"] | undefined): boolean | undefined;
-    getLsParams(options: this["ParsedCallOptions"]): LangSmithParams;
-    invocationParams(options?: this["ParsedCallOptions"]): ChatResponsesInvocationParams | ChatCompletionsInvocationParams;
-    /** @ignore */
-    _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
-    _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
-    withConfig(config: Partial<CallOptions>): Runnable<BaseLanguageModelInput, AIMessageChunk, CallOptions>;
+declare class ChatOpenAI<CallOptions extends ChatOpenAICallOptions = ChatOpenAICallOptions> extends BaseChatOpenAI<CallOptions> {
+  protected fields?: ChatOpenAIFields | undefined;
+  /**
+   * 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: boolean;
+  protected responses: ChatOpenAIResponses;
+  protected completions: ChatOpenAICompletions;
+  get lc_serializable_keys(): string[];
+  constructor(fields?: ChatOpenAIFields | undefined);
+  protected _useResponsesApi(options: this["ParsedCallOptions"] | undefined): boolean | undefined;
+  getLsParams(options: this["ParsedCallOptions"]): LangSmithParams;
+  invocationParams(options?: this["ParsedCallOptions"]): ChatCompletionsInvocationParams | ChatResponsesInvocationParams;
+  /** @ignore */
+  _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+  _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+  withConfig(config: Partial<CallOptions>): Runnable<BaseLanguageModelInput, AIMessageChunk, CallOptions>;
 }
+//#endregion
+export { BaseChatOpenAI, BaseChatOpenAICallOptions, BaseChatOpenAIFields, ChatOpenAI, ChatOpenAICallOptions, ChatOpenAICompletions, ChatOpenAICompletionsCallOptions, ChatOpenAIFields, ChatOpenAIResponses, ChatOpenAIResponsesCallOptions };
+//# sourceMappingURL=chat_models.d.ts.map