@zhivex-ai/openai 0.13.7 → 0.14.1

package/dist/index.js

@@ -7,7 +7,7 @@ export { OpenAIAgentsClient } from "./agents.js";
 import { toJSONSchema, z } from "zod";
 import { OpenAILiveModel, isOpenAILiveModel } from "./live.js";
 import { createOpenAIImageGenerationModel, normalizeOpenAIImageGenerationCall, normalizeOpenAIImageGenerationPartialImage } from "./image-generation.js";
-import { groundedCapabilities, supportsOpenAIModernResponses, isOpenAIAstraModel, isOpenAISolLunaModel, modelCapabilities, supportsOpenAIApplyPatchAndSkills, supportsOpenAIShell } from "./capabilities.js";
+import { groundedCapabilities, supportsOpenAIModernResponses, assertOpenAIModelRequestSupported, resolveOpenAIModelProfile, modelCapabilities } from "./capabilities.js";
 import { imageInputToDataUrl, ConfigurationError, ProviderHTTPError, ProviderResponseTooLargeError, ProviderToolCallError, assertTrustedEndpoint, resolveAudioResponseLimits, openWebSocketConnection, hostedTool, providerDataPart, UnsupportedFeatureError, createProviderAdapter, isCallableToolDefinition, isHostedToolDefinition, normalizeFinishReason, streamSSE, streamChatCompletions, toolResultPayload, withRetry, withResponseRetry, withTimeoutSignal } from "@zhivex-ai/core/provider";
 const MIB = 1024 * 1024;
 const DEFAULT_HOSTED_IMAGE_EVENT_BYTES = 32 * MIB;
@@ -270,8 +270,7 @@ const responsesImageGenerationConfig = (tools, limits) => {
             : {})
     };
 };
-const assertResponsesToolsSupported = (modelId, tools) => {
-    const currentCapabilities = modelCapabilities(modelId).agentCapabilities;
+const assertResponsesToolsSupported = (modelId, tools, currentCapabilities) => {
     for (const definition of Object.values(tools ?? {})) {
         const type = isCallableToolDefinition(definition) ? openAILocalResponsesToolType(definition) : definition.type;
         if (type === "tool_search" && !currentCapabilities?.toolSearch) {
@@ -283,22 +282,22 @@ const assertResponsesToolsSupported = (modelId, tools) => {
         if (type === "computer" && !currentCapabilities?.computerUse) {
             throw new UnsupportedFeatureError(`Provider "openai" model "${modelId}" does not support the Responses computer tool.`);
         }
-        if (type === "shell" && !supportsOpenAIShell(modelId)) {
+        if (type === "shell" && !currentCapabilities?.shell) {
             throw new UnsupportedFeatureError(`Provider "openai" model "${modelId}" does not support the Responses ${type} tool.`);
         }
-        if (type === "apply_patch" && !supportsOpenAIApplyPatchAndSkills(modelId)) {
+        if (type === "apply_patch" && !currentCapabilities?.applyPatch) {
             throw new UnsupportedFeatureError(`Provider "openai" model "${modelId}" does not support the Responses ${type} tool.`);
         }
         if (type === "skill" && !currentCapabilities?.skills) {
             throw new UnsupportedFeatureError(`Provider "openai" model "${modelId}" does not support the Responses skills tool.`);
         }
-        if (type === "programmatic_tool_calling" && !supportsOpenAIModernResponses(modelId)) {
+        if (type === "programmatic_tool_calling" && !currentCapabilities?.programmaticToolCalling) {
             throw new UnsupportedFeatureError(`Provider "openai" model "${modelId}" does not support Programmatic Tool Calling.`);
         }
     }
 };
-const assertOpenAIResponsesOptionsSupported = (modelId, options) => {
-    if (options.multi_agent?.enabled && !supportsOpenAIModernResponses(modelId)) {
+const assertOpenAIResponsesOptionsSupported = (modelId, options, currentCapabilities) => {
+    if (options.multi_agent?.enabled && !currentCapabilities?.multiAgent) {
         throw new UnsupportedFeatureError(`Provider "openai" model "${modelId}" does not support Multi-agent.`);
     }
 };
@@ -934,7 +933,7 @@ const addTokenUsage = (left, right) => {
         return right;
     if (!right)
         return left;
-    const sum = (a, b) => a === undefined && b === undefined ? undefined : (a ?? 0) + (b ?? 0);
+    const sum = (a, b) => a === undefined || b === undefined ? undefined : a + b;
     return {
         inputTokens: sum(left.inputTokens, right.inputTokens),
         cachedInputTokens: sum(left.cachedInputTokens, right.cachedInputTokens),
@@ -1382,7 +1381,8 @@ const streamGenerateResult = async function* (result) {
         type: "finish",
         finishReason: result.finishReason,
         providerFinishReason: result.providerFinishReason,
-        usage: result.usage
+        usage: result.usage,
+        providerRequestCount: result.providerRequestCount
     };
 };
 const extractSources = (value) => {
@@ -1419,45 +1419,43 @@ class OpenAILanguageModel {
     responseLimits;
     provider = "openai";
     capabilities;
-    constructor(modelId, apiKey, baseURL, fetcher, responseLimits) {
+    constructor(modelId, apiKey, baseURL, fetcher, responseLimits, capabilityOptions) {
         this.modelId = modelId;
         this.apiKey = apiKey;
         this.baseURL = baseURL;
         this.fetcher = fetcher;
         this.responseLimits = responseLimits;
-        this.capabilities = { ...modelCapabilities(modelId), toolHistory: "json" };
+        const base = modelCapabilities(modelId, capabilityOptions.unknownModelCapabilities);
+        const override = (capabilityOptions.modelCapabilities && Object.hasOwn(capabilityOptions.modelCapabilities, modelId) ? capabilityOptions.modelCapabilities[modelId] : undefined);
+        this.capabilities = { ...base, ...override,
+            agentCapabilities: { ...base.agentCapabilities, ...override?.agentCapabilities }, toolHistory: "json" };
     }
     usesResponsesAPI(input, options) {
-        if (isOpenAISolLunaModel(this.modelId)) {
-            const raw = options.bodyOptions;
-            const effort = input.reasoning?.effort ?? raw.reasoning?.effort ?? raw.reasoning_effort;
-            if (effort !== undefined && !["none", "low", "medium", "high", "xhigh", "max"].includes(String(effort))) {
-                throw new UnsupportedFeatureError(`GPT-6 Sol/Luna does not support reasoning effort "${effort}".`);
-            }
-            if (effort !== "none") {
-                if (input.temperature !== undefined || raw.temperature !== undefined || raw.top_p !== undefined || raw.top_logprobs !== undefined ||
-                    (options.apiMode === "chat" && raw.logprobs !== undefined) || raw.include?.includes("message.output_text.logprobs")) {
-                    throw new UnsupportedFeatureError('GPT-6 Sol/Luna sampling and logprobs controls require reasoning effort "none".');
-                }
-                if (options.apiMode === "chat" && Object.keys(input.tools ?? {}).length) {
-                    throw new UnsupportedFeatureError('GPT-6 Sol/Luna tool calling with reasoning requires the Responses API; Chat Completions requires effort "none".');
-                }
-            }
+        if (!this.capabilities.tools && (Object.keys(input.tools ?? {}).length || input.messages.some(message => message.parts.some(part => part.type === "tool-call" || part.type === "tool-result")))) {
+            throw new UnsupportedFeatureError(`OpenAI model "${this.modelId}" has no declared tool support.`);
         }
-        if (isOpenAIAstraModel(this.modelId)) {
-            const raw = options.bodyOptions;
-            const effort = input.reasoning?.effort ?? raw.reasoning?.effort ?? raw.reasoning_effort;
-            if (effort !== undefined && !["low", "medium", "high", "xhigh", "max"].includes(String(effort))) {
-                throw new UnsupportedFeatureError(`GPT-6 Astra does not support reasoning effort "${effort}".`);
-            }
-            if (input.temperature !== undefined || raw.temperature !== undefined || raw.top_p !== undefined || raw.top_logprobs !== undefined ||
-                (options.apiMode === "chat" && raw.logprobs !== undefined) || raw.include?.includes("message.output_text.logprobs")) {
-                throw new UnsupportedFeatureError("GPT-6 Astra does not support the requested sampling or logprobs controls.");
-            }
-            if (options.apiMode === "chat" && Object.keys(input.tools ?? {}).length) {
-                throw new UnsupportedFeatureError("GPT-6 Astra tool calling requires the Responses API.");
-            }
+        if (!this.capabilities.vision && input.messages.some(message => message.parts.some(part => part.type === "image"))) {
+            throw new UnsupportedFeatureError(`OpenAI model "${this.modelId}" has no declared vision support.`);
         }
+        const rawFormat = options.bodyOptions.response_format;
+        const rawText = options.bodyOptions.text;
+        const formatTypes = [rawFormat?.type, rawText?.format?.type];
+        if (!this.capabilities.structuredOutput && (input.structuredOutput?.mode === "native" || formatTypes.includes("json_schema"))) {
+            throw new UnsupportedFeatureError(`OpenAI model "${this.modelId}" has no declared native structured output support.`);
+        }
+        if (!this.capabilities.jsonMode && formatTypes.includes("json_object")) {
+            throw new UnsupportedFeatureError(`OpenAI model "${this.modelId}" has no declared JSON mode support.`);
+        }
+        if (!this.capabilities.parallelToolCalls && options.bodyOptions.parallel_tool_calls === true) {
+            throw new UnsupportedFeatureError(`OpenAI model "${this.modelId}" has no declared parallel tool calling support.`);
+        }
+        if (!this.capabilities.reasoning && (input.reasoning || options.bodyOptions.reasoning || options.bodyOptions.reasoning_effort)) {
+            throw new UnsupportedFeatureError(`OpenAI model "${this.modelId}" has no declared reasoning support.`);
+        }
+        if (!this.capabilities.toolChoice && (input.toolChoice !== undefined || options.bodyOptions.tool_choice !== undefined)) {
+            throw new UnsupportedFeatureError(`OpenAI model "${this.modelId}" has no declared tool choice support.`);
+        }
+        assertOpenAIModelRequestSupported(this.modelId, input, options);
         const requiresResponses = hasResponsesOnlyTools(input.tools) || options.multiAgentEnabled;
         if (options.apiMode === "chat") {
             if (requiresResponses) {
@@ -1465,12 +1463,12 @@ class OpenAILanguageModel {
             }
             return false;
         }
-        return options.apiMode === "responses" || requiresResponses || supportsOpenAIModernResponses(this.modelId);
+        return options.apiMode === "responses" || requiresResponses || resolveOpenAIModelProfile(this.modelId).defaultApi === "responses";
     }
     async generateViaResponses(input, signal, options) {
         const responseBodyOptions = openAIResponsesBodyOptions(options.bodyOptions, this.modelId);
-        assertResponsesToolsSupported(this.modelId, input.tools);
-        assertOpenAIResponsesOptionsSupported(this.modelId, responseBodyOptions);
+        assertResponsesToolsSupported(this.modelId, input.tools, this.capabilities.agentCapabilities);
+        assertOpenAIResponsesOptionsSupported(this.modelId, responseBodyOptions, this.capabilities.agentCapabilities);
         const previousResponse = responseBodyOptions.store === false ? undefined : getProviderResponseId(input.messages);
         const messages = previousResponse && previousResponse.index < input.messages.length - 1
             ? input.messages.slice(previousResponse.index + 1)
@@ -1478,75 +1476,119 @@ class OpenAILanguageModel {
         let nextPreviousResponseId = previousResponse?.responseId;
         let nextInput = messages.length ? toResponsesInput(messages, input.toolResultFormat, input.messages) : [];
         let accumulatedUsage;
+        const ptc = hasProgrammaticToolCalling(input.tools);
+        const requestLimit = Math.min(input.maxProviderRequests ?? 8, 8);
+        if (!Number.isSafeInteger(requestLimit) || requestLimit < 1)
+            throw new ConfigurationError("maxProviderRequests must be a positive integer.");
+        let providerRequestCount = 0;
+        let usageComplete = true;
+        const failure = (diagnosticCode, cause) => new ProviderToolCallError({
+            provider: "openai", transport: "responses", diagnosticCode,
+            reason: cause instanceof ProviderToolCallError ? cause.reason : "response_failed",
+            retryable: false, effectsPossible: providerRequestCount > 0,
+            confirmedUsage: accumulatedUsage, usageComplete, providerRequestCount
+        });
         let statelessInternalOutputs = [];
-        for (let continuation = 0; continuation < 8; continuation += 1) {
-            const response = await withResponseRetry(() => this.fetcher(`${this.baseURL}/responses`, {
-                method: "POST",
-                headers: options.headers,
-                signal,
-                body: JSON.stringify({
-                    ...responseBodyOptions,
-                    model: this.modelId,
-                    ...(nextPreviousResponseId ? { previous_response_id: nextPreviousResponseId } : {}),
-                    ...(nextInput.length ? { input: nextInput } : {}),
-                    tools: mapResponsesTools(input.tools),
-                    ...(input.toolChoice ? { tool_choice: mapResponsesToolChoice(input.toolChoice) } : {}),
-                    text: mapResponsesStructuredOutput(input),
-                    temperature: input.temperature,
-                    max_output_tokens: input.maxTokens,
-                    ...mapResponsesReasoning(input, responseBodyOptions.reasoning)
-                })
-            }), { ...input, abortSignal: signal }, "OpenAI");
-            const json = await parseJson(response);
-            accumulatedUsage = addTokenUsage(accumulatedUsage, mapResponsesUsage(json.usage));
-            const assistantMessage = parseResponsesAssistantMessage(json, options.multiAgentEnabled, localResponsesTools(input.tools), this.responseLimits.toolCallArgumentChars);
-            const currentOutput = Array.isArray(json.output)
-                ? json.output
-                : [];
-            const completeStatelessOutput = [...statelessInternalOutputs, ...currentOutput];
-            if (responseBodyOptions.store === false && completeStatelessOutput.length) {
-                assistantMessage.parts = assistantMessage.parts.filter((part) => part.type !== "provider-data" ||
-                    part.provider !== "openai" ||
-                    !part.data ||
-                    typeof part.data !== "object" ||
-                    part.data.type !== "responses_output");
-                assistantMessage.parts.push(providerDataPart("openai", {
-                    type: "responses_output",
-                    items: completeStatelessOutput
-                }));
-            }
-            const hasToolCalls = assistantMessage.parts.some((part) => part.type === "tool-call");
-            const hasRefusal = (json.output ?? []).some((item) => item?.type === "message" &&
-                (item.content ?? []).some((content) => content?.type === "refusal"));
-            const hasFinalMessage = (json.output ?? []).some((item) => item?.type === "message" &&
-                (!options.multiAgentEnabled || (item.agent?.agent_name === "/root" && item.phase === "final_answer")));
-            const shouldContinueProgram = hasProgrammaticToolCalling(input.tools) &&
-                json.status === "completed" &&
-                !hasToolCalls &&
-                !hasFinalMessage &&
-                (json.output ?? []).some((item) => item?.type === "program" || item?.type === "program_output");
-            if (!shouldContinueProgram) {
-                return {
-                    messages: [assistantMessage],
-                    text: extractMessageText(assistantMessage),
-                    audio: extractAudioOutputs(assistantMessage),
-                    images: extractResponsesImageOutputs(json, responsesImageGenerationConfig(input.tools)?.outputFormat),
-                    finishReason: normalizeResponsesFinishReason(json.status, hasToolCalls, hasRefusal),
-                    providerFinishReason: json.status,
-                    usage: accumulatedUsage,
-                    rawResponse: json
-                };
-            }
-            if (responseBodyOptions.store === false) {
-                statelessInternalOutputs = completeStatelessOutput;
-                nextInput = [...nextInput, ...currentOutput];
-            }
-            else {
-                nextPreviousResponseId = json.id;
-                nextInput = [];
+        try {
+            for (let continuation = 0; continuation < requestLimit; continuation += 1) {
+                const remainingOutputTokens = input.maxTokens === undefined ? undefined
+                    : input.maxTokens - (accumulatedUsage?.outputTokens ?? 0);
+                if (ptc && remainingOutputTokens !== undefined && remainingOutputTokens < 1)
+                    throw failure("OPENAI_PTC_OUTPUT_LIMIT");
+                if (ptc) {
+                    signal?.throwIfAborted();
+                    providerRequestCount++;
+                    usageComplete = false;
+                }
+                const response = await withResponseRetry(() => this.fetcher(`${this.baseURL}/responses`, {
+                    method: "POST",
+                    headers: options.headers,
+                    signal,
+                    body: JSON.stringify({
+                        ...responseBodyOptions,
+                        model: this.modelId,
+                        ...(nextPreviousResponseId ? { previous_response_id: nextPreviousResponseId } : {}),
+                        ...(nextInput.length ? { input: nextInput } : {}),
+                        tools: mapResponsesTools(input.tools),
+                        ...(input.toolChoice ? { tool_choice: mapResponsesToolChoice(input.toolChoice) } : {}),
+                        text: mapResponsesStructuredOutput(input) ?? responseBodyOptions.text,
+                        temperature: input.temperature,
+                        max_output_tokens: ptc ? remainingOutputTokens : input.maxTokens,
+                        ...mapResponsesReasoning(input, responseBodyOptions.reasoning)
+                    })
+                }), { ...input, abortSignal: signal, ...(ptc ? { maxRetries: 0 } : {}) }, "OpenAI");
+                const json = await parseJson(response);
+                const reportedUsage = mapResponsesUsage(json.usage);
+                if (ptc && (!reportedUsage || ![reportedUsage.inputTokens, reportedUsage.outputTokens, reportedUsage.totalTokens].every(value => typeof value === "number" && Number.isSafeInteger(value) && value >= 0) || reportedUsage.totalTokens < reportedUsage.inputTokens + reportedUsage.outputTokens || Object.values(reportedUsage).some(value => value !== undefined && (!Number.isSafeInteger(value) || value < 0)))) {
+                    throw failure("OPENAI_PTC_USAGE_UNKNOWN");
+                }
+                const nextUsage = addTokenUsage(accumulatedUsage, reportedUsage);
+                if (ptc && Object.values(nextUsage ?? {}).some(value => value !== undefined && !Number.isSafeInteger(value)))
+                    throw failure("OPENAI_PTC_USAGE_UNKNOWN");
+                accumulatedUsage = nextUsage;
+                if (ptc)
+                    usageComplete = true;
+                if (ptc && input.maxTokens !== undefined && accumulatedUsage.outputTokens > input.maxTokens)
+                    throw failure("OPENAI_PTC_OUTPUT_LIMIT");
+                const assistantMessage = parseResponsesAssistantMessage(json, options.multiAgentEnabled, localResponsesTools(input.tools), this.responseLimits.toolCallArgumentChars);
+                const currentOutput = Array.isArray(json.output)
+                    ? json.output
+                    : [];
+                const completeStatelessOutput = [...statelessInternalOutputs, ...currentOutput];
+                if (responseBodyOptions.store === false && completeStatelessOutput.length) {
+                    assistantMessage.parts = assistantMessage.parts.filter((part) => part.type !== "provider-data" ||
+                        part.provider !== "openai" ||
+                        !part.data ||
+                        typeof part.data !== "object" ||
+                        part.data.type !== "responses_output");
+                    assistantMessage.parts.push(providerDataPart("openai", {
+                        type: "responses_output",
+                        items: completeStatelessOutput
+                    }));
+                }
+                const hasToolCalls = assistantMessage.parts.some((part) => part.type === "tool-call");
+                const hasRefusal = (json.output ?? []).some((item) => item?.type === "message" &&
+                    (item.content ?? []).some((content) => content?.type === "refusal"));
+                const hasFinalMessage = (json.output ?? []).some((item) => item?.type === "message" &&
+                    (!options.multiAgentEnabled || (item.agent?.agent_name === "/root" && item.phase === "final_answer")));
+                const shouldContinueProgram = hasProgrammaticToolCalling(input.tools) &&
+                    json.status === "completed" &&
+                    !hasToolCalls &&
+                    !hasFinalMessage &&
+                    (json.output ?? []).some((item) => item?.type === "program" || item?.type === "program_output");
+                if (!shouldContinueProgram) {
+                    return {
+                        messages: [assistantMessage],
+                        text: extractMessageText(assistantMessage),
+                        audio: extractAudioOutputs(assistantMessage),
+                        images: extractResponsesImageOutputs(json, responsesImageGenerationConfig(input.tools)?.outputFormat),
+                        finishReason: normalizeResponsesFinishReason(json.status, hasToolCalls, hasRefusal),
+                        providerFinishReason: json.status,
+                        usage: accumulatedUsage,
+                        ...(ptc ? { providerRequestCount } : {}),
+                        rawResponse: json
+                    };
+                }
+                if (responseBodyOptions.store === false) {
+                    statelessInternalOutputs = completeStatelessOutput;
+                    nextInput = [...nextInput, ...currentOutput];
+                }
+                else {
+                    nextPreviousResponseId = json.id;
+                    nextInput = [];
+                }
             }
+            throw failure("OPENAI_PTC_REQUEST_LIMIT");
+        }
+        catch (error) {
+            if (!ptc)
+                throw error;
+            if (error instanceof ProviderToolCallError && error.providerRequestCount !== undefined)
+                throw error;
+            // Never replay a dispatched program; the receipt distinguishes a confirmed
+            // prefix from a failed/uncertain request and intentionally omits raw payloads.
+            throw failure(error instanceof ProviderToolCallError ? error.diagnosticCode : "OPENAI_PTC_REQUEST_FAILED", error);
         }
-        throw new ProviderHTTPError("OpenAI Programmatic Tool Calling exceeded 8 internal continuations.", 500);
     }
     async generate(input) {
         const { signal, cleanup } = getRequestOptions(input);
@@ -1565,7 +1607,7 @@ class OpenAILanguageModel {
                     messages: mapMessages(input.messages, input.toolResultFormat),
                     tools: mapTools(input.tools),
                     ...(input.toolChoice ? { tool_choice: mapToolChoice(input.toolChoice) } : {}),
-                    response_format: mapStructuredOutput(input),
+                    response_format: mapStructuredOutput(input) ?? options.bodyOptions.response_format,
                     temperature: input.temperature,
                     ...(input.reasoning ? {} : { max_tokens: input.maxTokens }),
                     ...mapChatReasoning(input),
@@ -1594,19 +1636,18 @@ class OpenAILanguageModel {
         const options = resolveOpenAILanguageRequestOptions(input.providerOptions, this.apiKey);
         if (this.usesResponsesAPI(input, options)) {
             const responseBodyOptions = openAIResponsesBodyOptions(options.bodyOptions, this.modelId);
-            assertResponsesToolsSupported(this.modelId, input.tools);
-            assertOpenAIResponsesOptionsSupported(this.modelId, responseBodyOptions);
+            assertResponsesToolsSupported(this.modelId, input.tools, this.capabilities.agentCapabilities);
+            assertOpenAIResponsesOptionsSupported(this.modelId, responseBodyOptions, this.capabilities.agentCapabilities);
             const { signal, cleanup } = getRequestOptions(input);
             if (hasProgrammaticToolCalling(input.tools)) {
-                const result = await this.generateViaResponses(input, signal, options);
-                return (async function* () {
-                    try {
-                        yield* streamGenerateResult(result);
-                    }
-                    finally {
-                        cleanup();
-                    }
-                })();
+                try {
+                    const result = await this.generateViaResponses(input, signal, options);
+                    return streamGenerateResult(result);
+                }
+                finally {
+                    // PTC is fully materialized before an iterator is returned.
+                    cleanup();
+                }
             }
             const previousResponse = responseBodyOptions.store === false ? undefined : getProviderResponseId(input.messages);
             const messages = previousResponse && previousResponse.index < input.messages.length - 1
@@ -1623,7 +1664,7 @@ class OpenAILanguageModel {
                     ...(messages.length ? { input: toResponsesInput(messages, input.toolResultFormat, input.messages) } : {}),
                     tools: mapResponsesTools(input.tools),
                     ...(input.toolChoice ? { tool_choice: mapResponsesToolChoice(input.toolChoice) } : {}),
-                    text: mapResponsesStructuredOutput(input),
+                    text: mapResponsesStructuredOutput(input) ?? responseBodyOptions.text,
                     temperature: input.temperature,
                     max_output_tokens: input.maxTokens,
                     ...mapResponsesReasoning(input, responseBodyOptions.reasoning),
@@ -1652,7 +1693,7 @@ class OpenAILanguageModel {
                 messages: mapMessages(input.messages, input.toolResultFormat),
                 tools: mapTools(input.tools),
                 ...(input.toolChoice ? { tool_choice: mapToolChoice(input.toolChoice) } : {}),
-                response_format: mapStructuredOutput(input),
+                response_format: mapStructuredOutput(input) ?? options.bodyOptions.response_format,
                 temperature: input.temperature,
                 ...(input.reasoning ? {} : { max_tokens: input.maxTokens }),
                 ...mapChatReasoning(input),
@@ -1751,7 +1792,7 @@ export const createOpenAI = (options = {}) => {
         languageModel: (modelId) => {
             if (modelId.startsWith("gpt-live-"))
                 throw new UnsupportedFeatureError("GPT-Live is a voice model; use openai.realtimeModel(modelId).");
-            return new OpenAILanguageModel(modelId, apiKey, baseURL, fetcher, responseLimits);
+            return new OpenAILanguageModel(modelId, apiKey, baseURL, fetcher, responseLimits, options);
         },
         embeddingModel: (modelId) => new OpenAIEmbeddingModel(modelId, apiKey, baseURL, fetcher),
         transcriptionModel: (modelId) => new OpenAITranscriptionModel(modelId, apiKey, baseURL, fetcher, responseLimits),