@zhivex-ai/openai 0.13.6 → 0.14.0

package/dist/index.js

@@ -1,10 +1,14 @@
+import { jsonHeaders, parseJson, RESERVED_REQUEST_HEADERS } from "./http.js";
+import { OpenAIRealtimeModel, openAIRealtimeMcpMetadataKey, resolveOpenAIRealtimeHeaders } from "./realtime.js";
+export { openAIRealtimeMcpMetadataKey } from "./realtime.js";
+import { OpenAIEmbeddingModel, OpenAITranscriptionModel, OpenAISpeechModel, toUint8Array } from "./resource-models.js";
 import { OpenAIAgentsClient } from "./agents.js";
 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 { capabilities, groundedCapabilities, inferOpenAIRealtimeMode, supportsOpenAIModernResponses, isOpenAIAstraModel, isOpenAISolLunaModel, modelCapabilities, openAIRealtimeSupportsImageInput, realtimeCapabilities, speechCapabilities, supportsOpenAIApplyPatchAndSkills, supportsOpenAIShell, transcriptionCapabilities, } from "./capabilities.js";
-import { imageInputToDataUrl, CallbackRealtimeSession, ConfigurationError, ProviderHTTPError, ProviderResponseTooLargeError, ProviderToolCallError, assertTrustedEndpoint, decodeBase64WithLimit, readBodyWithLimit, readErrorBodyWithLimit, readJsonWithLimit, resolveAudioResponseLimits, openWebSocketConnection, hostedTool, providerDataPart, UnsupportedFeatureError, createProviderAdapter, encodeAudioFrame, encodeMediaFrame, isCallableToolDefinition, isHostedToolDefinition, normalizeFinishReason, streamSSE, toToolSet, toolResultPayload, withRetry, withResponseRetry, withTimeoutSignal } from "@zhivex-ai/core/provider";
+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;
 const DEFAULT_HOSTED_IMAGE_TOTAL_BYTES = 128 * MIB;
@@ -59,42 +63,6 @@ const assertOpenAIToolPathInsideRoot = async (rootDir, targetPath, label) => {
     }
     return target;
 };
-export const openAIRealtimeMcpMetadataKey = "openai.realtime_mcp";
-const jsonHeaders = (apiKey) => ({
-    "content-type": "application/json",
-    authorization: `Bearer ${apiKey}`
-});
-const OPENAI_JSON_RESPONSE_MAX_BYTES = 128 * 1024 * 1024;
-const OPENAI_REALTIME_AUDIO_MAX_BYTES = 16 * 1024 * 1024;
-const RESERVED_REQUEST_HEADERS = new Set([
-    "authorization",
-    "content-type",
-    "content-length",
-    "host",
-    "connection",
-    "transfer-encoding"
-]);
-const resolveOpenAIRealtimeHeaders = (apiKey, providerOptions, includeContentType = false) => {
-    const rawHeaders = providerOptions?.headers;
-    const customHeaders = rawHeaders && typeof rawHeaders === "object" && !Array.isArray(rawHeaders)
-        ? { ...rawHeaders }
-        : {};
-    const safetyIdentifier = providerOptions?.safety_identifier;
-    for (const key of Object.keys(customHeaders)) {
-        const normalizedKey = key.toLowerCase();
-        if (RESERVED_REQUEST_HEADERS.has(normalizedKey) ||
-            (typeof safetyIdentifier === "string" && safetyIdentifier && normalizedKey === "openai-safety-identifier")) {
-            delete customHeaders[key];
-        }
-    }
-    return {
-        ...(includeContentType ? jsonHeaders(apiKey) : { authorization: `Bearer ${apiKey}` }),
-        ...customHeaders,
-        ...(typeof safetyIdentifier === "string" && safetyIdentifier
-            ? { "OpenAI-Safety-Identifier": safetyIdentifier }
-            : {})
-    };
-};
 const resolveOpenAILanguageRequestOptions = (providerOptions, apiKey) => {
     const bodyOptions = { ...(providerOptions ?? {}) };
     const apiMode = bodyOptions.apiMode ?? "auto";
@@ -139,22 +107,7 @@ const openAIResponsesBodyOptions = (options, modelId) => options.store === false
     }
     : options;
 const getRequestOptions = (input) => withTimeoutSignal(input);
-const toUint8Array = (data) => {
-    if (data instanceof Uint8Array) {
-        return data;
-    }
-    if (data instanceof ArrayBuffer) {
-        return new Uint8Array(data);
-    }
-    return Uint8Array.from(Buffer.from(data, "base64"));
-};
 const toBase64 = (data) => typeof data === "string" ? data : Buffer.from(data instanceof Uint8Array ? data : new Uint8Array(data)).toString("base64");
-const createAudioFile = (audio) => {
-    const bytes = toUint8Array(audio.data);
-    return new File([bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength)], audio.filename ?? "audio", {
-        type: audio.mediaType
-    });
-};
 const inferOpenAIAudioFormat = (mediaType, explicitFormat) => {
     if (explicitFormat) {
         return explicitFormat;
@@ -180,20 +133,6 @@ const inferOpenAIAudioFormat = (mediaType, explicitFormat) => {
     }
     return normalized?.replace(/^audio\//, "") || mediaType;
 };
-const parseJson = async (response, options = {}) => {
-    if (!response.ok) {
-        const body = await readErrorBodyWithLimit(response, options.errorBodyBytes);
-        throw new ProviderHTTPError(`OpenAI request failed with status ${response.status}.`, response.status, {
-            responseBody: body
-        });
-    }
-    return readJsonWithLimit(response, {
-        maxBytes: options.maxBytes ?? OPENAI_JSON_RESPONSE_MAX_BYTES,
-        provider: options.provider ?? "openai",
-        endpoint: options.endpoint,
-        abort: options.abort
-    });
-};
 const isOpenAIPromptCacheBreakpointPart = (part) => part.type === "provider-data" &&
     part.provider === "openai" &&
     part.data !== null &&
@@ -331,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) {
@@ -344,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.`);
     }
 };
@@ -389,28 +327,6 @@ const mapTools = (input) => input
         };
     })
     : undefined;
-const mapRealtimeTools = (input) => input
-    ? Object.values(input).map((tool) => {
-        if (isCallableToolDefinition(tool)) {
-            return {
-                type: "function",
-                name: tool.name,
-                description: tool.description,
-                parameters: toJSONSchema(tool.schema)
-            };
-        }
-        if (tool.provider && tool.provider !== "openai") {
-            throw new UnsupportedFeatureError(`Provider "openai" does not support hosted tools declared for provider "${tool.provider}".`);
-        }
-        if (tool.type !== "mcp") {
-            throw new UnsupportedFeatureError(`Provider "openai" Realtime does not support the hosted tool type "${tool.type}". Use function or MCP tools.`);
-        }
-        return {
-            type: tool.type,
-            ...(tool.config && typeof tool.config === "object" ? tool.config : {})
-        };
-    })
-    : undefined;
 const mapResponsesTools = (input) => input
     ? Object.values(input).map((tool) => {
         if (isCallableToolDefinition(tool)) {
@@ -461,359 +377,6 @@ const mapResponsesToolChoice = (toolChoice) => {
         name: toolChoice.toolName
     };
 };
-const mapRealtimeToolChoice = (toolChoice) => {
-    if (!toolChoice || typeof toolChoice === "string") {
-        return toolChoice;
-    }
-    return {
-        type: "function",
-        name: toolChoice.toolName
-    };
-};
-const mapRealtimeProviderOptions = (providerOptions) => {
-    if (!providerOptions) {
-        return {};
-    }
-    return Object.fromEntries(Object.entries(providerOptions).filter(([key]) => !["headers", "safety_identifier", "realtime_url", "realtime_query", "expires_after"].includes(key)));
-};
-const mapRealtimeAudioFormat = (mediaType, sampleRateHz) => mediaType || sampleRateHz
-    ? {
-        ...(mediaType ? { type: mediaType } : {}),
-        ...(sampleRateHz ? { rate: sampleRateHz } : {})
-    }
-    : undefined;
-const mapRealtimeSessionConfig = (config, modelId) => {
-    const mode = inferOpenAIRealtimeMode(modelId ?? "", config.mode);
-    const tools = mapRealtimeTools(toToolSet(config.tools));
-    const audio = {
-        input: {
-            format: mapRealtimeAudioFormat(config.inputAudioMediaType, config.inputSampleRateHz),
-            transcription: mode === "transcription" || config.inputTranscription
-                ? {
-                    model: config.inputTranscription?.model ?? (mode === "transcription" ? modelId : undefined),
-                    language: config.inputTranscription?.language,
-                    prompt: config.inputTranscription?.prompt,
-                    delay: config.inputTranscription?.delay
-                }
-                : undefined,
-            noise_reduction: config.noiseReduction ?? undefined,
-            turn_detection: config.turnDetection ?? undefined
-        },
-        ...(mode === "transcription"
-            ? {}
-            : {
-                output: {
-                    format: mapRealtimeAudioFormat(config.outputAudioMediaType, config.outputSampleRateHz),
-                    voice: config.voice
-                }
-            })
-    };
-    return {
-        type: mode === "transcription" ? "transcription" : "realtime",
-        model: modelId,
-        instructions: config.translation?.instructions ?? config.instructions,
-        output_modalities: mode === "transcription" ? undefined : config.outputAudioMediaType || config.voice || mode === "translation" ? ["audio"] : ["text"],
-        tools: mode === "conversation" ? tools : undefined,
-        tool_choice: mode === "conversation" && config.toolChoice ? mapRealtimeToolChoice(config.toolChoice) : undefined,
-        reasoning: mode === "conversation" && config.reasoning?.effort
-            ? {
-                effort: config.reasoning.effort
-            }
-            : undefined,
-        include: config.inputTranscription?.includeLogprobs && mode === "transcription" ? ["item.input_audio_transcription.logprobs"] : undefined,
-        translation: mode === "translation"
-            ? {
-                target_language: config.translation?.targetLanguage,
-                source_language: config.translation?.sourceLanguage
-            }
-            : undefined,
-        audio,
-        ...mapRealtimeProviderOptions(config.providerOptions)
-    };
-};
-const openAIRealtimeURL = (baseURL, modelId, mode, providerOptions) => {
-    const override = providerOptions?.realtime_url;
-    if (typeof override === "string" && override) {
-        return override;
-    }
-    const url = new URL(baseURL);
-    url.protocol = url.protocol === "https:" ? "wss:" : url.protocol === "http:" ? "ws:" : url.protocol;
-    const endpoint = mode === "translation" ? "realtime/translations" : mode === "transcription" ? "realtime/transcription_sessions" : "realtime";
-    url.pathname = `${url.pathname.replace(/\/+$/, "")}/${endpoint}`;
-    url.searchParams.set("model", modelId);
-    const extraQuery = providerOptions?.realtime_query;
-    if (extraQuery && typeof extraQuery === "object" && !Array.isArray(extraQuery)) {
-        for (const [key, value] of Object.entries(extraQuery)) {
-            if (value != null) {
-                url.searchParams.set(key, String(value));
-            }
-        }
-    }
-    return url.toString();
-};
-const parseRealtimeProviderMetadata = (payload) => payload;
-const parseRealtimeJsonValue = (value) => {
-    if (typeof value === "string") {
-        try {
-            return JSON.parse(value);
-        }
-        catch {
-            return value;
-        }
-    }
-    return value == null ? null : value;
-};
-const openAIRealtimeMcpProviderDataEvent = (payload, data) => [
-    {
-        type: "realtime-provider-data",
-        provider: "openai",
-        data: {
-            ...data,
-            raw_event: payload
-        }
-    }
-];
-const openAIRealtimeMcpCommonData = (payload, item) => {
-    const itemId = typeof payload.item_id === "string" ? payload.item_id : typeof item?.id === "string" ? item.id : undefined;
-    const serverLabel = typeof payload.server_label === "string"
-        ? payload.server_label
-        : typeof item?.server_label === "string"
-            ? item.server_label
-            : undefined;
-    const name = typeof payload.name === "string" ? payload.name : typeof item?.name === "string" ? item.name : undefined;
-    return {
-        ...(itemId ? { item_id: itemId } : {}),
-        ...(serverLabel ? { server_label: serverLabel } : {}),
-        ...(name ? { name } : {})
-    };
-};
-const parseOpenAIRealtimeEvent = (payload) => {
-    const type = String(payload.type ?? "");
-    if (type === "session.created" || type === "session.updated") {
-        return [];
-    }
-    if (type === "mcp_list_tools.in_progress" || type === "mcp_list_tools.completed" || type === "mcp_list_tools.failed") {
-        const status = type.slice("mcp_list_tools.".length);
-        return openAIRealtimeMcpProviderDataEvent(payload, {
-            type: "mcp_list_tools",
-            status,
-            ...openAIRealtimeMcpCommonData(payload),
-            ...(payload.error !== undefined ? { error: parseRealtimeJsonValue(payload.error) } : {})
-        });
-    }
-    if (type === "conversation.item.done") {
-        const item = payload.item && typeof payload.item === "object" ? payload.item : undefined;
-        if (item?.type === "mcp_list_tools") {
-            return openAIRealtimeMcpProviderDataEvent(payload, {
-                type: "mcp_list_tools",
-                status: "completed",
-                ...openAIRealtimeMcpCommonData(payload, item),
-                ...(item.tools !== undefined ? { tools: parseRealtimeJsonValue(item.tools) } : {})
-            });
-        }
-        if (item?.type === "mcp_approval_request") {
-            const approvalRequestId = typeof item.id === "string" ? item.id : undefined;
-            return openAIRealtimeMcpProviderDataEvent(payload, {
-                type: "mcp_approval_request",
-                status: "approval_required",
-                ...openAIRealtimeMcpCommonData(payload, item),
-                ...(approvalRequestId ? { approval_request_id: approvalRequestId } : {}),
-                ...(item.arguments !== undefined ? { arguments: parseRealtimeJsonValue(item.arguments) } : {})
-            });
-        }
-        if (item?.type === "mcp_approval_response") {
-            const approve = item.approve === true;
-            return openAIRealtimeMcpProviderDataEvent(payload, {
-                type: "mcp_approval_response",
-                status: approve ? "approved" : "rejected",
-                approve,
-                ...openAIRealtimeMcpCommonData(payload, item),
-                ...(typeof item.approval_request_id === "string" ? { approval_request_id: item.approval_request_id } : {}),
-                ...(typeof item.reason === "string" ? { reason: item.reason } : {})
-            });
-        }
-    }
-    if (type === "response.mcp_call_arguments.delta" || type === "response.mcp_call_arguments.done") {
-        const isDone = type.endsWith(".done");
-        return openAIRealtimeMcpProviderDataEvent(payload, {
-            type: "mcp_call",
-            status: isDone ? "arguments_done" : "arguments_delta",
-            ...openAIRealtimeMcpCommonData(payload),
-            ...(isDone && payload.arguments !== undefined
-                ? { arguments: parseRealtimeJsonValue(payload.arguments) }
-                : payload.delta !== undefined
-                    ? { delta: parseRealtimeJsonValue(payload.delta) }
-                    : {})
-        });
-    }
-    if (type === "response.mcp_call.in_progress" || type === "response.mcp_call.completed" || type === "response.mcp_call.failed") {
-        const status = type.slice("response.mcp_call.".length);
-        return openAIRealtimeMcpProviderDataEvent(payload, {
-            type: "mcp_call",
-            status,
-            ...openAIRealtimeMcpCommonData(payload),
-            ...(payload.output !== undefined ? { output: parseRealtimeJsonValue(payload.output) } : {}),
-            ...(payload.error !== undefined ? { error: parseRealtimeJsonValue(payload.error) } : {})
-        });
-    }
-    if (type === "response.output_item.done") {
-        const item = payload.item && typeof payload.item === "object" ? payload.item : undefined;
-        if (item?.type === "mcp_call") {
-            return openAIRealtimeMcpProviderDataEvent(payload, {
-                type: "mcp_call",
-                status: item.status === "failed" ? "failed" : "completed",
-                ...openAIRealtimeMcpCommonData(payload, item),
-                ...(item.arguments !== undefined ? { arguments: parseRealtimeJsonValue(item.arguments) } : {}),
-                ...(item.output !== undefined ? { output: parseRealtimeJsonValue(item.output) } : {}),
-                ...(item.error !== undefined ? { error: parseRealtimeJsonValue(item.error) } : {}),
-                ...(typeof item.approval_request_id === "string" ? { approval_request_id: item.approval_request_id } : {})
-            });
-        }
-    }
-    if (type === "response.text.delta" || type === "response.output_text.delta") {
-        return [
-            {
-                type: "realtime-text-delta",
-                textDelta: String(payload.delta ?? ""),
-                itemId: typeof payload.item_id === "string" ? payload.item_id : undefined,
-                responseId: typeof payload.response_id === "string" ? payload.response_id : undefined,
-                role: "assistant",
-                providerMetadata: parseRealtimeProviderMetadata(payload)
-            }
-        ];
-    }
-    if (type === "response.audio.delta" || type === "response.output_audio.delta") {
-        return [
-            {
-                type: "realtime-audio-output",
-                audio: decodeBase64WithLimit(String(payload.delta ?? ""), {
-                    maxBytes: OPENAI_REALTIME_AUDIO_MAX_BYTES,
-                    provider: "openai",
-                    endpoint: "realtime"
-                }),
-                mediaType: typeof payload.media_type === "string" ? payload.media_type : "audio/pcm",
-                sampleRateHz: typeof payload.sample_rate_hz === "number" ? payload.sample_rate_hz : undefined,
-                channels: typeof payload.channels === "number" ? payload.channels : undefined,
-                itemId: typeof payload.item_id === "string" ? payload.item_id : undefined,
-                responseId: typeof payload.response_id === "string" ? payload.response_id : undefined,
-                providerMetadata: parseRealtimeProviderMetadata(payload)
-            }
-        ];
-    }
-    if (type === "conversation.item.input_audio_transcription.delta" || type === "input_audio_buffer.transcription.delta") {
-        return [
-            {
-                type: "realtime-transcript",
-                text: String(payload.delta ?? ""),
-                role: "user",
-                isFinal: false,
-                itemId: typeof payload.item_id === "string" ? payload.item_id : undefined,
-                providerMetadata: parseRealtimeProviderMetadata(payload)
-            }
-        ];
-    }
-    if (type === "conversation.item.input_audio_transcription.completed" || type === "input_audio_buffer.transcription.completed") {
-        return [
-            {
-                type: "realtime-transcript",
-                text: String(payload.transcript ?? ""),
-                role: "user",
-                isFinal: true,
-                itemId: typeof payload.item_id === "string" ? payload.item_id : undefined,
-                providerMetadata: parseRealtimeProviderMetadata(payload)
-            }
-        ];
-    }
-    if (type === "response.audio_transcript.delta" || type === "response.audio_transcription.delta" || type === "response.output_audio_transcript.delta") {
-        return [
-            {
-                type: "realtime-transcript",
-                text: String(payload.delta ?? ""),
-                role: "assistant",
-                isFinal: false,
-                itemId: typeof payload.item_id === "string" ? payload.item_id : undefined,
-                responseId: typeof payload.response_id === "string" ? payload.response_id : undefined,
-                providerMetadata: parseRealtimeProviderMetadata(payload)
-            }
-        ];
-    }
-    if (type === "response.audio_transcript.done" || type === "response.audio_transcription.done" || type === "response.output_audio_transcript.done") {
-        return [
-            {
-                type: "realtime-transcript",
-                text: String(payload.transcript ?? ""),
-                role: "assistant",
-                isFinal: true,
-                itemId: typeof payload.item_id === "string" ? payload.item_id : undefined,
-                responseId: typeof payload.response_id === "string" ? payload.response_id : undefined,
-                providerMetadata: parseRealtimeProviderMetadata(payload)
-            }
-        ];
-    }
-    if (type === "response.function_call_arguments.done" || type === "response.output_item.done") {
-        const name = typeof payload.name === "string"
-            ? payload.name
-            : payload.item && typeof payload.item === "object" && typeof payload.item.name === "string"
-                ? String(payload.item.name)
-                : undefined;
-        const callId = typeof payload.call_id === "string"
-            ? payload.call_id
-            : payload.item && typeof payload.item === "object" && typeof payload.item.call_id === "string"
-                ? String(payload.item.call_id)
-                : undefined;
-        const rawArgs = typeof payload.arguments === "string"
-            ? payload.arguments
-            : payload.item && typeof payload.item === "object" && typeof payload.item.arguments === "string"
-                ? String(payload.item.arguments)
-                : "{}";
-        if (!name || !callId) {
-            return [];
-        }
-        return [
-            {
-                type: "realtime-tool-call",
-                toolCall: {
-                    id: callId,
-                    name,
-                    input: JSON.parse(rawArgs || "{}")
-                }
-            }
-        ];
-    }
-    if (type === "response.done") {
-        return [
-            {
-                type: "realtime-response-complete",
-                reason: typeof payload.status === "string" ? payload.status : undefined,
-                providerMetadata: parseRealtimeProviderMetadata(payload)
-            }
-        ];
-    }
-    if (type === "error") {
-        const error = payload.error && typeof payload.error === "object" ? payload.error : undefined;
-        return [
-            {
-                type: "realtime-error",
-                message: typeof payload.message === "string"
-                    ? payload.message
-                    : typeof error?.message === "string"
-                        ? error.message
-                        : "Realtime API error.",
-                providerMetadata: parseRealtimeProviderMetadata(payload)
-            }
-        ];
-    }
-    if (type === "session.end") {
-        return [
-            {
-                type: "realtime-end",
-                reason: "session-end",
-                providerMetadata: parseRealtimeProviderMetadata(payload)
-            }
-        ];
-    }
-    return [];
-};
 const mapStructuredOutput = (input) => {
     if (!input.structuredOutput || input.structuredOutput.mode !== "native") {
         return undefined;
@@ -1855,45 +1418,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) {
@@ -1901,12 +1462,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)
@@ -1927,7 +1488,7 @@ class OpenAILanguageModel {
                     ...(nextInput.length ? { input: nextInput } : {}),
                     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)
@@ -2001,7 +1562,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),
@@ -2030,8 +1591,8 @@ 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);
@@ -2059,7 +1620,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),
@@ -2088,7 +1649,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),
@@ -2098,61 +1659,7 @@ class OpenAILanguageModel {
         }), { ...input, abortSignal: signal }, "OpenAI").catch((error) => { cleanup(); throw error; });
         return (async function* () {
             try {
-                const toolBuffers = new Map();
-                let lastFinishReason;
-                let lastUsage;
-                for await (const event of streamSSE(response)) {
-                    if (event.data === "[DONE]") {
-                        break;
-                    }
-                    const json = JSON.parse(event.data);
-                    const choice = json.choices?.[0];
-                    const delta = choice?.delta;
-                    if (delta?.content) {
-                        yield { type: "text-delta", textDelta: delta.content };
-                    }
-                    for (const toolCall of delta?.tool_calls ?? []) {
-                        const index = typeof toolCall.index === "number" && Number.isSafeInteger(toolCall.index) && toolCall.index >= 0
-                            ? toolCall.index
-                            : 0;
-                        const existing = toolBuffers.get(index) ?? {
-                            id: toolCall.id ?? `${index}`,
-                            name: toolCall.function?.name ?? "",
-                            args: ""
-                        };
-                        existing.id = toolCall.id ?? existing.id;
-                        existing.name ||= toolCall.function?.name ?? "";
-                        existing.args += toolCall.function?.arguments ?? "";
-                        toolBuffers.set(index, existing);
-                    }
-                    if (choice?.finish_reason === "tool_calls") {
-                        for (const [, toolCall] of [...toolBuffers.entries()].sort(([left], [right]) => left - right)) {
-                            yield {
-                                type: "tool-call",
-                                toolCall: {
-                                    id: toolCall.id,
-                                    name: toolCall.name,
-                                    input: JSON.parse(toolCall.args || "{}")
-                                }
-                            };
-                        }
-                        toolBuffers.clear();
-                    }
-                    if (choice?.finish_reason) {
-                        lastFinishReason = choice.finish_reason;
-                    }
-                    if (json.usage) {
-                        lastUsage = json.usage;
-                    }
-                }
-                if (lastFinishReason || lastUsage) {
-                    yield {
-                        type: "finish",
-                        finishReason: normalizeFinishReason(lastFinishReason),
-                        providerFinishReason: lastFinishReason,
-                        usage: mapChatUsage(lastUsage)
-                    };
-                }
+                yield* streamChatCompletions(response, "openai");
             }
             finally {
                 cleanup();
@@ -2160,159 +1667,6 @@ class OpenAILanguageModel {
         })();
     }
 }
-class OpenAIEmbeddingModel {
-    modelId;
-    apiKey;
-    baseURL;
-    fetcher;
-    provider = "openai";
-    capabilities = capabilities;
-    constructor(modelId, apiKey, baseURL, fetcher) {
-        this.modelId = modelId;
-        this.apiKey = apiKey;
-        this.baseURL = baseURL;
-        this.fetcher = fetcher;
-    }
-    async embed(input) {
-        const { signal, cleanup } = withTimeoutSignal(input);
-        const values = input.values.map((value) => {
-            if (typeof value !== "string") {
-                throw new UnsupportedFeatureError('Provider "openai" does not support multimodal embedding values.');
-            }
-            return value;
-        });
-        try {
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/embeddings`, {
-                method: "POST",
-                headers: jsonHeaders(this.apiKey),
-                signal,
-                body: JSON.stringify({
-                    model: this.modelId,
-                    input: values
-                })
-            }), input);
-            const json = await parseJson(response);
-            return {
-                embeddings: json.data.map((entry) => entry.embedding),
-                usage: {
-                    inputTokens: json.usage?.prompt_tokens,
-                    totalTokens: json.usage?.total_tokens
-                },
-                rawResponse: json
-            };
-        }
-        finally {
-            cleanup();
-        }
-    }
-}
-class OpenAITranscriptionModel {
-    modelId;
-    apiKey;
-    baseURL;
-    fetcher;
-    responseLimits;
-    provider = "openai";
-    capabilities = transcriptionCapabilities;
-    constructor(modelId, apiKey, baseURL, fetcher, responseLimits = resolveAudioResponseLimits()) {
-        this.modelId = modelId;
-        this.apiKey = apiKey;
-        this.baseURL = baseURL;
-        this.fetcher = fetcher;
-        this.responseLimits = responseLimits;
-    }
-    async transcribe(input) {
-        const { signal, cleanup, abort } = withTimeoutSignal(input);
-        const form = new FormData();
-        for (const [key, value] of Object.entries(input.providerOptions ?? {})) {
-            if (["model", "file", "prompt", "language"].includes(key)) {
-                continue;
-            }
-            form.set(key, typeof value === "string" ? value : JSON.stringify(value));
-        }
-        form.set("model", this.modelId);
-        form.set("file", createAudioFile(input.audio));
-        if (input.prompt) {
-            form.set("prompt", input.prompt);
-        }
-        if (input.language) {
-            form.set("language", input.language);
-        }
-        try {
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/audio/transcriptions`, {
-                method: "POST",
-                redirect: "error",
-                headers: { authorization: `Bearer ${this.apiKey}` },
-                signal,
-                body: form
-            }), input);
-            const json = await parseJson(response, {
-                maxBytes: this.responseLimits.transcriptionBytes,
-                errorBodyBytes: this.responseLimits.errorBodyBytes,
-                endpoint: "audio/transcriptions",
-                abort
-            });
-            return {
-                text: json.text ?? "",
-                rawResponse: json
-            };
-        }
-        finally {
-            cleanup();
-        }
-    }
-}
-class OpenAISpeechModel {
-    modelId;
-    apiKey;
-    baseURL;
-    fetcher;
-    responseLimits;
-    provider = "openai";
-    capabilities = speechCapabilities;
-    constructor(modelId, apiKey, baseURL, fetcher, responseLimits = resolveAudioResponseLimits()) {
-        this.modelId = modelId;
-        this.apiKey = apiKey;
-        this.baseURL = baseURL;
-        this.fetcher = fetcher;
-        this.responseLimits = responseLimits;
-    }
-    async generateSpeech(input) {
-        const { signal, cleanup, abort } = withTimeoutSignal(input);
-        try {
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/audio/speech`, {
-                method: "POST",
-                headers: jsonHeaders(this.apiKey),
-                signal,
-                body: JSON.stringify({
-                    ...input.providerOptions,
-                    model: this.modelId,
-                    input: input.input,
-                    voice: input.voice ?? "alloy"
-                })
-            }), input);
-            if (!response.ok) {
-                const body = await readErrorBodyWithLimit(response, this.responseLimits.errorBodyBytes);
-                throw new ProviderHTTPError(`OpenAI request failed with status ${response.status}.`, response.status, {
-                    responseBody: body
-                });
-            }
-            return {
-                audio: await readBodyWithLimit(response, {
-                    maxBytes: this.responseLimits.speechBytes,
-                    provider: "openai",
-                    endpoint: "audio/speech",
-                    abort
-                }),
-                mediaType: response.headers.get("content-type") ?? "audio/mpeg",
-                rawResponse: undefined
-            };
-        }
-        finally {
-            cleanup();
-        }
-    }
-}
 class OpenAIGroundedLanguageModel {
     modelId;
     apiKey;
@@ -2360,234 +1714,6 @@ class OpenAIGroundedLanguageModel {
         }
     }
 }
-class OpenAIRealtimeModel {
-    modelId;
-    apiKey;
-    baseURL;
-    fetcher;
-    connectionFactory;
-    realtimeURL;
-    browserTokenURL;
-    allowUnsafeEndpoints;
-    provider = "openai";
-    capabilities;
-    constructor(modelId, apiKey, baseURL, fetcher, connectionFactory, realtimeURL, browserTokenURL, allowUnsafeEndpoints = false) {
-        this.modelId = modelId;
-        this.apiKey = apiKey;
-        this.baseURL = baseURL;
-        this.fetcher = fetcher;
-        this.connectionFactory = connectionFactory;
-        this.realtimeURL = realtimeURL;
-        this.browserTokenURL = browserTokenURL;
-        this.allowUnsafeEndpoints = allowUnsafeEndpoints;
-        this.capabilities = realtimeCapabilities(modelId);
-    }
-    resolveConfig(config) {
-        if (config.delegation)
-            throw new UnsupportedFeatureError("Client delegation requires a GPT-Live model.");
-        const mode = inferOpenAIRealtimeMode(this.modelId, config.mode);
-        if (mode !== "conversation" && (config.tools || config.toolChoice)) {
-            throw new UnsupportedFeatureError(`Provider "openai" model "${this.modelId}" does not support realtime tools in ${mode} mode.`);
-        }
-        if (mode === "translation" && !config.translation?.targetLanguage) {
-            throw new ConfigurationError('OpenAI realtime translation sessions require "translation.targetLanguage".');
-        }
-        if (mode === "transcription" && config.voice) {
-            throw new UnsupportedFeatureError(`Provider "openai" model "${this.modelId}" does not support realtime audio output in transcription mode.`);
-        }
-        return {
-            mode,
-            autoResponse: mode === "conversation",
-            ...config
-        };
-    }
-    async connect(config = {}, options) {
-        const initialConfig = this.resolveConfig(config);
-        const providerOptions = initialConfig.providerOptions;
-        const headers = resolveOpenAIRealtimeHeaders(this.apiKey, providerOptions);
-        const trustedRealtimeHost = new URL(this.realtimeURL ?? this.baseURL).hostname;
-        const realtimeEndpoint = assertTrustedEndpoint(this.realtimeURL ??
-            openAIRealtimeURL(this.baseURL, this.modelId, inferOpenAIRealtimeMode(this.modelId, initialConfig.mode), providerOptions), {
-            label: "OpenAI realtime endpoint",
-            protocols: ["wss"],
-            allowedHosts: [trustedRealtimeHost],
-            allowUnsafe: this.allowUnsafeEndpoints
-        }).toString();
-        const connection = await (this.connectionFactory ?? openWebSocketConnection)(realtimeEndpoint, headers, options);
-        const session = new CallbackRealtimeSession({
-            provider: this.provider,
-            modelId: this.modelId,
-            capabilities: this.capabilities,
-            config: initialConfig,
-            connection,
-            callbacks: {
-                parseEvent: parseOpenAIRealtimeEvent,
-                buildAudioPayloads: (frame, sessionConfig) => {
-                    const mode = inferOpenAIRealtimeMode(this.modelId, sessionConfig.mode);
-                    const payloads = [
-                        {
-                            type: "input_audio_buffer.append",
-                            audio: encodeAudioFrame(frame)
-                        }
-                    ];
-                    if (frame.isFinal) {
-                        payloads.push({ type: "input_audio_buffer.commit" });
-                        if (mode === "conversation" && (sessionConfig.autoResponse ?? true)) {
-                            payloads.push({ type: "response.create" });
-                        }
-                    }
-                    return payloads;
-                },
-                buildMediaPayloads: (frame) => {
-                    if (!openAIRealtimeSupportsImageInput(this.modelId)) {
-                        throw new UnsupportedFeatureError(`Provider "openai" model "${this.modelId}" does not support realtime image input.`);
-                    }
-                    if (!frame.mediaType.startsWith("image/")) {
-                        throw new UnsupportedFeatureError(`Provider "openai" only supports realtime image media input, but received "${frame.mediaType}".`);
-                    }
-                    return [
-                        {
-                            type: "conversation.item.create",
-                            item: {
-                                type: "message",
-                                role: "user",
-                                content: [
-                                    {
-                                        type: "input_image",
-                                        image_url: `data:${frame.mediaType};base64,${encodeMediaFrame(frame)}`
-                                    }
-                                ]
-                            }
-                        }
-                    ];
-                },
-                buildTextPayloads: (text, sessionConfig) => {
-                    const mode = inferOpenAIRealtimeMode(this.modelId, sessionConfig.mode);
-                    if (mode !== "conversation") {
-                        throw new UnsupportedFeatureError(`Provider "openai" model "${this.modelId}" does not support realtime text input in ${mode} mode.`);
-                    }
-                    const payloads = [
-                        {
-                            type: "conversation.item.create",
-                            item: {
-                                type: "message",
-                                role: "user",
-                                content: [{ type: "input_text", text }]
-                            }
-                        }
-                    ];
-                    if (sessionConfig.autoResponse ?? true) {
-                        payloads.push({ type: "response.create" });
-                    }
-                    return payloads;
-                },
-                buildToolResultPayloads: (result, sessionConfig) => {
-                    const mode = inferOpenAIRealtimeMode(this.modelId, sessionConfig.mode);
-                    if (mode !== "conversation") {
-                        throw new UnsupportedFeatureError(`Provider "openai" model "${this.modelId}" does not support realtime tools in ${mode} mode.`);
-                    }
-                    const mcpMetadata = result.providerMetadata?.[openAIRealtimeMcpMetadataKey];
-                    if (mcpMetadata && typeof mcpMetadata === "object" && !Array.isArray(mcpMetadata)) {
-                        const approval = mcpMetadata;
-                        if (approval.type === "mcp_approval_response" &&
-                            typeof approval.approval_request_id === "string" &&
-                            typeof approval.approve === "boolean") {
-                            return [
-                                {
-                                    type: "conversation.item.create",
-                                    item: {
-                                        ...(typeof approval.id === "string" ? { id: approval.id } : {}),
-                                        type: "mcp_approval_response",
-                                        approval_request_id: approval.approval_request_id,
-                                        approve: approval.approve,
-                                        ...(typeof approval.reason === "string" ? { reason: approval.reason } : {})
-                                    }
-                                }
-                            ];
-                        }
-                    }
-                    const payloads = [
-                        {
-                            type: "conversation.item.create",
-                            item: {
-                                type: "function_call_output",
-                                call_id: result.toolCallId,
-                                output: JSON.stringify(toolResultPayload(result))
-                            }
-                        }
-                    ];
-                    if (sessionConfig.autoResponse ?? true) {
-                        payloads.push({ type: "response.create" });
-                    }
-                    return payloads;
-                },
-                buildUpdatePayloads: (sessionConfig) => [
-                    {
-                        type: "session.update",
-                        session: mapRealtimeSessionConfig(this.resolveConfig(sessionConfig), this.modelId)
-                    }
-                ],
-                buildInitialPayloads: (sessionConfig) => [
-                    {
-                        type: "session.update",
-                        session: mapRealtimeSessionConfig(sessionConfig, this.modelId)
-                    }
-                ]
-            }
-        });
-        await session.initialize();
-        return session;
-    }
-    async createBrowserToken(config = {}, options) {
-        const resolvedConfig = this.resolveConfig(config);
-        const providerOptions = { ...(resolvedConfig.providerOptions ?? {}) };
-        const expiresAfter = providerOptions.expires_after;
-        delete providerOptions.expires_after;
-        const { signal, cleanup } = withTimeoutSignal({
-            abortSignal: options?.signal,
-            timeoutMs: options?.timeoutMs
-        });
-        try {
-            const response = await withRetry(() => this.fetcher(this.browserTokenURL ?? `${this.baseURL}/realtime/client_secrets`, {
-                method: "POST",
-                redirect: "error",
-                headers: resolveOpenAIRealtimeHeaders(this.apiKey, providerOptions, true),
-                body: JSON.stringify({
-                    ...(expiresAfter ? { expires_after: expiresAfter } : {}),
-                    session: mapRealtimeSessionConfig({
-                        ...resolvedConfig,
-                        providerOptions
-                    }, this.modelId)
-                }),
-                signal
-            }));
-            const payload = await parseJson(response);
-            const secret = payload.client_secret;
-            const value = secret && typeof secret === "object" && typeof secret.value === "string"
-                ? secret.value
-                : typeof payload.token === "string"
-                    ? payload.token
-                    : typeof payload.value === "string"
-                        ? payload.value
-                        : "";
-            const expiresAtMs = secret && typeof secret === "object" && typeof secret.expires_at_ms === "number"
-                ? secret.expires_at_ms
-                : typeof payload.expires_at_ms === "number"
-                    ? payload.expires_at_ms
-                    : typeof payload.expires_at === "number"
-                        ? payload.expires_at * 1000
-                        : undefined;
-            return {
-                value,
-                expiresAtMs,
-                rawResponse: payload
-            };
-        }
-        finally {
-            cleanup();
-        }
-    }
-}
 export const createOpenAI = (options = {}) => {
     const apiKey = options.apiKey ?? process.env.OPENAI_API_KEY;
     if (!apiKey) {
@@ -2622,7 +1748,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),