@langchain/openai 1.6.2 → 1.7.0

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

@@ -1 +1 @@
-{"version":3,"file":"mcp.d.cts","names":[],"sources":["../../src/tools/mcp.ts"],"mappings":";;;;;;;KAOY;;;;UAaK;;;;EAIf;;;;;EAKA;;;;;UAMe;;;;EAIf,SAAS;;;;EAIT,QAAQ;;;;;UAMA;;;;EAIR;;;;;EAKA,0BAA0B;;;;;EAK1B;;;;;EAKA,UAAU;;;;;;;;;EASV,uCAAuC;;;;EAIvC;;;;;UAMe,+BAA+B;;;;;EAK9C;;;;;UAMe,4BAA4B;;;;;;;;;;;;;;;EAe3C,aAAa;;;;;KAMH,UAAU,OAAa,UAAU,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+GlC,IAAI,SAAS,yBAAyB;iBACtC,IAAI,SAAS,sBAAsB"}
+{"version":3,"file":"mcp.d.cts","names":["OpenAIClient"],"sources":["../../src/tools/mcp.ts"],"mappings":";;;;;;;YAOY;;;;iBAaK;;;;EAIf;;;;;EAKA;;;;;iBAMe;;;;EAIf,SAAS;;;;EAIT,QAAQ;;;;;UAMA;;;;EAIR;;;;;EAKA,0BAA0B;;;;;EAK1B;;;;;EAKA,UAAU;;;;;;;;;EASV,uCAAuC;;;;EAIvC;;;;;iBAMe,+BAA+B;;;;;EAK9C;;;;;iBAMe,4BAA4B;;;;;;;;;;;;;;;EAe3C,aAAa;;;;;YAMH,UAAUA,OAAa,UAAU,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA+GlC,IAAI,SAAS,yBAAyB;wBACtC,IAAI,SAAS,sBAAsB"}

package/dist/tools/mcp.d.ts

@@ -5,11 +5,11 @@ import { ServerTool } from "@langchain/core/tools";
  * Available connector IDs for OpenAI's built-in service connectors.
  * These are OpenAI-maintained MCP wrappers for popular services.
  */
-type McpConnectorId = "connector_dropbox" | "connector_gmail" | "connector_googlecalendar" | "connector_googledrive" | "connector_microsoftteams" | "connector_outlookcalendar" | "connector_outlookemail" | "connector_sharepoint";
+export type McpConnectorId = "connector_dropbox" | "connector_gmail" | "connector_googlecalendar" | "connector_googledrive" | "connector_microsoftteams" | "connector_outlookcalendar" | "connector_outlookemail" | "connector_sharepoint";
 /**
  * Filter object to specify which tools are allowed.
  */
-interface McpToolFilter {
+export interface McpToolFilter {
   /**
    * List of allowed tool names.
    */
@@ -23,7 +23,7 @@ interface McpToolFilter {
 /**
  * Filter object for approval requirements.
  */
-interface McpApprovalFilter {
+export interface McpApprovalFilter {
   /**
    * Tools that always require approval before execution.
    */
@@ -73,7 +73,7 @@ interface McpBaseOptions {
 /**
  * Options for connecting to a remote MCP server via URL.
  */
-interface McpRemoteServerOptions extends McpBaseOptions {
+export interface McpRemoteServerOptions extends McpBaseOptions {
   /**
    * The URL for the MCP server.
    * The server must implement the Streamable HTTP or HTTP/SSE transport protocol.
@@ -83,7 +83,7 @@ interface McpRemoteServerOptions extends McpBaseOptions {
 /**
  * Options for connecting to an OpenAI-maintained service connector.
  */
-interface McpConnectorOptions extends McpBaseOptions {
+export interface McpConnectorOptions extends McpBaseOptions {
   /**
    * Identifier for the service connector.
    * These are OpenAI-maintained MCP wrappers for popular services.
@@ -103,7 +103,7 @@ interface McpConnectorOptions extends McpBaseOptions {
 /**
  * OpenAI MCP tool type for the Responses API.
  */
-type McpTool = OpenAI.Responses.Tool.Mcp;
+export type McpTool = OpenAI.Responses.Tool.Mcp;
 /**
  * Creates an MCP tool that connects to a remote MCP server or OpenAI service connector.
  * This allows OpenAI models to access external tools and services via the Model Context Protocol.
@@ -168,8 +168,7 @@ type McpTool = OpenAI.Responses.Tool.Mcp;
  * });
  * ```
  */
-declare function mcp(options: McpRemoteServerOptions): ServerTool;
-declare function mcp(options: McpConnectorOptions): ServerTool;
+export declare function mcp(options: McpRemoteServerOptions): ServerTool;
+export declare function mcp(options: McpConnectorOptions): ServerTool;
 //#endregion
-export { McpApprovalFilter, McpConnectorId, McpConnectorOptions, McpRemoteServerOptions, McpTool, McpToolFilter, mcp };
 //# sourceMappingURL=mcp.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"mcp.d.ts","names":[],"sources":["../../src/tools/mcp.ts"],"mappings":";;;;;;;KAOY;;;;UAaK;;;;EAIf;;;;;EAKA;;;;;UAMe;;;;EAIf,SAAS;;;;EAIT,QAAQ;;;;;UAMA;;;;EAIR;;;;;EAKA,0BAA0B;;;;;EAK1B;;;;;EAKA,UAAU;;;;;;;;;EASV,uCAAuC;;;;EAIvC;;;;;UAMe,+BAA+B;;;;;EAK9C;;;;;UAMe,4BAA4B;;;;;;;;;;;;;;;EAe3C,aAAa;;;;;KAMH,UAAU,OAAa,UAAU,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+GlC,IAAI,SAAS,yBAAyB;iBACtC,IAAI,SAAS,sBAAsB"}
+{"version":3,"file":"mcp.d.ts","names":["OpenAIClient"],"sources":["../../src/tools/mcp.ts"],"mappings":";;;;;;;YAOY;;;;iBAaK;;;;EAIf;;;;;EAKA;;;;;iBAMe;;;;EAIf,SAAS;;;;EAIT,QAAQ;;;;;UAMA;;;;EAIR;;;;;EAKA,0BAA0B;;;;;EAK1B;;;;;EAKA,UAAU;;;;;;;;;EASV,uCAAuC;;;;EAIvC;;;;;iBAMe,+BAA+B;;;;;EAK9C;;;;;iBAMe,4BAA4B;;;;;;;;;;;;;;;EAe3C,aAAa;;;;;YAMH,UAAUA,OAAa,UAAU,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA+GlC,IAAI,SAAS,yBAAyB;wBACtC,IAAI,SAAS,sBAAsB"}

package/dist/tools/shell.d.cts

@@ -6,8 +6,8 @@ import { z } from "zod/v4";
  * Re-export action type from OpenAI SDK for convenience.
  * The action contains command details like commands array, timeout, and max output length.
  */
-type ShellAction = OpenAI.Responses.ResponseFunctionShellToolCall.Action;
-declare const ShellActionSchema: z.ZodObject<{
+export type ShellAction = OpenAI.Responses.ResponseFunctionShellToolCall.Action;
+export declare const ShellActionSchema: z.ZodObject<{
   commands: z.ZodArray<z.ZodString>;
   timeout_ms: z.ZodOptional<z.ZodNumber>;
   max_output_length: z.ZodOptional<z.ZodNumber>;
@@ -16,16 +16,16 @@ declare const ShellActionSchema: z.ZodObject<{
  * Result of a single shell command execution.
  * Contains stdout, stderr, and the outcome (exit code or timeout).
  */
-type ShellCommandOutput = OpenAI.Responses.ResponseFunctionShellCallOutputContent;
+export type ShellCommandOutput = OpenAI.Responses.ResponseFunctionShellCallOutputContent;
 /**
  * Outcome type for shell command execution - either exit with code or timeout.
  */
-type ShellCallOutcome = ShellCommandOutput["outcome"];
+export type ShellCallOutcome = ShellCommandOutput["outcome"];
 /**
  * Result of executing shell commands.
  * Contains an array of outputs (one per command) and the max_output_length parameter.
  */
-interface ShellResult {
+export interface ShellResult {
   /**
    * Array of command outputs. Each entry corresponds to a command from the action.
    * The order should match the order of commands in the action.
@@ -40,7 +40,7 @@ interface ShellResult {
 /**
  * Options for the Shell tool.
  */
-interface ShellOptions {
+export interface ShellOptions {
   /**
    * Execute function that handles shell command execution.
    * This function receives the action input containing the commands and limits,
@@ -84,7 +84,7 @@ interface ShellOptions {
 /**
  * OpenAI Shell tool type for the Responses API.
  */
-type ShellTool = OpenAI.Responses.FunctionShellTool;
+export type ShellTool = OpenAI.Responses.FunctionShellTool;
 /**
  * Creates a Shell tool that allows models to run shell commands through your integration.
  *
@@ -214,7 +214,6 @@ type ShellTool = OpenAI.Responses.FunctionShellTool;
  * - If `max_output_length` exists in the action, always pass it back in the output
  * - Many CLI tools return non-zero exit codes for warnings; still capture stdout/stderr
  */
-declare function shell(options: ShellOptions): DynamicStructuredTool<typeof ShellActionSchema, ShellAction, unknown, string>;
+export declare function shell(options: ShellOptions): DynamicStructuredTool<typeof ShellActionSchema, ShellAction, unknown, string>;
 //#endregion
-export { ShellAction, ShellActionSchema, ShellCallOutcome, ShellCommandOutput, ShellOptions, ShellResult, ShellTool, shell };
 //# sourceMappingURL=shell.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"shell.d.cts","names":[],"sources":["../../src/tools/shell.ts"],"mappings":";;;;;;;;KAQY,cACV,OAAa,UAAU,8BAA8B;cAG1C,mBAAiB,EAAA;;;;GAY5B,EAAA,KAAA;;;;;KAMU,qBACV,OAAa,UAAU;;;;KAKb,mBAAmB;;;;;UAMd;;;;;EAKf,QAAQ;;;;;EAKR;;;;;UAMe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuCf,UAAU,QAAQ,gBAAgB,cAAc,QAAQ;;;;;KAM9C,YAAY,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqI/B,MAAM,SAAS,eAyBT,6BACX,mBACP"}
+{"version":3,"file":"shell.d.cts","names":["OpenAIClient"],"sources":["../../src/tools/shell.ts"],"mappings":";;;;;;;;YAQY,cACVA,OAAa,UAAU,8BAA8B;qBAG1C,mBAAiB,EAAA;;;;GAY5B,EAAA,KAAA;;;;;YAMU,qBACVA,OAAa,UAAU;;;;YAKb,mBAAmB;;;;;iBAMd;;;;;EAKf,QAAQ;;;;;EAKR;;;;;iBAMe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuCf,UAAU,QAAQ,gBAAgB,cAAc,QAAQ;;;;;YAM9C,YAAYA,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAqI/B,MAAM,SAAS,eAyBT,6BACX,mBACP"}

package/dist/tools/shell.d.ts

@@ -6,8 +6,8 @@ import { z } from "zod/v4";
  * Re-export action type from OpenAI SDK for convenience.
  * The action contains command details like commands array, timeout, and max output length.
  */
-type ShellAction = OpenAI.Responses.ResponseFunctionShellToolCall.Action;
-declare const ShellActionSchema: z.ZodObject<{
+export type ShellAction = OpenAI.Responses.ResponseFunctionShellToolCall.Action;
+export declare const ShellActionSchema: z.ZodObject<{
   commands: z.ZodArray<z.ZodString>;
   timeout_ms: z.ZodOptional<z.ZodNumber>;
   max_output_length: z.ZodOptional<z.ZodNumber>;
@@ -16,16 +16,16 @@ declare const ShellActionSchema: z.ZodObject<{
  * Result of a single shell command execution.
  * Contains stdout, stderr, and the outcome (exit code or timeout).
  */
-type ShellCommandOutput = OpenAI.Responses.ResponseFunctionShellCallOutputContent;
+export type ShellCommandOutput = OpenAI.Responses.ResponseFunctionShellCallOutputContent;
 /**
  * Outcome type for shell command execution - either exit with code or timeout.
  */
-type ShellCallOutcome = ShellCommandOutput["outcome"];
+export type ShellCallOutcome = ShellCommandOutput["outcome"];
 /**
  * Result of executing shell commands.
  * Contains an array of outputs (one per command) and the max_output_length parameter.
  */
-interface ShellResult {
+export interface ShellResult {
   /**
    * Array of command outputs. Each entry corresponds to a command from the action.
    * The order should match the order of commands in the action.
@@ -40,7 +40,7 @@ interface ShellResult {
 /**
  * Options for the Shell tool.
  */
-interface ShellOptions {
+export interface ShellOptions {
   /**
    * Execute function that handles shell command execution.
    * This function receives the action input containing the commands and limits,
@@ -84,7 +84,7 @@ interface ShellOptions {
 /**
  * OpenAI Shell tool type for the Responses API.
  */
-type ShellTool = OpenAI.Responses.FunctionShellTool;
+export type ShellTool = OpenAI.Responses.FunctionShellTool;
 /**
  * Creates a Shell tool that allows models to run shell commands through your integration.
  *
@@ -214,7 +214,6 @@ type ShellTool = OpenAI.Responses.FunctionShellTool;
  * - If `max_output_length` exists in the action, always pass it back in the output
  * - Many CLI tools return non-zero exit codes for warnings; still capture stdout/stderr
  */
-declare function shell(options: ShellOptions): DynamicStructuredTool<typeof ShellActionSchema, ShellAction, unknown, string>;
+export declare function shell(options: ShellOptions): DynamicStructuredTool<typeof ShellActionSchema, ShellAction, unknown, string>;
 //#endregion
-export { ShellAction, ShellActionSchema, ShellCallOutcome, ShellCommandOutput, ShellOptions, ShellResult, ShellTool, shell };
 //# sourceMappingURL=shell.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"shell.d.ts","names":[],"sources":["../../src/tools/shell.ts"],"mappings":";;;;;;;;KAQY,cACV,OAAa,UAAU,8BAA8B;cAG1C,mBAAiB,EAAA;;;;GAY5B,EAAA,KAAA;;;;;KAMU,qBACV,OAAa,UAAU;;;;KAKb,mBAAmB;;;;;UAMd;;;;;EAKf,QAAQ;;;;;EAKR;;;;;UAMe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuCf,UAAU,QAAQ,gBAAgB,cAAc,QAAQ;;;;;KAM9C,YAAY,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqI/B,MAAM,SAAS,eAyBT,6BACX,mBACP"}
+{"version":3,"file":"shell.d.ts","names":["OpenAIClient"],"sources":["../../src/tools/shell.ts"],"mappings":";;;;;;;;YAQY,cACVA,OAAa,UAAU,8BAA8B;qBAG1C,mBAAiB,EAAA;;;;GAY5B,EAAA,KAAA;;;;;YAMU,qBACVA,OAAa,UAAU;;;;YAKb,mBAAmB;;;;;iBAMd;;;;;EAKf,QAAQ;;;;;EAKR;;;;;iBAMe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuCf,UAAU,QAAQ,gBAAgB,cAAc,QAAQ;;;;;YAM9C,YAAYA,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAqI/B,MAAM,SAAS,eAyBT,6BACX,mBACP"}

package/dist/tools/toolSearch.d.cts

@@ -1,7 +1,7 @@
 import { OpenAI } from "openai";
 import { ServerTool } from "@langchain/core/tools";
 //#region src/tools/toolSearch.d.ts
-interface ToolSearchOptions {
+export interface ToolSearchOptions {
   /**
    * Whether tool search is executed by the server or by the client.
    * - `"server"` (default): OpenAI's servers handle the search internally.
@@ -17,7 +17,7 @@ interface ToolSearchOptions {
    */
   parameters?: unknown;
 }
-type ToolSearchTool = OpenAI.Responses.ToolSearchTool;
+export type ToolSearchTool = OpenAI.Responses.ToolSearchTool;
 /**
  * Creates a tool search tool that enables OpenAI models to dynamically discover
  * and load tools on-demand from a large pool, rather than requiring all tool
@@ -72,7 +72,6 @@ type ToolSearchTool = OpenAI.Responses.ToolSearchTool;
  * });
  * ```
  */
-declare function toolSearch(options?: ToolSearchOptions): ServerTool;
+export declare function toolSearch(options?: ToolSearchOptions): ServerTool;
 //#endregion
-export { ToolSearchOptions, ToolSearchTool, toolSearch };
 //# sourceMappingURL=toolSearch.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"toolSearch.d.cts","names":[],"sources":["../../src/tools/toolSearch.ts"],"mappings":";;;UAGiB;;;;;;EAMf;;;;EAIA;;;;EAIA;;KAGU,iBAAiB,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwDpC,WAAW,UAAU,oBAAoB"}
+{"version":3,"file":"toolSearch.d.cts","names":["OpenAIClient"],"sources":["../../src/tools/toolSearch.ts"],"mappings":";;;iBAGiB;;;;;;EAMf;;;;EAIA;;;;EAIA;;YAGU,iBAAiBA,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAwDpC,WAAW,UAAU,oBAAoB"}

package/dist/tools/toolSearch.d.ts

@@ -1,7 +1,7 @@
 import { OpenAI } from "openai";
 import { ServerTool } from "@langchain/core/tools";
 //#region src/tools/toolSearch.d.ts
-interface ToolSearchOptions {
+export interface ToolSearchOptions {
   /**
    * Whether tool search is executed by the server or by the client.
    * - `"server"` (default): OpenAI's servers handle the search internally.
@@ -17,7 +17,7 @@ interface ToolSearchOptions {
    */
   parameters?: unknown;
 }
-type ToolSearchTool = OpenAI.Responses.ToolSearchTool;
+export type ToolSearchTool = OpenAI.Responses.ToolSearchTool;
 /**
  * Creates a tool search tool that enables OpenAI models to dynamically discover
  * and load tools on-demand from a large pool, rather than requiring all tool
@@ -72,7 +72,6 @@ type ToolSearchTool = OpenAI.Responses.ToolSearchTool;
  * });
  * ```
  */
-declare function toolSearch(options?: ToolSearchOptions): ServerTool;
+export declare function toolSearch(options?: ToolSearchOptions): ServerTool;
 //#endregion
-export { ToolSearchOptions, ToolSearchTool, toolSearch };
 //# sourceMappingURL=toolSearch.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"toolSearch.d.ts","names":[],"sources":["../../src/tools/toolSearch.ts"],"mappings":";;;UAGiB;;;;;;EAMf;;;;EAIA;;;;EAIA;;KAGU,iBAAiB,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwDpC,WAAW,UAAU,oBAAoB"}
+{"version":3,"file":"toolSearch.d.ts","names":["OpenAIClient"],"sources":["../../src/tools/toolSearch.ts"],"mappings":";;;iBAGiB;;;;;;EAMf;;;;EAIA;;;;EAIA;;YAGU,iBAAiBA,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAwDpC,WAAW,UAAU,oBAAoB"}

package/dist/tools/webSearch.d.cts

@@ -4,7 +4,7 @@ import { ServerTool } from "@langchain/core/tools";
 /**
  * User location configuration for geographic search refinement.
  */
-interface WebSearchUserLocation {
+export interface WebSearchUserLocation {
   /**
    * The type of location. Currently only "approximate" is supported.
    */
@@ -31,7 +31,7 @@ interface WebSearchUserLocation {
 /**
  * Domain filtering configuration for web search.
  */
-interface WebSearchFilters {
+export interface WebSearchFilters {
   /**
    * Allow-list of up to 100 domains to limit search results.
    * Omit the HTTP/HTTPS prefix (e.g., "openai.com" instead of "https://openai.com/").
@@ -42,7 +42,7 @@ interface WebSearchFilters {
 /**
  * Options for the OpenAI web search tool.
  */
-interface WebSearchOptions {
+export interface WebSearchOptions {
   /**
    * Domain filtering configuration.
    * Limit results to a specific set of up to 100 domains.
@@ -62,7 +62,7 @@ interface WebSearchOptions {
 /**
  * OpenAI web search tool type for the Responses API.
  */
-type WebSearchTool = OpenAI.Responses.WebSearchTool;
+export type WebSearchTool = OpenAI.Responses.WebSearchTool;
 /**
  * Creates a web search tool that allows OpenAI models to search the web
  * for up-to-date information before generating a response.
@@ -122,7 +122,6 @@ type WebSearchTool = OpenAI.Responses.WebSearchTool;
  * });
  * ```
  */
-declare function webSearch(options?: WebSearchOptions): ServerTool;
+export declare function webSearch(options?: WebSearchOptions): ServerTool;
 //#endregion
-export { WebSearchFilters, WebSearchOptions, WebSearchTool, WebSearchUserLocation, webSearch };
 //# sourceMappingURL=webSearch.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"webSearch.d.cts","names":[],"sources":["../../src/tools/webSearch.ts"],"mappings":";;;;;;UAMiB;;;;EAIf;;;;;EAKA;;;;EAIA;;;;EAIA;;;;;EAKA;;;;;UAMe;;;;;;EAMf;;;;;UAMe;;;;;EAKf,UAAU;;;;;EAKV,eAAe;;;;;EAKf;;;;;KAMU,gBAAgB,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6DnC,UAAU,UAAU,mBAAmB"}
+{"version":3,"file":"webSearch.d.cts","names":["OpenAIClient"],"sources":["../../src/tools/webSearch.ts"],"mappings":";;;;;;iBAMiB;;;;EAIf;;;;;EAKA;;;;EAIA;;;;EAIA;;;;;EAKA;;;;;iBAMe;;;;;;EAMf;;;;;iBAMe;;;;;EAKf,UAAU;;;;;EAKV,eAAe;;;;;EAKf;;;;;YAMU,gBAAgBA,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6DnC,UAAU,UAAU,mBAAmB"}

package/dist/tools/webSearch.d.ts

@@ -4,7 +4,7 @@ import { ServerTool } from "@langchain/core/tools";
 /**
  * User location configuration for geographic search refinement.
  */
-interface WebSearchUserLocation {
+export interface WebSearchUserLocation {
   /**
    * The type of location. Currently only "approximate" is supported.
    */
@@ -31,7 +31,7 @@ interface WebSearchUserLocation {
 /**
  * Domain filtering configuration for web search.
  */
-interface WebSearchFilters {
+export interface WebSearchFilters {
   /**
    * Allow-list of up to 100 domains to limit search results.
    * Omit the HTTP/HTTPS prefix (e.g., "openai.com" instead of "https://openai.com/").
@@ -42,7 +42,7 @@ interface WebSearchFilters {
 /**
  * Options for the OpenAI web search tool.
  */
-interface WebSearchOptions {
+export interface WebSearchOptions {
   /**
    * Domain filtering configuration.
    * Limit results to a specific set of up to 100 domains.
@@ -62,7 +62,7 @@ interface WebSearchOptions {
 /**
  * OpenAI web search tool type for the Responses API.
  */
-type WebSearchTool = OpenAI.Responses.WebSearchTool;
+export type WebSearchTool = OpenAI.Responses.WebSearchTool;
 /**
  * Creates a web search tool that allows OpenAI models to search the web
  * for up-to-date information before generating a response.
@@ -122,7 +122,6 @@ type WebSearchTool = OpenAI.Responses.WebSearchTool;
  * });
  * ```
  */
-declare function webSearch(options?: WebSearchOptions): ServerTool;
+export declare function webSearch(options?: WebSearchOptions): ServerTool;
 //#endregion
-export { WebSearchFilters, WebSearchOptions, WebSearchTool, WebSearchUserLocation, webSearch };
 //# sourceMappingURL=webSearch.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"webSearch.d.ts","names":[],"sources":["../../src/tools/webSearch.ts"],"mappings":";;;;;;UAMiB;;;;EAIf;;;;;EAKA;;;;EAIA;;;;EAIA;;;;;EAKA;;;;;UAMe;;;;;;EAMf;;;;;UAMe;;;;;EAKf,UAAU;;;;;EAKV,eAAe;;;;;EAKf;;;;;KAMU,gBAAgB,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6DnC,UAAU,UAAU,mBAAmB"}
+{"version":3,"file":"webSearch.d.ts","names":["OpenAIClient"],"sources":["../../src/tools/webSearch.ts"],"mappings":";;;;;;iBAMiB;;;;EAIf;;;;;EAKA;;;;EAIA;;;;EAIA;;;;;EAKA;;;;;iBAMe;;;;;;EAMf;;;;;iBAMe;;;;;EAKf,UAAU;;;;;EAKV,eAAe;;;;;EAKf;;;;;YAMU,gBAAgBA,OAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6DnC,UAAU,UAAU,mBAAmB"}

package/dist/types.d.cts

@@ -7,12 +7,12 @@ import { TiktokenModel } from "js-tiktoken/lite";
 /**
  * @see https://platform.openai.com/docs/models
  */
-type OpenAIChatModelId = OpenAI.ChatModel | (string & NonNullable<unknown>);
-type OpenAIVerbosityParam = "low" | "medium" | "high" | null;
-type OpenAICacheRetentionParam = "in_memory" | "in-memory" | "24h" | null;
-type OpenAIPromptCacheOptions = OpenAI.Responses.ResponseCreateParams["prompt_cache_options"];
-type OpenAIApiKey = ClientOptions["apiKey"];
-declare interface OpenAIBaseInput {
+export type OpenAIChatModelId = OpenAI.ChatModel | (string & NonNullable<unknown>);
+export type OpenAIVerbosityParam = "low" | "medium" | "high" | null;
+export type OpenAICacheRetentionParam = "in_memory" | "in-memory" | "24h" | null;
+export type OpenAIPromptCacheOptions = OpenAI.Responses.ResponseCreateParams["prompt_cache_options"];
+export type OpenAIApiKey = ClientOptions["apiKey"];
+export declare interface OpenAIBaseInput {
   /** Sampling temperature to use */
   temperature: number;
   /**
@@ -85,8 +85,8 @@ declare interface OpenAIBaseInput {
    */
   verbosity?: OpenAIVerbosityParam;
 }
-type OpenAICoreRequestOptions = OpenAI.RequestOptions;
-interface OpenAICallOptions extends BaseLanguageModelCallOptions {
+export type OpenAICoreRequestOptions = OpenAI.RequestOptions;
+export interface OpenAICallOptions extends BaseLanguageModelCallOptions {
   /**
    * Additional options to pass to the underlying axios request.
    */
@@ -95,13 +95,13 @@ interface OpenAICallOptions extends BaseLanguageModelCallOptions {
 /**
  * Input to OpenAI class.
  */
-declare interface OpenAIInput extends OpenAIBaseInput {
+export declare interface OpenAIInput extends OpenAIBaseInput {
   /** Generates `bestOf` completions server side and returns the "best" */
   bestOf?: number;
   /** Batch size to use when passing multiple documents to generate */
   batchSize: number;
 }
-interface OpenAIChatInput extends OpenAIBaseInput {
+export interface OpenAIChatInput extends OpenAIBaseInput {
   /**
    * Whether to return log probabilities of the output tokens or not.
    * If true, returns the log probabilities of each output token returned in the content of message.
@@ -177,7 +177,7 @@ interface OpenAIChatInput extends OpenAIBaseInput {
    */
   promptCacheOptions?: OpenAIPromptCacheOptions;
 }
-interface AzureOpenAIInput {
+export interface AzureOpenAIInput {
   /**
    * API version to use when making requests to Azure OpenAI.
    */
@@ -235,7 +235,7 @@ interface AzureOpenAIInput {
    */
   azureADTokenProvider?: () => Promise<string>;
 }
-interface AzureOpenAIChatInput extends OpenAIChatInput, AzureOpenAIInput {
+export interface AzureOpenAIChatInput extends OpenAIChatInput, AzureOpenAIInput {
   openAIApiVersion?: string;
   openAIBasePath?: string;
   deploymentName?: string;
@@ -252,7 +252,7 @@ type ChatOpenAIResponseFormatJSONSchema = Omit<ResponseFormatJSONSchema, "json_s
 /**
  * The summary of a model's reasoning step.
  */
-type ChatOpenAIReasoningSummary = Omit<OpenAI.Responses.ResponseReasoningItem, "summary"> & {
+export type ChatOpenAIReasoningSummary = Omit<OpenAI.Responses.ResponseReasoningItem, "summary"> & {
   /**
    * The summary of the reasoning step. The index field will be populated if the response was
    * streamed. This allows LangChain to recompose the reasoning summary output correctly when the
@@ -262,8 +262,8 @@ type ChatOpenAIReasoningSummary = Omit<OpenAI.Responses.ResponseReasoningItem, "
     index?: number;
   }>;
 };
-type ChatOpenAIResponseFormat = ResponseFormatText | ResponseFormatJSONObject | ResponseFormatTextGrammar | ResponseFormatTextPython | ChatOpenAIResponseFormatJSONSchema;
-type ResponseFormatConfiguration = ResponseFormatText | ResponseFormatJSONObject | ResponseFormatJSONSchema;
+export type ChatOpenAIResponseFormat = ResponseFormatText | ResponseFormatJSONObject | ResponseFormatTextGrammar | ResponseFormatTextPython | ChatOpenAIResponseFormatJSONSchema;
+export type ResponseFormatConfiguration = ResponseFormatText | ResponseFormatJSONObject | ResponseFormatJSONSchema;
 //#endregion
-export { AzureOpenAIChatInput, AzureOpenAIInput, ChatOpenAIReasoningSummary, ChatOpenAIResponseFormat, OpenAIApiKey, OpenAIBaseInput, OpenAICacheRetentionParam, OpenAICallOptions, OpenAIChatInput, OpenAIChatModelId, OpenAICoreRequestOptions, OpenAIInput, OpenAIPromptCacheOptions, OpenAIVerbosityParam, ResponseFormatConfiguration, type TiktokenModel };
+export type { TiktokenModel };
 //# sourceMappingURL=types.d.cts.map

package/dist/types.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.cts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;;KAoBY,oBACR,OAAa,sBACH;KAEF;KAEA;KAKA,2BACV,OAAa,UAAU;KAEb,eAAe;kBAEF;;EAEvB;;;;;EAMA;;;;;;EAOA;;EAGA;;EAGA;;EAGA;;EAGA;;EAGA,YAAY;;EAGZ;;EAGA;;;;;EAMA;;;;;;EAOA;;EAGA,OAAO;;;;;EAOP,cAAc;;;;;EAMd;;EAEA;;;;EAKA;;;;;;EAOA,eAAe;;;;;EAKf,SAAS;;;;EAKT,YAAY;;KAGF,2BAA2B,OAAa;UAEnC,0BAA0B;;;;EAIzC,UAAU;;;;;kBAMa,oBAAoB;;EAE3C;;EAGA;;UAGe,wBAAwB;;;;;EAKvC;;;;;EAMA;;EAGA,iBAAiB,OAAa,KAAK;;;;;EAMnC;;;;;EAMA;;;;;;;;;;;;;EAcA,aAAa,MAAM,OAAa,KAAK;;;;;;EAOrC,QAAQ,OAAa,KAAK;;;;;;;EAQ1B,YAAY,OAAa;;;;;;;EAQzB;;;;;EAMA,eAAe,OAAa,UAAU;;;;;;EAOtC;;;;EAKA,uBAAuB;;;;EAKvB,qBAAqB;;UAGN;;;;EAIf;;;;EAKA;;;;;;;EAQA;;;;;;;EAQA;;;;;;;;EASA;;;;;;;;;EAUA;;;;;;EAOA;;;;;;EAOA;;;;;EAMA,6BAA6B;;UAGd,6BACP,iBAAiB;EACzB;EACA;EACA;;KAGG,qCAAqC,KACxC;EAGA,aAAa,KAAK;;;;;IAMhB,QAAQ,sBAAsB;;;;;;KAOtB,6BAA6B,KACvC,OAAa,UAAU;;;;;;EAQvB,SAAS,MACP,OAAa,UAAU,sBAAsB;IAAY;;;KAIjD,2BACR,qBACA,2BACA,4BACA,2BACA;KAEQ,8BACR,qBACA,2BACA"}
+{"version":3,"file":"types.d.cts","names":["OpenAIClient"],"sources":["../src/types.ts"],"mappings":";;;;;;;;;YAoBY,oBACRA,OAAa,sBACH;YAEF;YAEA;YAKA,2BACVA,OAAa,UAAU;YAEb,eAAe;yBAEF;;EAEvB;;;;;EAMA;;;;;;EAOA;;EAGA;;EAGA;;EAGA;;EAGA;;EAGA,YAAY;;EAGZ;;EAGA;;;;;EAMA;;;;;;EAOA;;EAGA,OAAO;;;;;EAOP,cAAc;;;;;EAMd;;EAEA;;;;EAKA;;;;;;EAOA,eAAe;;;;;EAKf,SAAS;;;;EAKT,YAAY;;YAGF,2BAA2BA,OAAa;iBAEnC,0BAA0B;;;;EAIzC,UAAU;;;;;yBAMa,oBAAoB;;EAE3C;;EAGA;;iBAGe,wBAAwB;;;;;EAKvC;;;;;EAMA;;EAGA,iBAAiBA,OAAa,KAAK;;;;;EAMnC;;;;;EAMA;;;;;;;;;;;;;EAcA,aAAa,MAAMA,OAAa,KAAK;;;;;;EAOrC,QAAQA,OAAa,KAAK;;;;;;;EAQ1B,YAAYA,OAAa;;;;;;;EAQzB;;;;;EAMA,eAAeA,OAAa,UAAU;;;;;;EAOtC;;;;EAKA,uBAAuB;;;;EAKvB,qBAAqB;;iBAGN;;;;EAIf;;;;EAKA;;;;;;;EAQA;;;;;;;EAQA;;;;;;;;EASA;;;;;;;;;EAUA;;;;;;EAOA;;;;;;EAOA;;;;;EAMA,6BAA6B;;iBAGd,6BACP,iBAAiB;EACzB;EACA;EACA;;KAGG,qCAAqC,KACxC;EAGA,aAAa,KAAK;;;;;IAMhB,QAAQ,sBAAsB;;;;;;YAOtB,6BAA6B,KACvCA,OAAa,UAAU;;;;;;EAQvB,SAAS,MACPA,OAAa,UAAU,sBAAsB;IAAY;;;YAIjD,2BACR,qBACA,2BACA,4BACA,2BACA;YAEQ,8BACR,qBACA,2BACA"}

package/dist/types.d.ts

@@ -7,12 +7,12 @@ import { TiktokenModel } from "js-tiktoken/lite";
 /**
  * @see https://platform.openai.com/docs/models
  */
-type OpenAIChatModelId = OpenAI.ChatModel | (string & NonNullable<unknown>);
-type OpenAIVerbosityParam = "low" | "medium" | "high" | null;
-type OpenAICacheRetentionParam = "in_memory" | "in-memory" | "24h" | null;
-type OpenAIPromptCacheOptions = OpenAI.Responses.ResponseCreateParams["prompt_cache_options"];
-type OpenAIApiKey = ClientOptions["apiKey"];
-declare interface OpenAIBaseInput {
+export type OpenAIChatModelId = OpenAI.ChatModel | (string & NonNullable<unknown>);
+export type OpenAIVerbosityParam = "low" | "medium" | "high" | null;
+export type OpenAICacheRetentionParam = "in_memory" | "in-memory" | "24h" | null;
+export type OpenAIPromptCacheOptions = OpenAI.Responses.ResponseCreateParams["prompt_cache_options"];
+export type OpenAIApiKey = ClientOptions["apiKey"];
+export declare interface OpenAIBaseInput {
   /** Sampling temperature to use */
   temperature: number;
   /**
@@ -85,8 +85,8 @@ declare interface OpenAIBaseInput {
    */
   verbosity?: OpenAIVerbosityParam;
 }
-type OpenAICoreRequestOptions = OpenAI.RequestOptions;
-interface OpenAICallOptions extends BaseLanguageModelCallOptions {
+export type OpenAICoreRequestOptions = OpenAI.RequestOptions;
+export interface OpenAICallOptions extends BaseLanguageModelCallOptions {
   /**
    * Additional options to pass to the underlying axios request.
    */
@@ -95,13 +95,13 @@ interface OpenAICallOptions extends BaseLanguageModelCallOptions {
 /**
  * Input to OpenAI class.
  */
-declare interface OpenAIInput extends OpenAIBaseInput {
+export declare interface OpenAIInput extends OpenAIBaseInput {
   /** Generates `bestOf` completions server side and returns the "best" */
   bestOf?: number;
   /** Batch size to use when passing multiple documents to generate */
   batchSize: number;
 }
-interface OpenAIChatInput extends OpenAIBaseInput {
+export interface OpenAIChatInput extends OpenAIBaseInput {
   /**
    * Whether to return log probabilities of the output tokens or not.
    * If true, returns the log probabilities of each output token returned in the content of message.
@@ -177,7 +177,7 @@ interface OpenAIChatInput extends OpenAIBaseInput {
    */
   promptCacheOptions?: OpenAIPromptCacheOptions;
 }
-interface AzureOpenAIInput {
+export interface AzureOpenAIInput {
   /**
    * API version to use when making requests to Azure OpenAI.
    */
@@ -235,7 +235,7 @@ interface AzureOpenAIInput {
    */
   azureADTokenProvider?: () => Promise<string>;
 }
-interface AzureOpenAIChatInput extends OpenAIChatInput, AzureOpenAIInput {
+export interface AzureOpenAIChatInput extends OpenAIChatInput, AzureOpenAIInput {
   openAIApiVersion?: string;
   openAIBasePath?: string;
   deploymentName?: string;
@@ -252,7 +252,7 @@ type ChatOpenAIResponseFormatJSONSchema = Omit<ResponseFormatJSONSchema, "json_s
 /**
  * The summary of a model's reasoning step.
  */
-type ChatOpenAIReasoningSummary = Omit<OpenAI.Responses.ResponseReasoningItem, "summary"> & {
+export type ChatOpenAIReasoningSummary = Omit<OpenAI.Responses.ResponseReasoningItem, "summary"> & {
   /**
    * The summary of the reasoning step. The index field will be populated if the response was
    * streamed. This allows LangChain to recompose the reasoning summary output correctly when the
@@ -262,8 +262,8 @@ type ChatOpenAIReasoningSummary = Omit<OpenAI.Responses.ResponseReasoningItem, "
     index?: number;
   }>;
 };
-type ChatOpenAIResponseFormat = ResponseFormatText | ResponseFormatJSONObject | ResponseFormatTextGrammar | ResponseFormatTextPython | ChatOpenAIResponseFormatJSONSchema;
-type ResponseFormatConfiguration = ResponseFormatText | ResponseFormatJSONObject | ResponseFormatJSONSchema;
+export type ChatOpenAIResponseFormat = ResponseFormatText | ResponseFormatJSONObject | ResponseFormatTextGrammar | ResponseFormatTextPython | ChatOpenAIResponseFormatJSONSchema;
+export type ResponseFormatConfiguration = ResponseFormatText | ResponseFormatJSONObject | ResponseFormatJSONSchema;
 //#endregion
-export { AzureOpenAIChatInput, AzureOpenAIInput, ChatOpenAIReasoningSummary, ChatOpenAIResponseFormat, OpenAIApiKey, OpenAIBaseInput, OpenAICacheRetentionParam, OpenAICallOptions, OpenAIChatInput, OpenAIChatModelId, OpenAICoreRequestOptions, OpenAIInput, OpenAIPromptCacheOptions, OpenAIVerbosityParam, ResponseFormatConfiguration, type TiktokenModel };
+export type { TiktokenModel };
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;;KAoBY,oBACR,OAAa,sBACH;KAEF;KAEA;KAKA,2BACV,OAAa,UAAU;KAEb,eAAe;kBAEF;;EAEvB;;;;;EAMA;;;;;;EAOA;;EAGA;;EAGA;;EAGA;;EAGA;;EAGA,YAAY;;EAGZ;;EAGA;;;;;EAMA;;;;;;EAOA;;EAGA,OAAO;;;;;EAOP,cAAc;;;;;EAMd;;EAEA;;;;EAKA;;;;;;EAOA,eAAe;;;;;EAKf,SAAS;;;;EAKT,YAAY;;KAGF,2BAA2B,OAAa;UAEnC,0BAA0B;;;;EAIzC,UAAU;;;;;kBAMa,oBAAoB;;EAE3C;;EAGA;;UAGe,wBAAwB;;;;;EAKvC;;;;;EAMA;;EAGA,iBAAiB,OAAa,KAAK;;;;;EAMnC;;;;;EAMA;;;;;;;;;;;;;EAcA,aAAa,MAAM,OAAa,KAAK;;;;;;EAOrC,QAAQ,OAAa,KAAK;;;;;;;EAQ1B,YAAY,OAAa;;;;;;;EAQzB;;;;;EAMA,eAAe,OAAa,UAAU;;;;;;EAOtC;;;;EAKA,uBAAuB;;;;EAKvB,qBAAqB;;UAGN;;;;EAIf;;;;EAKA;;;;;;;EAQA;;;;;;;EAQA;;;;;;;;EASA;;;;;;;;;EAUA;;;;;;EAOA;;;;;;EAOA;;;;;EAMA,6BAA6B;;UAGd,6BACP,iBAAiB;EACzB;EACA;EACA;;KAGG,qCAAqC,KACxC;EAGA,aAAa,KAAK;;;;;IAMhB,QAAQ,sBAAsB;;;;;;KAOtB,6BAA6B,KACvC,OAAa,UAAU;;;;;;EAQvB,SAAS,MACP,OAAa,UAAU,sBAAsB;IAAY;;;KAIjD,2BACR,qBACA,2BACA,4BACA,2BACA;KAEQ,8BACR,qBACA,2BACA"}
+{"version":3,"file":"types.d.ts","names":["OpenAIClient"],"sources":["../src/types.ts"],"mappings":";;;;;;;;;YAoBY,oBACRA,OAAa,sBACH;YAEF;YAEA;YAKA,2BACVA,OAAa,UAAU;YAEb,eAAe;yBAEF;;EAEvB;;;;;EAMA;;;;;;EAOA;;EAGA;;EAGA;;EAGA;;EAGA;;EAGA,YAAY;;EAGZ;;EAGA;;;;;EAMA;;;;;;EAOA;;EAGA,OAAO;;;;;EAOP,cAAc;;;;;EAMd;;EAEA;;;;EAKA;;;;;;EAOA,eAAe;;;;;EAKf,SAAS;;;;EAKT,YAAY;;YAGF,2BAA2BA,OAAa;iBAEnC,0BAA0B;;;;EAIzC,UAAU;;;;;yBAMa,oBAAoB;;EAE3C;;EAGA;;iBAGe,wBAAwB;;;;;EAKvC;;;;;EAMA;;EAGA,iBAAiBA,OAAa,KAAK;;;;;EAMnC;;;;;EAMA;;;;;;;;;;;;;EAcA,aAAa,MAAMA,OAAa,KAAK;;;;;;EAOrC,QAAQA,OAAa,KAAK;;;;;;;EAQ1B,YAAYA,OAAa;;;;;;;EAQzB;;;;;EAMA,eAAeA,OAAa,UAAU;;;;;;EAOtC;;;;EAKA,uBAAuB;;;;EAKvB,qBAAqB;;iBAGN;;;;EAIf;;;;EAKA;;;;;;;EAQA;;;;;;;EAQA;;;;;;;;EASA;;;;;;;;;EAUA;;;;;;EAOA;;;;;;EAOA;;;;;EAMA,6BAA6B;;iBAGd,6BACP,iBAAiB;EACzB;EACA;EACA;;KAGG,qCAAqC,KACxC;EAGA,aAAa,KAAK;;;;;IAMhB,QAAQ,sBAAsB;;;;;;YAOtB,6BAA6B,KACvCA,OAAa,UAAU;;;;;;EAQvB,SAAS,MACPA,OAAa,UAAU,sBAAsB;IAAY;;;YAIjD,2BACR,qBACA,2BACA,4BACA,2BACA;YAEQ,8BACR,qBACA,2BACA"}

package/dist/utils/azure.d.cts

@@ -1,5 +1,5 @@
 //#region src/utils/azure.d.ts
-interface OpenAIEndpointConfig {
+export interface OpenAIEndpointConfig {
   azureOpenAIApiDeploymentName?: string;
   azureOpenAIApiInstanceName?: string;
   azureOpenAIApiKey?: string;
@@ -32,13 +32,13 @@ interface OpenAIEndpointConfig {
  *
  * @returns {string | undefined} The generated (Azure) OpenAI endpoint URL.
  */
-declare function getEndpoint(config: OpenAIEndpointConfig): string | null | undefined;
+export declare function getEndpoint(config: OpenAIEndpointConfig): string | null | undefined;
 type HeaderValue = string | undefined | null;
-type HeadersLike = Headers | readonly HeaderValue[][] | Record<string, HeaderValue | readonly HeaderValue[]> | undefined | null | {
+export type HeadersLike = Headers | readonly HeaderValue[][] | Record<string, HeaderValue | readonly HeaderValue[]> | undefined | null | {
   values: Headers;
   [key: string]: unknown;
 };
-declare function isHeaders(headers: unknown): headers is Headers;
+export declare function isHeaders(headers: unknown): headers is Headers;
 /**
  * Normalizes various header formats into a consistent Record format.
  *
@@ -68,9 +68,8 @@ declare function isHeaders(headers: unknown): headers is Headers;
  * const normalized3 = normalizeHeaders(headers3);
  * ```
  */
-declare function normalizeHeaders(headers: HeadersLike): Record<string, HeaderValue | readonly HeaderValue[]>;
-declare function getFormattedEnv(): string;
-declare function getHeadersWithUserAgent(headers: HeadersLike, isAzure?: boolean, version?: string): Record<string, string>;
+export declare function normalizeHeaders(headers: HeadersLike): Record<string, HeaderValue | readonly HeaderValue[]>;
+export declare function getFormattedEnv(): string;
+export declare function getHeadersWithUserAgent(headers: HeadersLike, isAzure?: boolean, version?: string): Record<string, string>;
 //#endregion
-export { HeadersLike, OpenAIEndpointConfig, getEndpoint, getFormattedEnv, getHeadersWithUserAgent, isHeaders, normalizeHeaders };
 //# sourceMappingURL=azure.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"azure.d.cts","names":[],"sources":["../../src/utils/azure.ts"],"mappings":";UAGiB;EACf;EACA;EACA;EACA,6BAA6B;EAC7B;EACA;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2Bc,YAAY,QAAQ;KA2C/B;KACO,cACR,mBACS,kBACT,eAAe,uBAAuB;EAIpC,QAAQ;GAAU;;iBAER,UAAU,mBAAmB,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsCxC,iBACd,SAAS,cACR,eAAe,uBAAuB;iBAgCzB;iBAUA,wBACd,SAAS,aACT,mBACA,mBACC"}
+{"version":3,"file":"azure.d.cts","names":[],"sources":["../../src/utils/azure.ts"],"mappings":";iBAGiB;EACf;EACA;EACA;EACA,6BAA6B;EAC7B;EACA;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2Bc,YAAY,QAAQ;KA2C/B;YACO,cACR,mBACS,kBACT,eAAe,uBAAuB;EAIpC,QAAQ;GAAU;;wBAER,UAAU,mBAAmB,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAsCxC,iBACd,SAAS,cACR,eAAe,uBAAuB;wBAgCzB;wBAUA,wBACd,SAAS,aACT,mBACA,mBACC"}

package/dist/utils/azure.d.ts

@@ -1,5 +1,5 @@
 //#region src/utils/azure.d.ts
-interface OpenAIEndpointConfig {
+export interface OpenAIEndpointConfig {
   azureOpenAIApiDeploymentName?: string;
   azureOpenAIApiInstanceName?: string;
   azureOpenAIApiKey?: string;
@@ -32,13 +32,13 @@ interface OpenAIEndpointConfig {
  *
  * @returns {string | undefined} The generated (Azure) OpenAI endpoint URL.
  */
-declare function getEndpoint(config: OpenAIEndpointConfig): string | null | undefined;
+export declare function getEndpoint(config: OpenAIEndpointConfig): string | null | undefined;
 type HeaderValue = string | undefined | null;
-type HeadersLike = Headers | readonly HeaderValue[][] | Record<string, HeaderValue | readonly HeaderValue[]> | undefined | null | {
+export type HeadersLike = Headers | readonly HeaderValue[][] | Record<string, HeaderValue | readonly HeaderValue[]> | undefined | null | {
   values: Headers;
   [key: string]: unknown;
 };
-declare function isHeaders(headers: unknown): headers is Headers;
+export declare function isHeaders(headers: unknown): headers is Headers;
 /**
  * Normalizes various header formats into a consistent Record format.
  *
@@ -68,9 +68,8 @@ declare function isHeaders(headers: unknown): headers is Headers;
  * const normalized3 = normalizeHeaders(headers3);
  * ```
  */
-declare function normalizeHeaders(headers: HeadersLike): Record<string, HeaderValue | readonly HeaderValue[]>;
-declare function getFormattedEnv(): string;
-declare function getHeadersWithUserAgent(headers: HeadersLike, isAzure?: boolean, version?: string): Record<string, string>;
+export declare function normalizeHeaders(headers: HeadersLike): Record<string, HeaderValue | readonly HeaderValue[]>;
+export declare function getFormattedEnv(): string;
+export declare function getHeadersWithUserAgent(headers: HeadersLike, isAzure?: boolean, version?: string): Record<string, string>;
 //#endregion
-export { HeadersLike, OpenAIEndpointConfig, getEndpoint, getFormattedEnv, getHeadersWithUserAgent, isHeaders, normalizeHeaders };
 //# sourceMappingURL=azure.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"azure.d.ts","names":[],"sources":["../../src/utils/azure.ts"],"mappings":";UAGiB;EACf;EACA;EACA;EACA,6BAA6B;EAC7B;EACA;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2Bc,YAAY,QAAQ;KA2C/B;KACO,cACR,mBACS,kBACT,eAAe,uBAAuB;EAIpC,QAAQ;GAAU;;iBAER,UAAU,mBAAmB,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsCxC,iBACd,SAAS,cACR,eAAe,uBAAuB;iBAgCzB;iBAUA,wBACd,SAAS,aACT,mBACA,mBACC"}
+{"version":3,"file":"azure.d.ts","names":[],"sources":["../../src/utils/azure.ts"],"mappings":";iBAGiB;EACf;EACA;EACA;EACA,6BAA6B;EAC7B;EACA;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2Bc,YAAY,QAAQ;KA2C/B;YACO,cACR,mBACS,kBACT,eAAe,uBAAuB;EAIpC,QAAQ;GAAU;;wBAER,UAAU,mBAAmB,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAsCxC,iBACd,SAAS,cACR,eAAe,uBAAuB;wBAgCzB;wBAUA,wBACd,SAAS,aACT,mBACA,mBACC"}