@zhivex-ai/openai 0.8.0 → 0.9.0

package/dist/index.js

@@ -1,5 +1,22 @@
 import { toJSONSchema, z } from "zod";
-import { CallbackRealtimeSession, ConfigurationError, ProviderHTTPError, openWebSocketConnection, hostedTool, providerDataPart, UnsupportedFeatureError, createProviderAdapter, encodeAudioFrame, encodeMediaFrame, isCallableToolDefinition, isHostedToolDefinition, normalizeFinishReason, streamSSE, toToolSet, toolResultPayload, withRetry, withTimeoutSignal } from "@zhivex-ai/core";
+import { createOpenAIImageGenerationModel, normalizeOpenAIImageGenerationCall, normalizeOpenAIImageGenerationPartialImage } from "./image-generation.js";
+import { CallbackRealtimeSession, ConfigurationError, ProviderHTTPError, ProviderResponseTooLargeError, readBodyWithLimit, readErrorBodyWithLimit, readJsonWithLimit, resolveAudioResponseLimits, openWebSocketConnection, hostedTool, providerDataPart, UnsupportedFeatureError, createProviderAdapter, encodeAudioFrame, encodeMediaFrame, isCallableToolDefinition, isHostedToolDefinition, normalizeFinishReason, streamSSE, toToolSet, toolResultPayload, withRetry, withTimeoutSignal } from "@zhivex-ai/core";
+const MIB = 1024 * 1024;
+const DEFAULT_HOSTED_IMAGE_EVENT_BYTES = 32 * MIB;
+const DEFAULT_HOSTED_IMAGE_TOTAL_BYTES = 128 * MIB;
+const HOSTED_IMAGE_EVENT_JSON_OVERHEAD_CHARS = MIB;
+const normalizeOpenAIResponseLimit = (value, fallback, name) => {
+    const resolved = value ?? fallback;
+    if (!Number.isSafeInteger(resolved) || resolved <= 0) {
+        throw new ConfigurationError(`The "${name}" response limit must be a positive safe integer.`);
+    }
+    return resolved;
+};
+const resolveOpenAIResponseLimits = (limits = {}) => ({
+    ...resolveAudioResponseLimits(limits),
+    hostedImageEventBytes: normalizeOpenAIResponseLimit(limits.hostedImageEventBytes, DEFAULT_HOSTED_IMAGE_EVENT_BYTES, "hostedImageEventBytes"),
+    hostedImageTotalBytes: normalizeOpenAIResponseLimit(limits.hostedImageTotalBytes, DEFAULT_HOSTED_IMAGE_TOTAL_BYTES, "hostedImageTotalBytes")
+});
 const openAIResponsesToolMetadataKey = "openai.responses_tool_type";
 const openAIResponsesFunctionConfigMetadataKey = "openai.responses_function_config";
 const openAIResponsesFunctionConfig = (tool) => {
@@ -27,6 +44,7 @@ const assertOpenAIToolPathInsideRoot = async (rootDir, targetPath, label) => {
     }
     return target;
 };
+export const openAIRealtimeMcpMetadataKey = "openai.realtime_mcp";
 const capabilities = {
     streaming: true,
     tools: true,
@@ -154,17 +172,38 @@ const inferOpenAIRealtimeMode = (modelId, mode) => {
     }
     return "conversation";
 };
-const openAIRealtimeSupportsImageInput = (modelId) => /^(?:gpt-realtime|gpt-realtime-mini|gpt-realtime-1\.5|gpt-realtime-2)(?:-\d{4}-\d{2}-\d{2}|@.*)?$/.test(modelId);
+const isOpenAIRealtimeReasoningModel = (modelId) => /^gpt-realtime-2(?:\.1(?:-mini)?)?(?:-\d{4}-\d{2}-\d{2}|@.*)?$/.test(modelId);
+const openAIRealtimeSupportsImageInput = (modelId) => /^(?:gpt-realtime|gpt-realtime-mini|gpt-realtime-1\.5|gpt-realtime-2(?:\.1(?:-mini)?)?)(?:-\d{4}-\d{2}-\d{2}|@.*)?$/.test(modelId);
 const realtimeCapabilities = (modelId) => ({
     ...capabilities,
     streaming: false,
+    structuredOutput: false,
+    jsonMode: false,
+    embeddings: false,
     audioInput: true,
     audioOutput: !isOpenAIRealtimeTranscriptionModel(modelId),
     tools: !isOpenAIRealtimeTranslationModel(modelId) && !isOpenAIRealtimeTranscriptionModel(modelId),
     toolChoice: !isOpenAIRealtimeTranslationModel(modelId) && !isOpenAIRealtimeTranscriptionModel(modelId),
     parallelToolCalls: !isOpenAIRealtimeTranslationModel(modelId) && !isOpenAIRealtimeTranscriptionModel(modelId),
     vision: openAIRealtimeSupportsImageInput(modelId),
-    reasoning: /^gpt-realtime-2(?:[-@]|$)/.test(modelId),
+    reasoning: isOpenAIRealtimeReasoningModel(modelId),
+    webSearch: false,
+    agentCapabilities: {
+        ...capabilities.agentCapabilities,
+        supportTier: isOpenAIRealtimeTranslationModel(modelId) || isOpenAIRealtimeTranscriptionModel(modelId) ? "tier-c" : "tier-a",
+        toolChoiceNone: !isOpenAIRealtimeTranslationModel(modelId) && !isOpenAIRealtimeTranscriptionModel(modelId),
+        approvalRequests: !isOpenAIRealtimeTranslationModel(modelId) && !isOpenAIRealtimeTranscriptionModel(modelId),
+        hostedWebSearch: false,
+        hostedFileSearch: false,
+        remoteMcp: !isOpenAIRealtimeTranslationModel(modelId) && !isOpenAIRealtimeTranscriptionModel(modelId),
+        computerUse: false,
+        codeExecution: false,
+        shell: false,
+        applyPatch: false,
+        toolSearch: false,
+        skills: false,
+        toolsets: false
+    },
     realtime: {
         sessions: true,
         audioInput: true,
@@ -178,6 +217,28 @@ const jsonHeaders = (apiKey) => ({
     "content-type": "application/json",
     authorization: `Bearer ${apiKey}`
 });
+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 (normalizedKey === "authorization" ||
+            normalizedKey === "content-type" ||
+            (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";
@@ -227,9 +288,12 @@ const toUint8Array = (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) => new File([toUint8Array(audio.data).buffer], audio.filename ?? "audio", {
-    type: audio.mediaType
-});
+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;
@@ -255,14 +319,21 @@ const inferOpenAIAudioFormat = (mediaType, explicitFormat) => {
     }
     return normalized?.replace(/^audio\//, "") || mediaType;
 };
-const parseJson = async (response) => {
+const parseJson = async (response, options = {}) => {
     if (!response.ok) {
-        const body = await response.text();
+        const body = await readErrorBodyWithLimit(response, options.errorBodyBytes);
         throw new ProviderHTTPError(`OpenAI request failed with status ${response.status}.`, response.status, {
             responseBody: body
         });
     }
-    return response.json();
+    return options.maxBytes
+        ? readJsonWithLimit(response, {
+            maxBytes: options.maxBytes,
+            provider: options.provider ?? "openai",
+            endpoint: options.endpoint,
+            abort: options.abort
+        })
+        : response.json();
 };
 const isOpenAIPromptCacheBreakpointPart = (part) => part.type === "provider-data" &&
     part.provider === "openai" &&
@@ -381,6 +452,25 @@ const localResponsesTools = (tools) => new Map(Object.values(tools ?? {})
     .filter(isCallableToolDefinition)
     .map((tool) => [openAILocalResponsesToolType(tool), tool.name])
     .filter((entry) => Boolean(entry[0])));
+const responsesImageGenerationConfig = (tools, limits) => {
+    const definition = Object.values(tools ?? {}).find((tool) => isHostedToolDefinition(tool) && tool.provider === "openai" && tool.type === "image_generation");
+    if (!definition || !isHostedToolDefinition(definition)) {
+        return undefined;
+    }
+    const outputFormat = definition.config && typeof definition.config === "object" &&
+        ["png", "jpeg", "webp"].includes(String(definition.config.output_format))
+        ? definition.config.output_format
+        : "png";
+    return {
+        outputFormat,
+        ...(limits
+            ? {
+                eventMaxBytes: limits.hostedImageEventBytes,
+                totalMaxBytes: limits.hostedImageTotalBytes
+            }
+            : {})
+    };
+};
 const assertResponsesToolsSupported = (modelId, tools) => {
     const currentCapabilities = modelCapabilities(modelId).agentCapabilities;
     for (const definition of Object.values(tools ?? {})) {
@@ -439,6 +529,28 @@ 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)) {
@@ -489,11 +601,20 @@ 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", "realtime_url", "realtime_query", "expires_after"].includes(key)));
+    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
     ? {
@@ -503,7 +624,7 @@ const mapRealtimeAudioFormat = (mediaType, sampleRateHz) => mediaType || sampleR
     : undefined;
 const mapRealtimeSessionConfig = (config, modelId) => {
     const mode = inferOpenAIRealtimeMode(modelId ?? "", config.mode);
-    const tools = mapTools(toToolSet(config.tools));
+    const tools = mapRealtimeTools(toToolSet(config.tools));
     const audio = {
         input: {
             format: mapRealtimeAudioFormat(config.inputAudioMediaType, config.inputSampleRateHz),
@@ -533,7 +654,7 @@ const mapRealtimeSessionConfig = (config, 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 ? mapToolChoice(config.toolChoice) : undefined,
+        tool_choice: mode === "conversation" && config.toolChoice ? mapRealtimeToolChoice(config.toolChoice) : undefined,
         reasoning: mode === "conversation" && config.reasoning?.effort
             ? {
                 effort: config.reasoning.effort
@@ -571,11 +692,124 @@ const openAIRealtimeURL = (baseURL, modelId, mode, providerOptions) => {
     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 [
             {
@@ -905,7 +1139,7 @@ const parseResponsesProviderData = (item) => {
     }
     const typedItem = item;
     if (typeof typedItem.type !== "string" ||
-        ["message", "function_call"].includes(typedItem.type)) {
+        ["message", "function_call", "image_generation_call"].includes(typedItem.type)) {
         return undefined;
     }
     return item;
@@ -1149,6 +1383,10 @@ const parseResponsesAssistantMessage = (json, multiAgentEnabled = false, localTo
         parts
     };
 };
+const extractResponsesImageOutputs = (response, outputFormat = "png") => (Array.isArray(response.output) ? response.output : []).flatMap((item) => {
+    const normalized = normalizeOpenAIImageGenerationCall(item, outputFormat);
+    return normalized?.image ? [normalized.image] : [];
+});
 const normalizeResponsesFinishReason = (status, hasToolCalls, hasRefusal = false) => {
     if (hasToolCalls) {
         return "tool-calls";
@@ -1199,11 +1437,26 @@ const addTokenUsage = (left, right) => {
         totalTokens: sum(left.totalTokens, right.totalTokens)
     };
 };
-const streamResponses = async function* (response, multiAgentEnabled = false, localTools = new Map()) {
+const streamResponses = async function* (response, multiAgentEnabled = false, localTools = new Map(), imageGeneration) {
     const toolBuffers = new Map();
     const outputAgents = new Map();
+    const hostedImageEventMaxBytes = imageGeneration?.eventMaxBytes ?? DEFAULT_HOSTED_IMAGE_EVENT_BYTES;
+    const hostedImageTotalMaxBytes = imageGeneration?.totalMaxBytes ?? DEFAULT_HOSTED_IMAGE_TOTAL_BYTES;
+    let hostedImageBytes = 0;
     let sawToolCalls = false;
     let sawRefusal = false;
+    const recordHostedImageBytes = (image) => {
+        const receivedBytes = hostedImageBytes + (image.data?.byteLength ?? 0);
+        if (receivedBytes > hostedImageTotalMaxBytes) {
+            throw new ProviderResponseTooLargeError({
+                maxBytes: hostedImageTotalMaxBytes,
+                receivedBytes,
+                provider: "openai",
+                endpoint: "hosted image generation stream"
+            });
+        }
+        hostedImageBytes = receivedBytes;
+    };
     const emitToolCall = (key) => {
         const toolCall = toolBuffers.get(key);
         if (!toolCall || toolCall.emitted || !toolCall.name) {
@@ -1221,12 +1474,31 @@ const streamResponses = async function* (response, multiAgentEnabled = false, lo
             }
         };
     };
-    for await (const event of streamSSE(response)) {
+    const maxHostedImageEventChars = Math.min(Number.MAX_SAFE_INTEGER, 4 * Math.ceil(hostedImageEventMaxBytes / 3) + HOSTED_IMAGE_EVENT_JSON_OVERHEAD_CHARS);
+    for await (const event of streamSSE(response, imageGeneration
+        ? { maxEventChars: maxHostedImageEventChars, maxBufferChars: maxHostedImageEventChars }
+        : undefined)) {
         if (event.data === "[DONE]") {
             return;
         }
         const json = JSON.parse(event.data);
         const type = json.type;
+        if (type === "response.image_generation_call.partial_image") {
+            const normalized = normalizeOpenAIImageGenerationPartialImage(json, imageGeneration?.outputFormat ?? "png", hostedImageEventMaxBytes);
+            if (normalized) {
+                recordHostedImageBytes(normalized.image);
+                yield {
+                    type: "image-generation",
+                    provider: "openai",
+                    image: normalized.image,
+                    partial: true,
+                    id: normalized.callId,
+                    index: normalized.partialImageIndex,
+                    providerMetadata: normalized.providerMetadata
+                };
+            }
+            continue;
+        }
         if (type === "error") {
             throw new ProviderHTTPError(`OpenAI Responses stream failed: ${json.error?.message ?? json.message ?? "unknown error"}`, 500, { responseBody: JSON.stringify(json) });
         }
@@ -1248,6 +1520,20 @@ const streamResponses = async function* (response, multiAgentEnabled = false, lo
         if (type === "response.output_item.added" || type === "response.output_item.done") {
             const item = json.item;
             let handledLocalToolCall = false;
+            if (item?.type === "image_generation_call" && type === "response.output_item.done") {
+                const normalized = normalizeOpenAIImageGenerationCall(item, imageGeneration?.outputFormat ?? "png", hostedImageEventMaxBytes);
+                if (normalized?.image) {
+                    recordHostedImageBytes(normalized.image);
+                    yield {
+                        type: "image-generation",
+                        provider: "openai",
+                        image: normalized.image,
+                        partial: false,
+                        id: normalized.id,
+                        providerMetadata: normalized.providerMetadata
+                    };
+                }
+            }
             if (typeof json.output_index === "number" && item?.type === "message") {
                 outputAgents.set(json.output_index, {
                     agentName: item.agent?.agent_name
@@ -1404,6 +1690,14 @@ const streamGenerateResult = async function* (result) {
             }
         }
     }
+    for (const image of result.images ?? []) {
+        yield {
+            type: "image-generation",
+            provider: "openai",
+            image,
+            partial: false
+        };
+    }
     yield {
         type: "finish",
         finishReason: result.finishReason,
@@ -1442,13 +1736,15 @@ class OpenAILanguageModel {
     apiKey;
     baseURL;
     fetcher;
+    responseLimits;
     provider = "openai";
     capabilities;
-    constructor(modelId, apiKey, baseURL, fetcher) {
+    constructor(modelId, apiKey, baseURL, fetcher, responseLimits) {
         this.modelId = modelId;
         this.apiKey = apiKey;
         this.baseURL = baseURL;
         this.fetcher = fetcher;
+        this.responseLimits = responseLimits;
         this.capabilities = modelCapabilities(modelId);
     }
     usesResponsesAPI(input, options) {
@@ -1524,6 +1820,7 @@ class OpenAILanguageModel {
                     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,
@@ -1623,9 +1920,10 @@ class OpenAILanguageModel {
                     stream: true
                 })
             }), input);
+            const imageGeneration = responsesImageGenerationConfig(input.tools, this.responseLimits);
             return (async function* () {
                 try {
-                    yield* streamResponses(response, options.multiAgentEnabled, localResponsesTools(input.tools));
+                    yield* streamResponses(response, options.multiAgentEnabled, localResponsesTools(input.tools), imageGeneration);
                 }
                 finally {
                     cleanup();
@@ -1751,17 +2049,25 @@ class OpenAITranscriptionModel {
     apiKey;
     baseURL;
     fetcher;
+    responseLimits;
     provider = "openai";
     capabilities = transcriptionCapabilities;
-    constructor(modelId, apiKey, baseURL, fetcher) {
+    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 } = withTimeoutSignal(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) {
@@ -1770,9 +2076,6 @@ class OpenAITranscriptionModel {
         if (input.language) {
             form.set("language", input.language);
         }
-        for (const [key, value] of Object.entries(input.providerOptions ?? {})) {
-            form.set(key, typeof value === "string" ? value : JSON.stringify(value));
-        }
         try {
             const response = await withRetry(() => this.fetcher(`${this.baseURL}/audio/transcriptions`, {
                 method: "POST",
@@ -1780,7 +2083,12 @@ class OpenAITranscriptionModel {
                 signal,
                 body: form
             }), input);
-            const json = await parseJson(response);
+            const json = await parseJson(response, {
+                maxBytes: this.responseLimits.transcriptionBytes,
+                errorBodyBytes: this.responseLimits.errorBodyBytes,
+                endpoint: "audio/transcriptions",
+                abort
+            });
             return {
                 text: json.text ?? "",
                 rawResponse: json
@@ -1796,16 +2104,18 @@ class OpenAISpeechModel {
     apiKey;
     baseURL;
     fetcher;
+    responseLimits;
     provider = "openai";
     capabilities = speechCapabilities;
-    constructor(modelId, apiKey, baseURL, fetcher) {
+    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 } = withTimeoutSignal(input);
+        const { signal, cleanup, abort } = withTimeoutSignal(input);
         try {
             const response = await withRetry(() => this.fetcher(`${this.baseURL}/audio/speech`, {
                 method: "POST",
@@ -1819,13 +2129,18 @@ class OpenAISpeechModel {
                 })
             }), input);
             if (!response.ok) {
-                const body = await response.text();
+                const body = await readErrorBodyWithLimit(response, this.responseLimits.errorBodyBytes);
                 throw new ProviderHTTPError(`OpenAI request failed with status ${response.status}.`, response.status, {
                     responseBody: body
                 });
             }
             return {
-                audio: new Uint8Array(await response.arrayBuffer()),
+                audio: await readBodyWithLimit(response, {
+                    maxBytes: this.responseLimits.speechBytes,
+                    provider: "openai",
+                    endpoint: "audio/speech",
+                    abort
+                }),
                 mediaType: response.headers.get("content-type") ?? "audio/mpeg",
                 rawResponse: undefined
             };
@@ -1921,11 +2236,10 @@ class OpenAIRealtimeModel {
     }
     async connect(config = {}, options) {
         const initialConfig = this.resolveConfig(config);
-        const headers = {
-            authorization: `Bearer ${this.apiKey}`
-        };
+        const providerOptions = initialConfig.providerOptions;
+        const headers = resolveOpenAIRealtimeHeaders(this.apiKey, providerOptions);
         const connection = await (this.connectionFactory ?? openWebSocketConnection)(this.realtimeURL ??
-            openAIRealtimeURL(this.baseURL, this.modelId, inferOpenAIRealtimeMode(this.modelId, initialConfig.mode), initialConfig.providerOptions), headers, options);
+            openAIRealtimeURL(this.baseURL, this.modelId, inferOpenAIRealtimeMode(this.modelId, initialConfig.mode), providerOptions), headers, options);
         const session = new CallbackRealtimeSession({
             provider: this.provider,
             modelId: this.modelId,
@@ -1998,6 +2312,26 @@ class OpenAIRealtimeModel {
                     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",
@@ -2037,7 +2371,7 @@ class OpenAIRealtimeModel {
         delete providerOptions.expires_after;
         const response = await withRetry(() => this.fetcher(this.browserTokenURL ?? `${this.baseURL}/realtime/client_secrets`, {
             method: "POST",
-            headers: jsonHeaders(this.apiKey),
+            headers: resolveOpenAIRealtimeHeaders(this.apiKey, providerOptions, true),
             body: JSON.stringify({
                 ...(expiresAfter ? { expires_after: expiresAfter } : {}),
                 session: mapRealtimeSessionConfig({
@@ -2079,12 +2413,14 @@ export const createOpenAI = (options = {}) => {
     }
     const baseURL = options.baseURL ?? "https://api.openai.com/v1";
     const fetcher = options.fetch ?? globalThis.fetch;
+    const responseLimits = resolveOpenAIResponseLimits(options.responseLimits);
     return createProviderAdapter({
         name: "openai",
-        languageModel: (modelId) => new OpenAILanguageModel(modelId, apiKey, baseURL, fetcher),
+        languageModel: (modelId) => new OpenAILanguageModel(modelId, apiKey, baseURL, fetcher, responseLimits),
         embeddingModel: (modelId) => new OpenAIEmbeddingModel(modelId, apiKey, baseURL, fetcher),
-        transcriptionModel: (modelId) => new OpenAITranscriptionModel(modelId, apiKey, baseURL, fetcher),
-        speechModel: (modelId) => new OpenAISpeechModel(modelId, apiKey, baseURL, fetcher),
+        transcriptionModel: (modelId) => new OpenAITranscriptionModel(modelId, apiKey, baseURL, fetcher, responseLimits),
+        speechModel: (modelId) => new OpenAISpeechModel(modelId, apiKey, baseURL, fetcher, responseLimits),
+        imageGenerationModel: (modelId) => createOpenAIImageGenerationModel({ modelId, apiKey, baseURL, fetch: fetcher }),
         realtimeModel: (modelId) => new OpenAIRealtimeModel(modelId, apiKey, baseURL, fetcher, options.realtimeConnectionFactory, options.realtimeURL, options.browserTokenURL),
         groundedLanguageModel: (modelId) => new OpenAIGroundedLanguageModel(modelId, apiKey, baseURL, fetcher),
         rawFetch: fetcher
@@ -2146,6 +2482,26 @@ export const openAIMcpApprovalResponse = (response) => providerDataPart("openai"
     type: "mcp_approval_response",
     ...response
 });
+export const openAIRealtimeMcpApprovalResult = (response) => ({
+    toolCallId: response.approvalRequestId,
+    toolName: response.name,
+    output: {
+        type: "mcp_approval_response",
+        approve: response.approve,
+        ...(response.reason ? { reason: response.reason } : {})
+    },
+    isError: false,
+    providerMetadata: {
+        [openAIRealtimeMcpMetadataKey]: {
+            type: "mcp_approval_response",
+            status: response.approve ? "approved" : "rejected",
+            approval_request_id: response.approvalRequestId,
+            approve: response.approve,
+            ...(response.itemId ? { id: response.itemId } : {}),
+            ...(response.reason ? { reason: response.reason } : {})
+        }
+    }
+});
 export const openAIPromptCacheBreakpoint = () => providerDataPart("openai", {
     type: "prompt_cache_breakpoint",
     mode: "explicit"
@@ -2294,4 +2650,5 @@ export const openAIApplyPatchTool = (config) => ({
     }),
     execute: async ({ operation }) => applyOpenAIPatchOperation(operation, config)
 });
+export * from "./image-generation.js";
 //# sourceMappingURL=index.js.map