@langchain/openai 1.6.2 → 1.7.0

package/dist/converters/completions.d.ts

@@ -6,7 +6,7 @@ import { ChatCompletionContentPart, ChatCompletionContentPartImage, ChatCompleti
 /**
  * @deprecated This converter is an internal detail of the OpenAI provider. Do not use it directly. This will be revisited in a future release.
  */
-declare const completionsApiContentBlockConverter: StandardContentBlockConverter<{
+export declare const completionsApiContentBlockConverter: StandardContentBlockConverter<{
   text: ChatCompletionContentPartText;
   image: ChatCompletionContentPartImage;
   audio: ChatCompletionContentPartInputAudio;
@@ -68,7 +68,7 @@ declare const completionsApiContentBlockConverter: StandardContentBlockConverter
  *   the `invalid_tool_calls` array rather than throwing an error
  *
  */
-declare const convertCompletionsMessageToBaseMessage: Converter<{
+export declare const convertCompletionsMessageToBaseMessage: Converter<{
   message: OpenAI.Chat.Completions.ChatCompletionMessage;
   rawResponse: OpenAI.Chat.Completions.ChatCompletion;
   includeRawResponse?: boolean;
@@ -132,7 +132,7 @@ declare const convertCompletionsMessageToBaseMessage: Converter<{
  * - Response metadata includes model provider info and usage statistics
  * - Function calls and tool calls are stored in additional_kwargs for compatibility
  */
-declare const convertCompletionsDeltaToBaseMessageChunk: Converter<{
+export declare const convertCompletionsDeltaToBaseMessageChunk: Converter<{
   delta: Record<string, any>;
   rawResponse: OpenAI.Chat.Completions.ChatCompletionChunk;
   includeRawResponse?: boolean;
@@ -166,7 +166,7 @@ declare const convertCompletionsDeltaToBaseMessageChunk: Converter<{
  * // Returns: { type: "image_url", image_url: { url: "data:image/png;base64,iVBORw0KGgo..." } }
  * ```
  */
-declare const convertStandardContentBlockToCompletionsContentPart: Converter<ContentBlock.Standard, OpenAI.Chat.Completions.ChatCompletionContentPartImage | OpenAI.Chat.Completions.ChatCompletionContentPartInputAudio | OpenAI.Chat.Completions.ChatCompletionContentPart.File | undefined>;
+export declare const convertStandardContentBlockToCompletionsContentPart: Converter<ContentBlock.Standard, OpenAI.Chat.Completions.ChatCompletionContentPartImage | OpenAI.Chat.Completions.ChatCompletionContentPartInputAudio | OpenAI.Chat.Completions.ChatCompletionContentPart.File | undefined>;
 /**
  * Converts a LangChain BaseMessage with standard content blocks to an OpenAI Chat Completions API message parameter.
  *
@@ -232,7 +232,7 @@ declare const convertStandardContentBlockToCompletionsContentPart: Converter<Con
  * // }
  * ```
  */
-declare const convertStandardContentMessageToCompletionsMessage: Converter<{
+export declare const convertStandardContentMessageToCompletionsMessage: Converter<{
   message: BaseMessage;
   model?: string;
 }, OpenAI.Chat.Completions.ChatCompletionMessageParam>;
@@ -307,10 +307,9 @@ declare const convertStandardContentMessageToCompletionsMessage: Converter<{
  * // }]
  * ```
  */
-declare const convertMessagesToCompletionsMessageParams: Converter<{
+export declare const convertMessagesToCompletionsMessageParams: Converter<{
   messages: BaseMessage[];
   model?: string;
 }, OpenAI.Chat.Completions.ChatCompletionMessageParam[]>;
 //#endregion
-export { completionsApiContentBlockConverter, convertCompletionsDeltaToBaseMessageChunk, convertCompletionsMessageToBaseMessage, convertMessagesToCompletionsMessageParams, convertStandardContentBlockToCompletionsContentPart, convertStandardContentMessageToCompletionsMessage };
 //# sourceMappingURL=completions.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"completions.d.ts","names":[],"sources":["../../src/converters/completions.ts"],"mappings":";;;;;;;;cAiDa,qCAAqC;EAChD,MAAM;EACN,OAAO;EACP,OAAO;EACP,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuNrB,wCAAwC;EAEjD,SAAS,OAAa,KAAK,YAAY;EACvC,aAAa,OAAa,KAAK,YAAY;EAC3C;GAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuHW,2CAA2C;EAGpD,OAAO;EACP,aAAa,OAAa,KAAK,YAAY;EAC3C;EACA,cAAc,OAAa,KAAK;GAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiHW,qDAAqD,UAChE,aAAa,UACX,OAAa,KAAK,YAAY,iCAC9B,OAAa,KAAK,YAAY,sCAC9B,OAAa,KAAK,YAAY,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+H/C,mDAAmD;EAC5D,SAAS;EAAa;GACxB,OAAa,KAAK,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgKnB,2CAA2C;EACpD,UAAU;EAAe;GAC3B,OAAa,KAAK,YAAY"}
+{"version":3,"file":"completions.d.ts","names":["OpenAIClient"],"sources":["../../src/converters/completions.ts"],"mappings":";;;;;;;;qBAiDa,qCAAqC;EAChD,MAAM;EACN,OAAO;EACP,OAAO;EACP,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAuNrB,wCAAwC;EAEjD,SAASA,OAAa,KAAK,YAAY;EACvC,aAAaA,OAAa,KAAK,YAAY;EAC3C;GAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAuHW,2CAA2C;EAGpD,OAAO;EACP,aAAaA,OAAa,KAAK,YAAY;EAC3C;EACA,cAAcA,OAAa,KAAK;GAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAiHW,qDAAqD,UAChE,aAAa,UACXA,OAAa,KAAK,YAAY,iCAC9BA,OAAa,KAAK,YAAY,sCAC9BA,OAAa,KAAK,YAAY,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA+H/C,mDAAmD;EAC5D,SAAS;EAAa;GACxBA,OAAa,KAAK,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAgKnB,2CAA2C;EACpD,UAAU;EAAe;GAC3BA,OAAa,KAAK,YAAY"}

package/dist/converters/responses.d.cts

@@ -7,11 +7,11 @@ import { Converter } from "@langchain/core/utils/format";
 type ExcludeController<T> = T extends {
   controller: unknown;
 } ? never : T;
-type ResponsesCreate = OpenAI.Responses["create"];
-type ResponsesParse = OpenAI.Responses["parse"];
-type ResponsesCreateInvoke = ExcludeController<Awaited<ReturnType<ResponsesCreate>>>;
-type ResponsesParseInvoke = ExcludeController<Awaited<ReturnType<ResponsesParse>>>;
-type ResponsesInputItem = OpenAI.Responses.ResponseInputItem;
+export type ResponsesCreate = OpenAI.Responses["create"];
+export type ResponsesParse = OpenAI.Responses["parse"];
+export type ResponsesCreateInvoke = ExcludeController<Awaited<ReturnType<ResponsesCreate>>>;
+export type ResponsesParseInvoke = ExcludeController<Awaited<ReturnType<ResponsesParse>>>;
+export type ResponsesInputItem = OpenAI.Responses.ResponseInputItem;
 /**
  * Converts OpenAI Responses API usage statistics to LangChain's UsageMetadata format.
  *
@@ -63,7 +63,7 @@ type ResponsesInputItem = OpenAI.Responses.ResponseInputItem;
  * - This converter is specifically designed for OpenAI's Responses API format and
  *   may differ from other OpenAI API endpoints
  */
-declare const convertResponsesUsageToUsageMetadata: Converter<OpenAI.Responses.ResponseUsage | undefined, UsageMetadata>;
+export declare const convertResponsesUsageToUsageMetadata: Converter<OpenAI.Responses.ResponseUsage | undefined, UsageMetadata>;
 /**
  * Converts an OpenAI Responses API response to a LangChain AIMessage.
  *
@@ -113,7 +113,7 @@ declare const convertResponsesUsageToUsageMetadata: Converter<OpenAI.Responses.R
  * Tool calls are parsed and validated. Invalid tool calls (malformed JSON, etc.) are captured
  * in the `invalid_tool_calls` array rather than throwing errors.
  */
-declare const convertResponsesMessageToAIMessage: Converter<ResponsesCreateInvoke | ResponsesParseInvoke, AIMessage>;
+export declare const convertResponsesMessageToAIMessage: Converter<ResponsesCreateInvoke | ResponsesParseInvoke, AIMessage>;
 /**
  * Converts a LangChain ChatOpenAI reasoning summary to an OpenAI Responses API reasoning item.
  *
@@ -173,7 +173,7 @@ declare const convertResponsesMessageToAIMessage: Converter<ResponsesCreateInvok
  * - This is the inverse operation of the streaming accumulation that happens in
  *   `convertResponsesDeltaToChatGenerationChunk`
  */
-declare const convertReasoningSummaryToResponsesReasoningItem: Converter<ChatOpenAIReasoningSummary, OpenAI.Responses.ResponseReasoningItem>;
+export declare const convertReasoningSummaryToResponsesReasoningItem: Converter<ChatOpenAIReasoningSummary, OpenAI.Responses.ResponseReasoningItem>;
 /**
  * Converts OpenAI Responses API stream events to LangChain ChatGenerationChunk objects.
  *
@@ -229,7 +229,7 @@ declare const convertReasoningSummaryToResponsesReasoningItem: Converter<ChatOpe
  * - Usage metadata is only available in `response.completed` events
  * - Partial images are intentionally ignored to prevent memory bloat in conversation history
  */
-declare const convertResponsesDeltaToChatGenerationChunk: Converter<OpenAI.Responses.ResponseStreamEvent, ChatGenerationChunk | null>;
+export declare const convertResponsesDeltaToChatGenerationChunk: Converter<OpenAI.Responses.ResponseStreamEvent, ChatGenerationChunk | null>;
 /**
  * Converts a single LangChain BaseMessage to OpenAI Responses API input format.
  *
@@ -269,7 +269,7 @@ declare const convertResponsesDeltaToChatGenerationChunk: Converter<OpenAI.Respo
  * // ]
  * ```
  */
-declare const convertStandardContentMessageToResponsesInput: Converter<BaseMessage, OpenAI.Responses.ResponseInputItem[]>;
+export declare const convertStandardContentMessageToResponsesInput: Converter<BaseMessage, OpenAI.Responses.ResponseInputItem[]>;
 /**
  * - MCP (Model Context Protocol) approval responses
  * - Zero Data Retention (ZDR) mode handling
@@ -300,11 +300,10 @@ declare const convertStandardContentMessageToResponsesInput: Converter<BaseMessa
  * });
  * ```
  */
-declare const convertMessagesToResponsesInput: Converter<{
+export declare const convertMessagesToResponsesInput: Converter<{
   messages: BaseMessage[];
   zdrEnabled: boolean;
   model: string;
 }, ResponsesInputItem[]>;
 //#endregion
-export { ResponsesCreate, ResponsesCreateInvoke, ResponsesInputItem, ResponsesParse, ResponsesParseInvoke, convertMessagesToResponsesInput, convertReasoningSummaryToResponsesReasoningItem, convertResponsesDeltaToChatGenerationChunk, convertResponsesMessageToAIMessage, convertResponsesUsageToUsageMetadata, convertStandardContentMessageToResponsesInput };
 //# sourceMappingURL=responses.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"responses.d.cts","names":[],"sources":["../../src/converters/responses.ts"],"mappings":";;;;;;KA0MK,kBAAkB,KAAK;EAAY;YAAgC;KAE5D,kBAAkB,OAAa;KAC/B,iBAAiB,OAAa;KAE9B,wBAAwB,kBAClC,QAAQ,WAAW;KAET,uBAAuB,kBACjC,QAAQ,WAAW;KAGT,qBAAqB,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6F3C,sCAAsC,UACjD,OAAa,UAAU,2BACvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAyEW,oCAAoC,UAC/C,wBAAwB,sBACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuOW,iDAAiD,UAC5D,4BACA,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoFZ,4CAA4C,UACvD,OAAa,UAAU,qBACvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiZW,+CAA+C,UAC1D,aACA,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkYZ,iCAAiC;EAC1C,UAAU;EAAe;EAAqB;GAChD"}
+{"version":3,"file":"responses.d.cts","names":["OpenAIClient"],"sources":["../../src/converters/responses.ts"],"mappings":";;;;;;KA0MK,kBAAkB,KAAK;EAAY;YAAgC;YAE5D,kBAAkBA,OAAa;YAC/B,iBAAiBA,OAAa;YAE9B,wBAAwB,kBAClC,QAAQ,WAAW;YAET,uBAAuB,kBACjC,QAAQ,WAAW;YAGT,qBAAqBA,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA6F3C,sCAAsC,UACjDA,OAAa,UAAU,2BACvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAyEW,oCAAoC,UAC/C,wBAAwB,sBACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAuOW,iDAAiD,UAC5D,4BACAA,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoFZ,4CAA4C,UACvDA,OAAa,UAAU,qBACvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAiZW,+CAA+C,UAC1D,aACAA,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAkYZ,iCAAiC;EAC1C,UAAU;EAAe;EAAqB;GAChD"}

package/dist/converters/responses.d.ts

@@ -7,11 +7,11 @@ import { Converter } from "@langchain/core/utils/format";
 type ExcludeController<T> = T extends {
   controller: unknown;
 } ? never : T;
-type ResponsesCreate = OpenAI.Responses["create"];
-type ResponsesParse = OpenAI.Responses["parse"];
-type ResponsesCreateInvoke = ExcludeController<Awaited<ReturnType<ResponsesCreate>>>;
-type ResponsesParseInvoke = ExcludeController<Awaited<ReturnType<ResponsesParse>>>;
-type ResponsesInputItem = OpenAI.Responses.ResponseInputItem;
+export type ResponsesCreate = OpenAI.Responses["create"];
+export type ResponsesParse = OpenAI.Responses["parse"];
+export type ResponsesCreateInvoke = ExcludeController<Awaited<ReturnType<ResponsesCreate>>>;
+export type ResponsesParseInvoke = ExcludeController<Awaited<ReturnType<ResponsesParse>>>;
+export type ResponsesInputItem = OpenAI.Responses.ResponseInputItem;
 /**
  * Converts OpenAI Responses API usage statistics to LangChain's UsageMetadata format.
  *
@@ -63,7 +63,7 @@ type ResponsesInputItem = OpenAI.Responses.ResponseInputItem;
  * - This converter is specifically designed for OpenAI's Responses API format and
  *   may differ from other OpenAI API endpoints
  */
-declare const convertResponsesUsageToUsageMetadata: Converter<OpenAI.Responses.ResponseUsage | undefined, UsageMetadata>;
+export declare const convertResponsesUsageToUsageMetadata: Converter<OpenAI.Responses.ResponseUsage | undefined, UsageMetadata>;
 /**
  * Converts an OpenAI Responses API response to a LangChain AIMessage.
  *
@@ -113,7 +113,7 @@ declare const convertResponsesUsageToUsageMetadata: Converter<OpenAI.Responses.R
  * Tool calls are parsed and validated. Invalid tool calls (malformed JSON, etc.) are captured
  * in the `invalid_tool_calls` array rather than throwing errors.
  */
-declare const convertResponsesMessageToAIMessage: Converter<ResponsesCreateInvoke | ResponsesParseInvoke, AIMessage>;
+export declare const convertResponsesMessageToAIMessage: Converter<ResponsesCreateInvoke | ResponsesParseInvoke, AIMessage>;
 /**
  * Converts a LangChain ChatOpenAI reasoning summary to an OpenAI Responses API reasoning item.
  *
@@ -173,7 +173,7 @@ declare const convertResponsesMessageToAIMessage: Converter<ResponsesCreateInvok
  * - This is the inverse operation of the streaming accumulation that happens in
  *   `convertResponsesDeltaToChatGenerationChunk`
  */
-declare const convertReasoningSummaryToResponsesReasoningItem: Converter<ChatOpenAIReasoningSummary, OpenAI.Responses.ResponseReasoningItem>;
+export declare const convertReasoningSummaryToResponsesReasoningItem: Converter<ChatOpenAIReasoningSummary, OpenAI.Responses.ResponseReasoningItem>;
 /**
  * Converts OpenAI Responses API stream events to LangChain ChatGenerationChunk objects.
  *
@@ -229,7 +229,7 @@ declare const convertReasoningSummaryToResponsesReasoningItem: Converter<ChatOpe
  * - Usage metadata is only available in `response.completed` events
  * - Partial images are intentionally ignored to prevent memory bloat in conversation history
  */
-declare const convertResponsesDeltaToChatGenerationChunk: Converter<OpenAI.Responses.ResponseStreamEvent, ChatGenerationChunk | null>;
+export declare const convertResponsesDeltaToChatGenerationChunk: Converter<OpenAI.Responses.ResponseStreamEvent, ChatGenerationChunk | null>;
 /**
  * Converts a single LangChain BaseMessage to OpenAI Responses API input format.
  *
@@ -269,7 +269,7 @@ declare const convertResponsesDeltaToChatGenerationChunk: Converter<OpenAI.Respo
  * // ]
  * ```
  */
-declare const convertStandardContentMessageToResponsesInput: Converter<BaseMessage, OpenAI.Responses.ResponseInputItem[]>;
+export declare const convertStandardContentMessageToResponsesInput: Converter<BaseMessage, OpenAI.Responses.ResponseInputItem[]>;
 /**
  * - MCP (Model Context Protocol) approval responses
  * - Zero Data Retention (ZDR) mode handling
@@ -300,11 +300,10 @@ declare const convertStandardContentMessageToResponsesInput: Converter<BaseMessa
  * });
  * ```
  */
-declare const convertMessagesToResponsesInput: Converter<{
+export declare const convertMessagesToResponsesInput: Converter<{
   messages: BaseMessage[];
   zdrEnabled: boolean;
   model: string;
 }, ResponsesInputItem[]>;
 //#endregion
-export { ResponsesCreate, ResponsesCreateInvoke, ResponsesInputItem, ResponsesParse, ResponsesParseInvoke, convertMessagesToResponsesInput, convertReasoningSummaryToResponsesReasoningItem, convertResponsesDeltaToChatGenerationChunk, convertResponsesMessageToAIMessage, convertResponsesUsageToUsageMetadata, convertStandardContentMessageToResponsesInput };
 //# sourceMappingURL=responses.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"responses.d.ts","names":[],"sources":["../../src/converters/responses.ts"],"mappings":";;;;;;KA0MK,kBAAkB,KAAK;EAAY;YAAgC;KAE5D,kBAAkB,OAAa;KAC/B,iBAAiB,OAAa;KAE9B,wBAAwB,kBAClC,QAAQ,WAAW;KAET,uBAAuB,kBACjC,QAAQ,WAAW;KAGT,qBAAqB,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6F3C,sCAAsC,UACjD,OAAa,UAAU,2BACvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAyEW,oCAAoC,UAC/C,wBAAwB,sBACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuOW,iDAAiD,UAC5D,4BACA,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoFZ,4CAA4C,UACvD,OAAa,UAAU,qBACvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiZW,+CAA+C,UAC1D,aACA,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkYZ,iCAAiC;EAC1C,UAAU;EAAe;EAAqB;GAChD"}
+{"version":3,"file":"responses.d.ts","names":["OpenAIClient"],"sources":["../../src/converters/responses.ts"],"mappings":";;;;;;KA0MK,kBAAkB,KAAK;EAAY;YAAgC;YAE5D,kBAAkBA,OAAa;YAC/B,iBAAiBA,OAAa;YAE9B,wBAAwB,kBAClC,QAAQ,WAAW;YAET,uBAAuB,kBACjC,QAAQ,WAAW;YAGT,qBAAqBA,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA6F3C,sCAAsC,UACjDA,OAAa,UAAU,2BACvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAyEW,oCAAoC,UAC/C,wBAAwB,sBACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAuOW,iDAAiD,UAC5D,4BACAA,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoFZ,4CAA4C,UACvDA,OAAa,UAAU,qBACvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAiZW,+CAA+C,UAC1D,aACAA,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAkYZ,iCAAiC;EAC1C,UAAU;EAAe;EAAqB;GAChD"}

package/dist/embeddings.d.cts

@@ -5,12 +5,12 @@ import { Embeddings, EmbeddingsParams } from "@langchain/core/embeddings";
 /**
  * @see https://platform.openai.com/docs/guides/embeddings#embedding-models
  */
-type OpenAIEmbeddingModelId = OpenAI.EmbeddingModel | (string & NonNullable<unknown>);
+export type OpenAIEmbeddingModelId = OpenAI.EmbeddingModel | (string & NonNullable<unknown>);
 /**
  * Interface for OpenAIEmbeddings parameters. Extends EmbeddingsParams and
  * defines additional parameters specific to the OpenAIEmbeddings class.
  */
-interface OpenAIEmbeddingsParams extends EmbeddingsParams {
+export interface OpenAIEmbeddingsParams extends EmbeddingsParams {
   /**
    * Model name to use
    * Alias for `model`
@@ -60,7 +60,7 @@ interface OpenAIEmbeddingsParams extends EmbeddingsParams {
  *
  * ```
  */
-declare class OpenAIEmbeddings<TOutput = number[]> extends Embeddings<TOutput> implements Partial<OpenAIEmbeddingsParams> {
+export declare class OpenAIEmbeddings<TOutput = number[]> extends Embeddings<TOutput> implements Partial<OpenAIEmbeddingsParams> {
   model: string;
   /** @deprecated Use "model" instead */
   modelName: string;
@@ -115,5 +115,4 @@ declare class OpenAIEmbeddings<TOutput = number[]> extends Embeddings<TOutput> i
   }>;
 }
 //#endregion
-export { OpenAIEmbeddingModelId, OpenAIEmbeddings, OpenAIEmbeddingsParams };
 //# sourceMappingURL=embeddings.d.cts.map

package/dist/embeddings.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"embeddings.d.cts","names":[],"sources":["../src/embeddings.ts"],"mappings":";;;;;;;KAeY,yBACR,OAAa,2BACH;;;;;UAMG,+BAA+B;;;;;;EAM9C,WAAW;;EAEX,OAAO;;;;;EAMP;;;;EAKA;;;;;EAMA;;;;;;EAOA;;;;EAKA;;;;;;;;;;;;;;;;;;cAmBW,iBAAiB,4BACpB,WAAW,oBACR,QAAQ;EAEnB;;EAGA;EAEA;EAGA;;;;;EAMA;EAEA;EAEA;EAEA;YAEU,QAAQ;YAER,cAAc;YAEd,SAAS;EAEnB,YACE,SAAS,QAAQ;IACf;;;;;IAKA,eAAe;;IAEf,SAAS;IACT,gBAAgB;;;;;;;;;EAyCd,eAAe,kBAAkB,QAAQ;;;;;;;EAsCzC,WAAW,eAAe,QAAQ;;;;;;;;YAsBxB,mBACd,SAAS,OAAa,wBAAqB,QAAA,OAAA"}
+{"version":3,"file":"embeddings.d.cts","names":["OpenAIClient"],"sources":["../src/embeddings.ts"],"mappings":";;;;;;;YAeY,yBACRA,OAAa,2BACH;;;;;iBAMG,+BAA+B;;;;;;EAM9C,WAAW;;EAEX,OAAO;;;;;EAMP;;;;EAKA;;;;;EAMA;;;;;;EAOA;;;;EAKA;;;;;;;;;;;;;;;;;;qBAmBW,iBAAiB,4BACpB,WAAW,oBACR,QAAQ;EAEnB;;EAGA;EAEA;EAGA;;;;;EAMA;EAEA;EAEA;EAEA;YAEU,QAAQA;YAER,cAAc;YAEd,SAAS;EAEnB,YACE,SAAS,QAAQ;IACf;;;;;IAKA,eAAe;;IAEf,SAAS;IACT,gBAAgB;;;;;;;;;EAyCd,eAAe,kBAAkB,QAAQ;;;;;;;EAsCzC,WAAW,eAAe,QAAQ;;;;;;;;YAsBxB,mBACd,SAASA,OAAa,wBAAqB,QAAAA,OAAA"}

package/dist/embeddings.d.ts

@@ -5,12 +5,12 @@ import { Embeddings, EmbeddingsParams } from "@langchain/core/embeddings";
 /**
  * @see https://platform.openai.com/docs/guides/embeddings#embedding-models
  */
-type OpenAIEmbeddingModelId = OpenAI.EmbeddingModel | (string & NonNullable<unknown>);
+export type OpenAIEmbeddingModelId = OpenAI.EmbeddingModel | (string & NonNullable<unknown>);
 /**
  * Interface for OpenAIEmbeddings parameters. Extends EmbeddingsParams and
  * defines additional parameters specific to the OpenAIEmbeddings class.
  */
-interface OpenAIEmbeddingsParams extends EmbeddingsParams {
+export interface OpenAIEmbeddingsParams extends EmbeddingsParams {
   /**
    * Model name to use
    * Alias for `model`
@@ -60,7 +60,7 @@ interface OpenAIEmbeddingsParams extends EmbeddingsParams {
  *
  * ```
  */
-declare class OpenAIEmbeddings<TOutput = number[]> extends Embeddings<TOutput> implements Partial<OpenAIEmbeddingsParams> {
+export declare class OpenAIEmbeddings<TOutput = number[]> extends Embeddings<TOutput> implements Partial<OpenAIEmbeddingsParams> {
   model: string;
   /** @deprecated Use "model" instead */
   modelName: string;
@@ -115,5 +115,4 @@ declare class OpenAIEmbeddings<TOutput = number[]> extends Embeddings<TOutput> i
   }>;
 }
 //#endregion
-export { OpenAIEmbeddingModelId, OpenAIEmbeddings, OpenAIEmbeddingsParams };
 //# sourceMappingURL=embeddings.d.ts.map

package/dist/embeddings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"embeddings.d.ts","names":[],"sources":["../src/embeddings.ts"],"mappings":";;;;;;;KAeY,yBACR,OAAa,2BACH;;;;;UAMG,+BAA+B;;;;;;EAM9C,WAAW;;EAEX,OAAO;;;;;EAMP;;;;EAKA;;;;;EAMA;;;;;;EAOA;;;;EAKA;;;;;;;;;;;;;;;;;;cAmBW,iBAAiB,4BACpB,WAAW,oBACR,QAAQ;EAEnB;;EAGA;EAEA;EAGA;;;;;EAMA;EAEA;EAEA;EAEA;YAEU,QAAQ;YAER,cAAc;YAEd,SAAS;EAEnB,YACE,SAAS,QAAQ;IACf;;;;;IAKA,eAAe;;IAEf,SAAS;IACT,gBAAgB;;;;;;;;;EAyCd,eAAe,kBAAkB,QAAQ;;;;;;;EAsCzC,WAAW,eAAe,QAAQ;;;;;;;;YAsBxB,mBACd,SAAS,OAAa,wBAAqB,QAAA,OAAA"}
+{"version":3,"file":"embeddings.d.ts","names":["OpenAIClient"],"sources":["../src/embeddings.ts"],"mappings":";;;;;;;YAeY,yBACRA,OAAa,2BACH;;;;;iBAMG,+BAA+B;;;;;;EAM9C,WAAW;;EAEX,OAAO;;;;;EAMP;;;;EAKA;;;;;EAMA;;;;;;EAOA;;;;EAKA;;;;;;;;;;;;;;;;;;qBAmBW,iBAAiB,4BACpB,WAAW,oBACR,QAAQ;EAEnB;;EAGA;EAEA;EAGA;;;;;EAMA;EAEA;EAEA;EAEA;YAEU,QAAQA;YAER,cAAc;YAEd,SAAS;EAEnB,YACE,SAAS,QAAQ;IACf;;;;;IAKA,eAAe;;IAEf,SAAS;IACT,gBAAgB;;;;;;;;;EAyCd,eAAe,kBAAkB,QAAQ;;;;;;;EAsCzC,WAAW,eAAe,QAAQ;;;;;;;;YAsBxB,mBACd,SAASA,OAAa,wBAAqB,QAAAA,OAAA"}

package/dist/llms.cjs

@@ -82,7 +82,7 @@ var OpenAI = class extends _langchain_core_language_models_llms.BaseLLM {
 	clientConfig;
 	constructor(fields) {
 		super(fields ?? {});
-		this._addVersion("@langchain/openai", "1.6.2");
+		this._addVersion("@langchain/openai", "1.7.0");
 		this.openAIApiKey = fields?.apiKey ?? fields?.openAIApiKey ?? (0, _langchain_core_utils_env.getEnvironmentVariable)("OPENAI_API_KEY");
 		this.apiKey = this.openAIApiKey;
 		this.organization = fields?.configuration?.organization ?? (0, _langchain_core_utils_env.getEnvironmentVariable)("OPENAI_ORGANIZATION");

package/dist/llms.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"llms.d.cts","names":[],"sources":["../src/llms.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+Da,SAAO,oBAAoB,oBAAoB,2BAClD,QAAQ,wBACL,QAAQ;SAEZ;MAIH;EAIJ;MAEI;KAAiB;;MAQjB,cAAc;EAQlB;EAEA;EAEA;EAEA;EAEA;EAEA;EAEA;EAEA,YAAY;EAEZ;;EAGA;EAEA,cAAc;EAEd;EAEA;EAEA;EAEA;EAEA;EAEA;EAEA,eAAe;EAEf,SAAS;EAET;YAEU,QAAQ;YAER,cAAc;EAExB,YACE,SAAS,QAAQ,eACf;IACE,gBAAgB;;;;;EAqEtB,iBACE,sCACC,KAAK,OAAa;;EAmBrB,sBAAsB,KAAK,OAAa;IACtC;MACE;;;;EAWJ,qBAAqB,KAAK,OAAa;IACrC;MACE;;;;;;;;;;;;;;;;;EAoBE,UACJ,mBACA,oCACA,aAAa,2BACZ,QAAQ;EA0HJ,sBACL,eACA,oCACA,aAAa,2BACZ,eAAe;;;;;;;EAiCZ,oBACJ,SAAS,OAAa,iCACtB,UAAU,2BACT,QAAQ,cAAc,OAAa;EAEhC,oBACJ,SAAS,OAAa,oCACtB,UAAU,2BACT,QAAQ,OAAa,YAAY;;;;;;;YAkC1B,kBACR,SAAS,uCACR;EA8BH"}
+{"version":3,"file":"llms.d.cts","names":["OpenAI","OpenAIClient"],"sources":["../src/llms.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+DaA,SAAO,oBAAoB,oBAAoB,2BAClD,QAAQ,wBACL,QAAQ;SAEZ;MAIH;EAIJ;MAEI;KAAiB;;MAQjB,cAAc;EAQlB;EAEA;EAEA;EAEA;EAEA;EAEA;EAEA;EAEA,YAAY;EAEZ;;EAGA;EAEA,cAAc;EAEd;EAEA;EAEA;EAEA;EAEA;EAEA;EAEA,eAAe;EAEf,SAAS;EAET;YAEU,QAAQC;YAER,cAAc;EAExB,YACE,SAAS,QAAQ,eACf;IACE,gBAAgB;;;;;EAqEtB,iBACE,sCACC,KAAKA,OAAa;;EAmBrB,sBAAsB,KAAKA,OAAa;IACtC;MACE;;;;EAWJ,qBAAqB,KAAKA,OAAa;IACrC;MACE;;;;;;;;;;;;;;;;;EAoBE,UACJ,mBACA,oCACA,aAAa,2BACZ,QAAQ;EA0HJ,sBACL,eACA,oCACA,aAAa,2BACZ,eAAe;;;;;;;EAiCZ,oBACJ,SAASA,OAAa,iCACtB,UAAU,2BACT,QAAQ,cAAcA,OAAa;EAEhC,oBACJ,SAASA,OAAa,oCACtB,UAAU,2BACT,QAAQA,OAAa,YAAY;;;;;;;YAkC1B,kBACR,SAAS,uCACR;EA8BH"}

package/dist/llms.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"llms.d.ts","names":[],"sources":["../src/llms.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+Da,SAAO,oBAAoB,oBAAoB,2BAClD,QAAQ,wBACL,QAAQ;SAEZ;MAIH;EAIJ;MAEI;KAAiB;;MAQjB,cAAc;EAQlB;EAEA;EAEA;EAEA;EAEA;EAEA;EAEA;EAEA,YAAY;EAEZ;;EAGA;EAEA,cAAc;EAEd;EAEA;EAEA;EAEA;EAEA;EAEA;EAEA,eAAe;EAEf,SAAS;EAET;YAEU,QAAQ;YAER,cAAc;EAExB,YACE,SAAS,QAAQ,eACf;IACE,gBAAgB;;;;;EAqEtB,iBACE,sCACC,KAAK,OAAa;;EAmBrB,sBAAsB,KAAK,OAAa;IACtC;MACE;;;;EAWJ,qBAAqB,KAAK,OAAa;IACrC;MACE;;;;;;;;;;;;;;;;;EAoBE,UACJ,mBACA,oCACA,aAAa,2BACZ,QAAQ;EA0HJ,sBACL,eACA,oCACA,aAAa,2BACZ,eAAe;;;;;;;EAiCZ,oBACJ,SAAS,OAAa,iCACtB,UAAU,2BACT,QAAQ,cAAc,OAAa;EAEhC,oBACJ,SAAS,OAAa,oCACtB,UAAU,2BACT,QAAQ,OAAa,YAAY;;;;;;;YAkC1B,kBACR,SAAS,uCACR;EA8BH"}
+{"version":3,"file":"llms.d.ts","names":["OpenAI","OpenAIClient"],"sources":["../src/llms.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+DaA,SAAO,oBAAoB,oBAAoB,2BAClD,QAAQ,wBACL,QAAQ;SAEZ;MAIH;EAIJ;MAEI;KAAiB;;MAQjB,cAAc;EAQlB;EAEA;EAEA;EAEA;EAEA;EAEA;EAEA;EAEA,YAAY;EAEZ;;EAGA;EAEA,cAAc;EAEd;EAEA;EAEA;EAEA;EAEA;EAEA;EAEA,eAAe;EAEf,SAAS;EAET;YAEU,QAAQC;YAER,cAAc;EAExB,YACE,SAAS,QAAQ,eACf;IACE,gBAAgB;;;;;EAqEtB,iBACE,sCACC,KAAKA,OAAa;;EAmBrB,sBAAsB,KAAKA,OAAa;IACtC;MACE;;;;EAWJ,qBAAqB,KAAKA,OAAa;IACrC;MACE;;;;;;;;;;;;;;;;;EAoBE,UACJ,mBACA,oCACA,aAAa,2BACZ,QAAQ;EA0HJ,sBACL,eACA,oCACA,aAAa,2BACZ,eAAe;;;;;;;EAiCZ,oBACJ,SAASA,OAAa,iCACtB,UAAU,2BACT,QAAQ,cAAcA,OAAa;EAEhC,oBACJ,SAASA,OAAa,oCACtB,UAAU,2BACT,QAAQA,OAAa,YAAY;;;;;;;YAkC1B,kBACR,SAAS,uCACR;EA8BH"}

package/dist/llms.js

@@ -82,7 +82,7 @@ var OpenAI$2 = class extends BaseLLM {
 	clientConfig;
 	constructor(fields) {
 		super(fields ?? {});
-		this._addVersion("@langchain/openai", "1.6.2");
+		this._addVersion("@langchain/openai", "1.7.0");
 		this.openAIApiKey = fields?.apiKey ?? fields?.openAIApiKey ?? getEnvironmentVariable("OPENAI_API_KEY");
 		this.apiKey = this.openAIApiKey;
 		this.organization = fields?.configuration?.organization ?? getEnvironmentVariable("OPENAI_ORGANIZATION");

package/dist/tools/applyPatch.d.cts

@@ -5,14 +5,14 @@ import { z } from "zod/v4";
 /**
  * Re-export operation types from OpenAI SDK for convenience.
  */
-type ApplyPatchCreateFileOperation = OpenAI.Responses.ResponseApplyPatchToolCall.CreateFile;
-type ApplyPatchUpdateFileOperation = OpenAI.Responses.ResponseApplyPatchToolCall.UpdateFile;
-type ApplyPatchDeleteFileOperation = OpenAI.Responses.ResponseApplyPatchToolCall.DeleteFile;
+export type ApplyPatchCreateFileOperation = OpenAI.Responses.ResponseApplyPatchToolCall.CreateFile;
+export type ApplyPatchUpdateFileOperation = OpenAI.Responses.ResponseApplyPatchToolCall.UpdateFile;
+export type ApplyPatchDeleteFileOperation = OpenAI.Responses.ResponseApplyPatchToolCall.DeleteFile;
 /**
  * Union type of all apply patch operations from OpenAI SDK.
  */
-type ApplyPatchOperation = NonNullable<OpenAI.Responses.ResponseApplyPatchToolCall["operation"]>;
-declare const ApplyPatchOperationSchema: z.ZodUnion<readonly [z.ZodObject<{
+export type ApplyPatchOperation = NonNullable<OpenAI.Responses.ResponseApplyPatchToolCall["operation"]>;
+export declare const ApplyPatchOperationSchema: z.ZodUnion<readonly [z.ZodObject<{
   type: z.ZodLiteral<"create_file">;
   path: z.ZodString;
   diff: z.ZodString;
@@ -27,7 +27,7 @@ declare const ApplyPatchOperationSchema: z.ZodUnion<readonly [z.ZodObject<{
 /**
  * Options for the Apply Patch tool.
  */
-interface ApplyPatchOptions {
+export interface ApplyPatchOptions {
   /**
    * Execute function that handles patch operations.
    * This function receives the operation input and should return a string
@@ -65,7 +65,7 @@ interface ApplyPatchOptions {
 /**
  * OpenAI Apply Patch tool type for the Responses API.
  */
-type ApplyPatchTool = OpenAI.Responses.ApplyPatchTool;
+export type ApplyPatchTool = OpenAI.Responses.ApplyPatchTool;
 /**
  * Creates an Apply Patch tool that allows models to propose structured diffs
  * that your integration applies. This enables iterative, multi-step code
@@ -141,7 +141,6 @@ type ApplyPatchTool = OpenAI.Responses.ApplyPatchTool;
  * - Consider backing up files before applying patches
  * - Implement "all-or-nothing" semantics if atomicity is required
  */
-declare function applyPatch(options: ApplyPatchOptions): DynamicStructuredTool<typeof ApplyPatchOperationSchema, ApplyPatchOperation, unknown, string>;
+export declare function applyPatch(options: ApplyPatchOptions): DynamicStructuredTool<typeof ApplyPatchOperationSchema, ApplyPatchOperation, unknown, string>;
 //#endregion
-export { ApplyPatchCreateFileOperation, ApplyPatchDeleteFileOperation, ApplyPatchOperation, ApplyPatchOperationSchema, ApplyPatchOptions, ApplyPatchTool, ApplyPatchUpdateFileOperation, applyPatch };
 //# sourceMappingURL=applyPatch.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"applyPatch.d.cts","names":[],"sources":["../../src/tools/applyPatch.ts"],"mappings":";;;;;;;KAOY,gCACV,OAAa,UAAU,2BAA2B;KACxC,gCACV,OAAa,UAAU,2BAA2B;KACxC,gCACV,OAAa,UAAU,2BAA2B;;;;KAKxC,sBAAsB,YAChC,OAAa,UAAU;cAsBZ,2BAAyB,EAAA,mBAAA,EAAA;;;;;;;;;;;GAIpC,EAAA,KAAA;;;;UAKe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCf,UAAU,WAAW,iCAAiC;;;;;KAM5C,iBAAiB,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+EpC,WAAW,SAAS,oBAed,6BACX,2BACP"}
+{"version":3,"file":"applyPatch.d.cts","names":["OpenAIClient"],"sources":["../../src/tools/applyPatch.ts"],"mappings":";;;;;;;YAOY,gCACVA,OAAa,UAAU,2BAA2B;YACxC,gCACVA,OAAa,UAAU,2BAA2B;YACxC,gCACVA,OAAa,UAAU,2BAA2B;;;;YAKxC,sBAAsB,YAChCA,OAAa,UAAU;qBAsBZ,2BAAyB,EAAA,mBAAA,EAAA;;;;;;;;;;;GAIpC,EAAA,KAAA;;;;iBAKe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCf,UAAU,WAAW,iCAAiC;;;;;YAM5C,iBAAiBA,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA+EpC,WAAW,SAAS,oBAed,6BACX,2BACP"}

package/dist/tools/applyPatch.d.ts

@@ -5,14 +5,14 @@ import { z } from "zod/v4";
 /**
  * Re-export operation types from OpenAI SDK for convenience.
  */
-type ApplyPatchCreateFileOperation = OpenAI.Responses.ResponseApplyPatchToolCall.CreateFile;
-type ApplyPatchUpdateFileOperation = OpenAI.Responses.ResponseApplyPatchToolCall.UpdateFile;
-type ApplyPatchDeleteFileOperation = OpenAI.Responses.ResponseApplyPatchToolCall.DeleteFile;
+export type ApplyPatchCreateFileOperation = OpenAI.Responses.ResponseApplyPatchToolCall.CreateFile;
+export type ApplyPatchUpdateFileOperation = OpenAI.Responses.ResponseApplyPatchToolCall.UpdateFile;
+export type ApplyPatchDeleteFileOperation = OpenAI.Responses.ResponseApplyPatchToolCall.DeleteFile;
 /**
  * Union type of all apply patch operations from OpenAI SDK.
  */
-type ApplyPatchOperation = NonNullable<OpenAI.Responses.ResponseApplyPatchToolCall["operation"]>;
-declare const ApplyPatchOperationSchema: z.ZodUnion<readonly [z.ZodObject<{
+export type ApplyPatchOperation = NonNullable<OpenAI.Responses.ResponseApplyPatchToolCall["operation"]>;
+export declare const ApplyPatchOperationSchema: z.ZodUnion<readonly [z.ZodObject<{
   type: z.ZodLiteral<"create_file">;
   path: z.ZodString;
   diff: z.ZodString;
@@ -27,7 +27,7 @@ declare const ApplyPatchOperationSchema: z.ZodUnion<readonly [z.ZodObject<{
 /**
  * Options for the Apply Patch tool.
  */
-interface ApplyPatchOptions {
+export interface ApplyPatchOptions {
   /**
    * Execute function that handles patch operations.
    * This function receives the operation input and should return a string
@@ -65,7 +65,7 @@ interface ApplyPatchOptions {
 /**
  * OpenAI Apply Patch tool type for the Responses API.
  */
-type ApplyPatchTool = OpenAI.Responses.ApplyPatchTool;
+export type ApplyPatchTool = OpenAI.Responses.ApplyPatchTool;
 /**
  * Creates an Apply Patch tool that allows models to propose structured diffs
  * that your integration applies. This enables iterative, multi-step code
@@ -141,7 +141,6 @@ type ApplyPatchTool = OpenAI.Responses.ApplyPatchTool;
  * - Consider backing up files before applying patches
  * - Implement "all-or-nothing" semantics if atomicity is required
  */
-declare function applyPatch(options: ApplyPatchOptions): DynamicStructuredTool<typeof ApplyPatchOperationSchema, ApplyPatchOperation, unknown, string>;
+export declare function applyPatch(options: ApplyPatchOptions): DynamicStructuredTool<typeof ApplyPatchOperationSchema, ApplyPatchOperation, unknown, string>;
 //#endregion
-export { ApplyPatchCreateFileOperation, ApplyPatchDeleteFileOperation, ApplyPatchOperation, ApplyPatchOperationSchema, ApplyPatchOptions, ApplyPatchTool, ApplyPatchUpdateFileOperation, applyPatch };
 //# sourceMappingURL=applyPatch.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"applyPatch.d.ts","names":[],"sources":["../../src/tools/applyPatch.ts"],"mappings":";;;;;;;KAOY,gCACV,OAAa,UAAU,2BAA2B;KACxC,gCACV,OAAa,UAAU,2BAA2B;KACxC,gCACV,OAAa,UAAU,2BAA2B;;;;KAKxC,sBAAsB,YAChC,OAAa,UAAU;cAsBZ,2BAAyB,EAAA,mBAAA,EAAA;;;;;;;;;;;GAIpC,EAAA,KAAA;;;;UAKe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCf,UAAU,WAAW,iCAAiC;;;;;KAM5C,iBAAiB,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+EpC,WAAW,SAAS,oBAed,6BACX,2BACP"}
+{"version":3,"file":"applyPatch.d.ts","names":["OpenAIClient"],"sources":["../../src/tools/applyPatch.ts"],"mappings":";;;;;;;YAOY,gCACVA,OAAa,UAAU,2BAA2B;YACxC,gCACVA,OAAa,UAAU,2BAA2B;YACxC,gCACVA,OAAa,UAAU,2BAA2B;;;;YAKxC,sBAAsB,YAChCA,OAAa,UAAU;qBAsBZ,2BAAyB,EAAA,mBAAA,EAAA;;;;;;;;;;;GAIpC,EAAA,KAAA;;;;iBAKe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCf,UAAU,WAAW,iCAAiC;;;;;YAM5C,iBAAiBA,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA+EpC,WAAW,SAAS,oBAed,6BACX,2BACP"}

package/dist/tools/codeInterpreter.d.cts

@@ -5,12 +5,12 @@ import { ServerTool } from "@langchain/core/tools";
  * Memory limit options for the Code Interpreter container.
  * Higher tiers offer more RAM and are billed at different rates.
  */
-type CodeInterpreterMemoryLimit = "1g" | "4g" | "16g" | "64g";
+export type CodeInterpreterMemoryLimit = "1g" | "4g" | "16g" | "64g";
 /**
  * Auto container configuration for Code Interpreter.
  * Creates a new container automatically or reuses an active one.
  */
-interface CodeInterpreterAutoContainer {
+export interface CodeInterpreterAutoContainer {
   /**
    * Memory limit for the container.
    * - `"1g"` (default): 1 GB RAM
@@ -29,7 +29,7 @@ interface CodeInterpreterAutoContainer {
 /**
  * Options for the Code Interpreter tool.
  */
-interface CodeInterpreterOptions {
+export interface CodeInterpreterOptions {
   /**
    * The container configuration for the Code Interpreter.
    *
@@ -44,7 +44,7 @@ interface CodeInterpreterOptions {
 /**
  * OpenAI Code Interpreter tool type for the Responses API.
  */
-type CodeInterpreterTool = OpenAI.Responses.Tool.CodeInterpreter;
+export type CodeInterpreterTool = OpenAI.Responses.Tool.CodeInterpreter;
 /**
  * Creates a Code Interpreter tool that allows models to write and run Python code
  * in a sandboxed environment to solve complex problems.
@@ -117,7 +117,6 @@ type CodeInterpreterTool = OpenAI.Responses.Tool.CodeInterpreter;
  * - Files in model input are automatically uploaded to the container
  * - Generated files are returned as `container_file_citation` annotations
  */
-declare function codeInterpreter(options?: CodeInterpreterOptions): ServerTool;
+export declare function codeInterpreter(options?: CodeInterpreterOptions): ServerTool;
 //#endregion
-export { CodeInterpreterAutoContainer, CodeInterpreterMemoryLimit, CodeInterpreterOptions, CodeInterpreterTool, codeInterpreter };
 //# sourceMappingURL=codeInterpreter.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"codeInterpreter.d.cts","names":[],"sources":["../../src/tools/codeInterpreter.ts"],"mappings":";;;;;;;KAOY;;;;;UAMK;;;;;;;;EAQf,cAAc;;;;;;EAMd;;;;;UAMe;;;;;;;;;;EAUf,qBAAqB;;;;;KAMX,sBAAsB,OAAa,UAAU,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+F9C,gBAAgB,UAAU,yBAAyB"}
+{"version":3,"file":"codeInterpreter.d.cts","names":["OpenAIClient"],"sources":["../../src/tools/codeInterpreter.ts"],"mappings":";;;;;;;YAOY;;;;;iBAMK;;;;;;;;EAQf,cAAc;;;;;;EAMd;;;;;iBAMe;;;;;;;;;;EAUf,qBAAqB;;;;;YAMX,sBAAsBA,OAAa,UAAU,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA+F9C,gBAAgB,UAAU,yBAAyB"}

package/dist/tools/codeInterpreter.d.ts

@@ -5,12 +5,12 @@ import { ServerTool } from "@langchain/core/tools";
  * Memory limit options for the Code Interpreter container.
  * Higher tiers offer more RAM and are billed at different rates.
  */
-type CodeInterpreterMemoryLimit = "1g" | "4g" | "16g" | "64g";
+export type CodeInterpreterMemoryLimit = "1g" | "4g" | "16g" | "64g";
 /**
  * Auto container configuration for Code Interpreter.
  * Creates a new container automatically or reuses an active one.
  */
-interface CodeInterpreterAutoContainer {
+export interface CodeInterpreterAutoContainer {
   /**
    * Memory limit for the container.
    * - `"1g"` (default): 1 GB RAM
@@ -29,7 +29,7 @@ interface CodeInterpreterAutoContainer {
 /**
  * Options for the Code Interpreter tool.
  */
-interface CodeInterpreterOptions {
+export interface CodeInterpreterOptions {
   /**
    * The container configuration for the Code Interpreter.
    *
@@ -44,7 +44,7 @@ interface CodeInterpreterOptions {
 /**
  * OpenAI Code Interpreter tool type for the Responses API.
  */
-type CodeInterpreterTool = OpenAI.Responses.Tool.CodeInterpreter;
+export type CodeInterpreterTool = OpenAI.Responses.Tool.CodeInterpreter;
 /**
  * Creates a Code Interpreter tool that allows models to write and run Python code
  * in a sandboxed environment to solve complex problems.
@@ -117,7 +117,6 @@ type CodeInterpreterTool = OpenAI.Responses.Tool.CodeInterpreter;
  * - Files in model input are automatically uploaded to the container
  * - Generated files are returned as `container_file_citation` annotations
  */
-declare function codeInterpreter(options?: CodeInterpreterOptions): ServerTool;
+export declare function codeInterpreter(options?: CodeInterpreterOptions): ServerTool;
 //#endregion
-export { CodeInterpreterAutoContainer, CodeInterpreterMemoryLimit, CodeInterpreterOptions, CodeInterpreterTool, codeInterpreter };
 //# sourceMappingURL=codeInterpreter.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"codeInterpreter.d.ts","names":[],"sources":["../../src/tools/codeInterpreter.ts"],"mappings":";;;;;;;KAOY;;;;;UAMK;;;;;;;;EAQf,cAAc;;;;;;EAMd;;;;;UAMe;;;;;;;;;;EAUf,qBAAqB;;;;;KAMX,sBAAsB,OAAa,UAAU,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+F9C,gBAAgB,UAAU,yBAAyB"}
+{"version":3,"file":"codeInterpreter.d.ts","names":["OpenAIClient"],"sources":["../../src/tools/codeInterpreter.ts"],"mappings":";;;;;;;YAOY;;;;;iBAMK;;;;;;;;EAQf,cAAc;;;;;;EAMd;;;;;iBAMe;;;;;;;;;;EAUf,qBAAqB;;;;;YAMX,sBAAsBA,OAAa,UAAU,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA+F9C,gBAAgB,UAAU,yBAAyB"}

package/dist/tools/computerUse.d.cts

@@ -6,24 +6,24 @@ import { z } from "zod/v4";
 /**
  * The type of computer environment to control.
  */
-type ComputerUseEnvironment = "browser" | "mac" | "windows" | "linux" | "ubuntu";
+export type ComputerUseEnvironment = "browser" | "mac" | "windows" | "linux" | "ubuntu";
 /**
  * Re-export action types from OpenAI SDK for convenience.
  */
-type ComputerUseClickAction = OpenAI.Responses.ResponseComputerToolCall.Click;
-type ComputerUseDoubleClickAction = OpenAI.Responses.ResponseComputerToolCall.DoubleClick;
-type ComputerUseDragAction = OpenAI.Responses.ResponseComputerToolCall.Drag;
-type ComputerUseKeypressAction = OpenAI.Responses.ResponseComputerToolCall.Keypress;
-type ComputerUseMoveAction = OpenAI.Responses.ResponseComputerToolCall.Move;
-type ComputerUseScreenshotAction = OpenAI.Responses.ResponseComputerToolCall.Screenshot;
-type ComputerUseScrollAction = OpenAI.Responses.ResponseComputerToolCall.Scroll;
-type ComputerUseTypeAction = OpenAI.Responses.ResponseComputerToolCall.Type;
-type ComputerUseWaitAction = OpenAI.Responses.ResponseComputerToolCall.Wait;
+export type ComputerUseClickAction = OpenAI.Responses.ResponseComputerToolCall.Click;
+export type ComputerUseDoubleClickAction = OpenAI.Responses.ResponseComputerToolCall.DoubleClick;
+export type ComputerUseDragAction = OpenAI.Responses.ResponseComputerToolCall.Drag;
+export type ComputerUseKeypressAction = OpenAI.Responses.ResponseComputerToolCall.Keypress;
+export type ComputerUseMoveAction = OpenAI.Responses.ResponseComputerToolCall.Move;
+export type ComputerUseScreenshotAction = OpenAI.Responses.ResponseComputerToolCall.Screenshot;
+export type ComputerUseScrollAction = OpenAI.Responses.ResponseComputerToolCall.Scroll;
+export type ComputerUseTypeAction = OpenAI.Responses.ResponseComputerToolCall.Type;
+export type ComputerUseWaitAction = OpenAI.Responses.ResponseComputerToolCall.Wait;
 /**
  * Union type of all computer use actions from OpenAI SDK.
  */
-type ComputerUseAction = OpenAI.Responses.ResponseComputerToolCall["action"];
-declare const ComputerUseActionSchema: z.ZodObject<{
+export type ComputerUseAction = OpenAI.Responses.ResponseComputerToolCall["action"];
+export declare const ComputerUseActionSchema: z.ZodObject<{
   action: z.ZodUnion<readonly [z.ZodObject<{
     type: z.ZodLiteral<"screenshot">;
   }, z.core.$strip>, z.ZodObject<{
@@ -79,14 +79,14 @@ declare const ComputerUseActionSchema: z.ZodObject<{
  * Input structure for the Computer Use tool.
  * The action is wrapped in an `action` property.
  */
-interface ComputerUseInput {
+export interface ComputerUseInput {
   action: ComputerUseAction;
 }
-type ComputerUseReturnType = string | Promise<string> | ToolMessage<any> | Promise<ToolMessage<any>>;
+export type ComputerUseReturnType = string | Promise<string> | ToolMessage<any> | Promise<ToolMessage<any>>;
 /**
  * Options for the Computer Use tool.
  */
-interface ComputerUseOptions {
+export interface ComputerUseOptions {
   /**
    * The width of the computer display in pixels.
    */
@@ -114,7 +114,7 @@ interface ComputerUseOptions {
 /**
  * OpenAI Computer Use tool type for the Responses API.
  */
-type ComputerUseTool = OpenAI.Responses.ComputerUsePreviewTool;
+export type ComputerUseTool = OpenAI.Responses.ComputerUsePreviewTool;
 /**
  * Creates a Computer Use tool that allows models to control computer interfaces
  * and perform tasks by simulating mouse clicks, keyboard input, scrolling, and more.
@@ -227,7 +227,6 @@ type ComputerUseTool = OpenAI.Responses.ComputerUsePreviewTool;
  * - Use `truncation: "auto"` parameter when making requests
  * - Recommended to use with `reasoning.summary` for debugging
  */
-declare function computerUse(options: ComputerUseOptions): DynamicStructuredTool<typeof ComputerUseActionSchema, ComputerUseInput, unknown, ComputerUseReturnType>;
+export declare function computerUse(options: ComputerUseOptions): DynamicStructuredTool<typeof ComputerUseActionSchema, ComputerUseInput, unknown, ComputerUseReturnType>;
 //#endregion
-export { ComputerUseAction, ComputerUseActionSchema, ComputerUseClickAction, ComputerUseDoubleClickAction, ComputerUseDragAction, ComputerUseEnvironment, ComputerUseInput, ComputerUseKeypressAction, ComputerUseMoveAction, ComputerUseOptions, ComputerUseReturnType, ComputerUseScreenshotAction, ComputerUseScrollAction, ComputerUseTool, ComputerUseTypeAction, ComputerUseWaitAction, computerUse };
 //# sourceMappingURL=computerUse.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"computerUse.d.cts","names":[],"sources":["../../src/tools/computerUse.ts"],"mappings":";;;;;;;;KAcY;;;;KAUA,yBACV,OAAa,UAAU,yBAAyB;KACtC,+BACV,OAAa,UAAU,yBAAyB;KACtC,wBACV,OAAa,UAAU,yBAAyB;KACtC,4BACV,OAAa,UAAU,yBAAyB;KACtC,wBACV,OAAa,UAAU,yBAAyB;KACtC,8BACV,OAAa,UAAU,yBAAyB;KACtC,0BACV,OAAa,UAAU,yBAAyB;KACtC,wBACV,OAAa,UAAU,yBAAyB;KACtC,wBACV,OAAa,UAAU,yBAAyB;;;;KAKtC,oBACV,OAAa,UAAU;cAsEZ,yBAAuB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAElC,EAAA,KAAA;;;;;UAmCe;EACf,QAAQ;;KAGE,iCAER,kBACA,mBACA,QAAQ;;;;UAKK;;;;EAIf;;;;EAKA;;;;;;;;;EAUA,aAAa;;;;;;EAOb,UACE,QAAQ,mBACR,SAAS,0BACN;;;;;KAMK,kBAAkB,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoHrC,YAAY,SAAS,qBAmEZ,6BACd,yBACP,2BAEA"}
+{"version":3,"file":"computerUse.d.cts","names":["OpenAIClient"],"sources":["../../src/tools/computerUse.ts"],"mappings":";;;;;;;;YAcY;;;;YAUA,yBACVA,OAAa,UAAU,yBAAyB;YACtC,+BACVA,OAAa,UAAU,yBAAyB;YACtC,wBACVA,OAAa,UAAU,yBAAyB;YACtC,4BACVA,OAAa,UAAU,yBAAyB;YACtC,wBACVA,OAAa,UAAU,yBAAyB;YACtC,8BACVA,OAAa,UAAU,yBAAyB;YACtC,0BACVA,OAAa,UAAU,yBAAyB;YACtC,wBACVA,OAAa,UAAU,yBAAyB;YACtC,wBACVA,OAAa,UAAU,yBAAyB;;;;YAKtC,oBACVA,OAAa,UAAU;qBAsEZ,yBAAuB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAElC,EAAA,KAAA;;;;;iBAmCe;EACf,QAAQ;;YAGE,iCAER,kBACA,mBACA,QAAQ;;;;iBAKK;;;;EAIf;;;;EAKA;;;;;;;;;EAUA,aAAa;;;;;;EAOb,UACE,QAAQ,mBACR,SAAS,0BACN;;;;;YAMK,kBAAkBA,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAoHrC,YAAY,SAAS,qBAmEZ,6BACd,yBACP,2BAEA"}