@core-ai/openai 0.18.0 → 0.20.0

package/dist/{chunk-LVGNSX5F.js → chunk-MKAXZHMO.js}

@@ -1,7 +1,9 @@
 // src/model-capabilities.ts
 import {
   getRegisteredModelCapabilities,
+  MULTIMODAL_INPUT_MODALITIES,
   stripModelDateSuffix,
+  TEXT_ONLY_MODALITIES,
   UNKNOWN_MODEL
 } from "@core-ai/core-ai";
 var STANDARD_EFFORTS = [
@@ -27,7 +29,16 @@ var PRO_EFFORTS = [
   "max"
 ];
 var HIGH_EFFORT = ["high"];
-function createCapabilities(supportedEfforts, restrictsSamplingParams, maxTokensParameter = "max_completion_tokens") {
+var OPENAI_AUDIO_INPUT_MODALITIES = {
+  input: ["text", "audio"],
+  output: ["text"]
+};
+function createCapabilities({
+  supportedEfforts,
+  restrictsSamplingParams,
+  maxTokensParameter = "max_completion_tokens",
+  modalities = MULTIMODAL_INPUT_MODALITIES
+}) {
   return {
     reasoning: {
       mode: "optional",
@@ -35,29 +46,45 @@ function createCapabilities(supportedEfforts, restrictsSamplingParams, maxTokens
       restrictsSamplingParams,
       supportedToolChoices: ["auto", "none", "required", "tool"]
     },
+    modalities,
     chatCompletions: {
       maxTokensParameter
     }
   };
 }
-var DEFAULT_CAPABILITIES = createCapabilities(STANDARD_EFFORTS, false);
-var UNKNOWN_MODEL_CAPABILITIES = createCapabilities(
-  STANDARD_EFFORTS,
-  false,
-  "max_tokens"
-);
-var SAMPLING_RESTRICTED_STANDARD_CAPABILITIES = createCapabilities(
-  STANDARD_EFFORTS,
-  true
-);
-var GPT_5_MAX_REASONING_CAPABILITIES = createCapabilities(MAX_EFFORTS, true);
-var GPT_5_MINIMAL_REASONING_CAPABILITIES = createCapabilities(
-  MINIMAL_EFFORTS,
-  true
-);
-var GPT_5_PRO_REASONING_CAPABILITIES = createCapabilities(PRO_EFFORTS, true);
-var GPT_5_HIGH_REASONING_CAPABILITIES = createCapabilities(HIGH_EFFORT, true);
-function createNoReasoningCapabilities(maxTokensParameter) {
+var DEFAULT_CAPABILITIES = createCapabilities({
+  supportedEfforts: STANDARD_EFFORTS,
+  restrictsSamplingParams: false
+});
+var UNKNOWN_MODEL_CAPABILITIES = createCapabilities({
+  supportedEfforts: STANDARD_EFFORTS,
+  restrictsSamplingParams: false,
+  maxTokensParameter: "max_tokens"
+});
+var SAMPLING_RESTRICTED_STANDARD_CAPABILITIES = createCapabilities({
+  supportedEfforts: STANDARD_EFFORTS,
+  restrictsSamplingParams: true
+});
+var GPT_5_MAX_REASONING_CAPABILITIES = createCapabilities({
+  supportedEfforts: MAX_EFFORTS,
+  restrictsSamplingParams: true
+});
+var GPT_5_MINIMAL_REASONING_CAPABILITIES = createCapabilities({
+  supportedEfforts: MINIMAL_EFFORTS,
+  restrictsSamplingParams: true
+});
+var GPT_5_PRO_REASONING_CAPABILITIES = createCapabilities({
+  supportedEfforts: PRO_EFFORTS,
+  restrictsSamplingParams: true
+});
+var GPT_5_HIGH_REASONING_CAPABILITIES = createCapabilities({
+  supportedEfforts: HIGH_EFFORT,
+  restrictsSamplingParams: true
+});
+function createNoReasoningCapabilities({
+  maxTokensParameter,
+  modalities = MULTIMODAL_INPUT_MODALITIES
+}) {
   return {
     reasoning: {
       mode: "unsupported",
@@ -65,19 +92,40 @@ function createNoReasoningCapabilities(maxTokensParameter) {
       restrictsSamplingParams: false,
       supportedToolChoices: ["auto", "none", "required", "tool"]
     },
+    modalities,
     chatCompletions: {
       maxTokensParameter
     }
   };
 }
-var NO_REASONING_CAPABILITIES = createNoReasoningCapabilities("max_tokens");
-var NO_REASONING_EFFORT_CAPABILITIES = createNoReasoningCapabilities(
-  "max_completion_tokens"
-);
-var O_SERIES_MAX_REASONING_CAPABILITIES = createCapabilities(
-  MAX_EFFORTS,
-  false
-);
+var NO_REASONING_CAPABILITIES = createNoReasoningCapabilities({
+  maxTokensParameter: "max_tokens"
+});
+var NO_REASONING_TEXT_ONLY_CAPABILITIES = createNoReasoningCapabilities({
+  maxTokensParameter: "max_tokens",
+  modalities: TEXT_ONLY_MODALITIES
+});
+var NO_REASONING_EFFORT_TEXT_ONLY_CAPABILITIES = createNoReasoningCapabilities({
+  maxTokensParameter: "max_completion_tokens",
+  modalities: TEXT_ONLY_MODALITIES
+});
+var AUDIO_CAPABILITIES = createNoReasoningCapabilities({
+  maxTokensParameter: "max_completion_tokens",
+  modalities: OPENAI_AUDIO_INPUT_MODALITIES
+});
+var GPT_4O_AUDIO_CAPABILITIES = createNoReasoningCapabilities({
+  maxTokensParameter: "max_tokens",
+  modalities: OPENAI_AUDIO_INPUT_MODALITIES
+});
+var O_SERIES_MAX_REASONING_CAPABILITIES = createCapabilities({
+  supportedEfforts: MAX_EFFORTS,
+  restrictsSamplingParams: false
+});
+var O_SERIES_TEXT_ONLY_CAPABILITIES = createCapabilities({
+  supportedEfforts: STANDARD_EFFORTS,
+  restrictsSamplingParams: false,
+  modalities: TEXT_ONLY_MODALITIES
+});
 var OPENAI_MODEL_CAPABILITIES = {
   "gpt-5.6-sol": GPT_5_MAX_REASONING_CAPABILITIES,
   "gpt-5.6-terra": SAMPLING_RESTRICTED_STANDARD_CAPABILITIES,
@@ -103,17 +151,22 @@ var OPENAI_MODEL_CAPABILITIES = {
   "gpt-5-codex": GPT_5_MAX_REASONING_CAPABILITIES,
   "o3-pro": O_SERIES_MAX_REASONING_CAPABILITIES,
   o3: DEFAULT_CAPABILITIES,
-  "o3-mini": DEFAULT_CAPABILITIES,
+  "o3-mini": O_SERIES_TEXT_ONLY_CAPABILITIES,
   "o4-mini": DEFAULT_CAPABILITIES,
   o1: DEFAULT_CAPABILITIES,
-  "o1-mini": NO_REASONING_EFFORT_CAPABILITIES,
+  "o1-mini": NO_REASONING_EFFORT_TEXT_ONLY_CAPABILITIES,
   "gpt-4.1": NO_REASONING_CAPABILITIES,
   "gpt-4.1-mini": NO_REASONING_CAPABILITIES,
   "gpt-4.1-nano": NO_REASONING_CAPABILITIES,
   "gpt-4o": NO_REASONING_CAPABILITIES,
   "gpt-4o-mini": NO_REASONING_CAPABILITIES,
   "gpt-4-turbo": NO_REASONING_CAPABILITIES,
-  "gpt-3.5-turbo": NO_REASONING_CAPABILITIES,
+  "gpt-3.5-turbo": NO_REASONING_TEXT_ONLY_CAPABILITIES,
+  "gpt-audio-1.5": AUDIO_CAPABILITIES,
+  "gpt-audio": AUDIO_CAPABILITIES,
+  "gpt-audio-mini": AUDIO_CAPABILITIES,
+  "gpt-4o-audio-preview": GPT_4O_AUDIO_CAPABILITIES,
+  "gpt-4o-mini-audio-preview": GPT_4O_AUDIO_CAPABILITIES,
   [UNKNOWN_MODEL]: UNKNOWN_MODEL_CAPABILITIES
 };
 var OPENAI_REASONING_EFFORT_MAP = {
@@ -126,6 +179,20 @@ var OPENAI_REASONING_EFFORT_MAP = {
 function getOpenAIModelCapabilities(modelId) {
   return getRegisteredModelCapabilities(OPENAI_MODEL_CAPABILITIES, modelId) ?? UNKNOWN_MODEL_CAPABILITIES;
 }
+function toOpenAIResponsesCapabilities(capabilities) {
+  if (!capabilities.modalities.input.includes("audio")) {
+    return capabilities;
+  }
+  return {
+    ...capabilities,
+    modalities: {
+      input: capabilities.modalities.input.filter(
+        (modality) => modality !== "audio"
+      ),
+      output: capabilities.modalities.output
+    }
+  };
+}
 function toOpenAIReasoningEffort(effort) {
   return OPENAI_REASONING_EFFORT_MAP[effort];
 }
@@ -207,7 +274,12 @@ var openaiCompatGenerateProviderOptionsSchema = openaiChatGenerateProviderOption
 import { createObjectStream, createChatStream } from "@core-ai/core-ai";
 
 // src/chat-completions/chat-adapter.ts
-import { clampReasoningEffort, getProviderMetadata } from "@core-ai/core-ai";
+import {
+  clampReasoningEffort,
+  getProviderMetadata,
+  ValidationError as ValidationError2,
+  validateInputModalities
+} from "@core-ai/core-ai";
 
 // src/shared/tools.ts
 import { zodSchemaToJsonSchema } from "@core-ai/core-ai";
@@ -246,14 +318,6 @@ function safeParseJsonObject(json) {
     return {};
   }
 }
-function validateOpenAIReasoningConfig(modelId, options) {
-  validateReasoningConfig(
-    modelId,
-    options,
-    getOpenAIModelCapabilities(modelId),
-    "openai"
-  );
-}
 function validateReasoningConfig(modelId, options, capabilities, providerId) {
   const reasoningEnabled = options.reasoning !== void 0 || capabilities.reasoning.mode === "always-on";
   if (!reasoningEnabled) {
@@ -311,7 +375,12 @@ function convertMessage(message, adapterOptions) {
   if (message.role === "user") {
     return {
       role: "user",
-      content: typeof message.content === "string" ? message.content : message.content.map(convertUserContentPart)
+      content: typeof message.content === "string" ? message.content : message.content.map(
+        (part) => convertUserContentPart(
+          part,
+          adapterOptions.providerId
+        )
+      )
     };
   }
   if (message.role === "assistant") {
@@ -365,7 +434,7 @@ function convertMessage(message, adapterOptions) {
     content: message.content
   };
 }
-function convertUserContentPart(part) {
+function convertUserContentPart(part, providerId) {
   if (part.type === "text") {
     return {
       type: "text",
@@ -381,6 +450,15 @@ function convertUserContentPart(part) {
       }
     };
   }
+  if (part.type === "audio") {
+    return {
+      type: "input_audio",
+      input_audio: {
+        data: part.source.data,
+        format: toOpenAIAudioFormat(part.source.mediaType, providerId)
+      }
+    };
+  }
   return {
     type: "file",
     file: {
@@ -389,6 +467,22 @@ function convertUserContentPart(part) {
     }
   };
 }
+var AUDIO_FORMAT_BY_MEDIA_TYPE = {
+  "audio/wav": "wav",
+  "audio/mp3": "mp3",
+  "audio/mpeg": "mp3"
+};
+function toOpenAIAudioFormat(mediaType, providerId) {
+  const format = AUDIO_FORMAT_BY_MEDIA_TYPE[mediaType.toLowerCase()];
+  if (format === void 0) {
+    throw new ValidationError2(
+      `unsupported audio media type "${mediaType}"; OpenAI Chat Completions accepts audio/wav, audio/mp3, and audio/mpeg`,
+      void 0,
+      providerId
+    );
+  }
+  return format;
+}
 function createGenerateRequest(modelId, options, adapterOptions) {
   return createRequest(modelId, options, false, adapterOptions);
 }
@@ -419,6 +513,12 @@ function createRequestBase(modelId, options, adapterOptions) {
     adapterOptions.capabilities,
     adapterOptions.providerId
   );
+  validateInputModalities({
+    messages: options.messages,
+    capabilities: adapterOptions.capabilities,
+    modelId,
+    providerId: adapterOptions.providerId
+  });
   const reasoningFields = mapReasoningToRequestFields(
     options,
     adapterOptions.capabilities
@@ -1283,16 +1383,34 @@ import {
 import { createObjectStream as createObjectStream2, createChatStream as createChatStream2 } from "@core-ai/core-ai";
 
 // src/chat-adapter.ts
-import { getProviderMetadata as getProviderMetadata2, clampReasoningEffort as clampReasoningEffort2 } from "@core-ai/core-ai";
+import {
+  getProviderMetadata as getProviderMetadata2,
+  clampReasoningEffort as clampReasoningEffort2,
+  UnsupportedInputModalityError,
+  ValidationError as ValidationError3,
+  validateInputModalities as validateInputModalities2
+} from "@core-ai/core-ai";
+var DEFAULT_PROVIDER_ID = "openai";
+function resolveAdapterOptions(modelId, adapterOptions) {
+  const capabilities = adapterOptions.capabilities ?? getOpenAIModelCapabilities(modelId);
+  return {
+    capabilities: toOpenAIResponsesCapabilities(capabilities),
+    // Also the ownership key for encrypted reasoning metadata — Azure
+    // (`azure-openai`) must not share the `openai` namespace.
+    providerId: adapterOptions.providerId ?? DEFAULT_PROVIDER_ID
+  };
+}
 var ENCRYPTED_REASONING_INCLUDE = "reasoning.encrypted_content";
 var REASONING_SUMMARY_SEPARATOR = "\n\n";
+var RESPONSES_AUDIO_REJECTION = "OpenAI Responses does not accept audio input; use provider.chat.chatModel() with an audio-capable Chat Completions model";
 function convertMessages2(messages, options = {}) {
   const includeReasoning = options.includeReasoning ?? true;
+  const providerId = options.providerId ?? DEFAULT_PROVIDER_ID;
   return messages.flatMap(
-    (message) => convertMessage2(message, includeReasoning)
+    (message) => convertMessage2(message, includeReasoning, providerId)
   );
 }
-function convertMessage2(message, includeReasoning) {
+function convertMessage2(message, includeReasoning, providerId) {
   if (message.role === "system") {
     return [
       {
@@ -1310,7 +1428,11 @@ function convertMessage2(message, includeReasoning) {
     ];
   }
   if (message.role === "assistant") {
-    return convertAssistantMessage(message.parts, includeReasoning);
+    return convertAssistantMessage(
+      message.parts,
+      includeReasoning,
+      providerId
+    );
   }
   return [
     {
@@ -1320,7 +1442,7 @@ function convertMessage2(message, includeReasoning) {
     }
   ];
 }
-function convertAssistantMessage(parts, includeReasoning) {
+function convertAssistantMessage(parts, includeReasoning, providerId) {
   const items = [];
   const textParts = [];
   const flushTextBuffer = () => {
@@ -1341,7 +1463,7 @@ function convertAssistantMessage(parts, includeReasoning) {
     if (part.type === "reasoning") {
       if (!includeReasoning || getProviderMetadata2(
         part.providerMetadata,
-        "openai"
+        providerId
       ) == null) {
         if (part.text.length > 0) {
           textParts.push(`<thinking>${part.text}</thinking>`);
@@ -1349,7 +1471,10 @@ function convertAssistantMessage(parts, includeReasoning) {
         continue;
       }
       flushTextBuffer();
-      const encryptedContent = getEncryptedReasoningContent(part);
+      const encryptedContent = getEncryptedReasoningContent(
+        part,
+        providerId
+      );
       items.push({
         type: "reasoning",
         summary: [
@@ -1373,13 +1498,20 @@ function convertAssistantMessage(parts, includeReasoning) {
   flushTextBuffer();
   return items;
 }
-function getEncryptedReasoningContent(part) {
+function getEncryptedReasoningContent(part, providerId) {
   const { encryptedContent } = getProviderMetadata2(
     part.providerMetadata,
-    "openai"
+    providerId
   ) ?? {};
   return typeof encryptedContent === "string" && encryptedContent.length > 0 ? encryptedContent : void 0;
 }
+function createReasoningProviderMetadata(providerId, encryptedContent) {
+  return {
+    [providerId]: {
+      ...encryptedContent ? { encryptedContent } : {}
+    }
+  };
+}
 function convertUserContentPart2(part) {
   if (part.type === "text") {
     return {
@@ -1394,58 +1526,80 @@ function convertUserContentPart2(part) {
       image_url: imageUrl
     };
   }
+  if (part.type === "audio") {
+    throw new ValidationError3(RESPONSES_AUDIO_REJECTION);
+  }
   return {
     type: "input_file",
     file_data: part.data,
     ...part.filename ? { filename: part.filename } : {}
   };
 }
-function createGenerateRequest2(modelId, options) {
+function createGenerateRequest2(modelId, options, adapterOptions = {}) {
   return createRequest2(
     modelId,
     options,
-    false
+    false,
+    adapterOptions
   );
 }
-function createStreamRequest2(modelId, options) {
+function createStreamRequest2(modelId, options, adapterOptions = {}) {
   return createRequest2(
     modelId,
     options,
-    true
+    true,
+    adapterOptions
   );
 }
-function createRequest2(modelId, options, stream) {
+function createRequest2(modelId, options, stream, adapterOptions) {
+  const resolved = resolveAdapterOptions(modelId, adapterOptions);
   const openaiOptions = parseOpenAIResponsesGenerateProviderOptions(
     options.providerOptions
   );
   const request = {
-    ...createRequestBase2(modelId, options),
+    ...createRequestBase2(modelId, options, resolved),
     ...stream ? { stream: true } : {},
     ...options.structuredOutputFormat ? { text: { format: options.structuredOutputFormat } } : {},
     ...mapOpenAIProviderOptionsToRequestFields2(openaiOptions)
   };
-  if (options.reasoning && getOpenAIModelCapabilities(modelId).reasoning.mode !== "unsupported") {
+  if (options.reasoning && resolved.capabilities.reasoning.mode !== "unsupported") {
     request.include = mergeInclude(request.include, [
       ENCRYPTED_REASONING_INCLUDE
     ]);
   }
   return request;
 }
-function createRequestBase2(modelId, options) {
-  validateOpenAIReasoningConfig(modelId, options);
-  const capabilities = getOpenAIModelCapabilities(modelId);
+function createRequestBase2(modelId, options, { capabilities, providerId }) {
+  validateReasoningConfig(modelId, options, capabilities, providerId);
+  validateResponsesInputModalities({
+    messages: options.messages,
+    capabilities,
+    modelId,
+    providerId
+  });
   return {
     model: modelId,
     store: false,
     input: convertMessages2(options.messages, {
-      includeReasoning: capabilities.reasoning.mode !== "unsupported"
+      includeReasoning: capabilities.reasoning.mode !== "unsupported",
+      providerId
     }),
     ...options.tools && Object.keys(options.tools).length > 0 ? { tools: convertResponseTools(options.tools) } : {},
     ...options.toolChoice ? { tool_choice: convertResponseToolChoice(options.toolChoice) } : {},
-    ...mapReasoningToRequestFields2(modelId, options),
+    ...mapReasoningToRequestFields2(options, capabilities),
     ...mapSamplingToRequestFields2(options)
   };
 }
+function validateResponsesInputModalities(options) {
+  try {
+    validateInputModalities2(options);
+  } catch (error) {
+    if (error instanceof UnsupportedInputModalityError && error.unsupportedModalities.includes("audio")) {
+      error.message = `${error.message}. ${RESPONSES_AUDIO_REJECTION}`;
+    }
+    throw error;
+  }
+}
 function convertResponseTools(tools) {
   return convertTools(tools).map((tool) => ({
     type: "function",
@@ -1489,11 +1643,12 @@ function mapOpenAIProviderOptionsToRequestFields2(options) {
     ...options?.user !== void 0 ? { user: options.user } : {}
   };
 }
-function mapGenerateResponse2(response) {
+function mapGenerateResponse2(response, adapterOptions = {}) {
+  const providerId = adapterOptions.providerId ?? DEFAULT_PROVIDER_ID;
   const parts = [];
   for (const item of response.output) {
     if (isReasoningItem(item)) {
-      const reasoningPart = mapReasoningPart(item);
+      const reasoningPart = mapReasoningPart(item, providerId);
       if (reasoningPart) {
         parts.push(reasoningPart);
       }
@@ -1526,7 +1681,7 @@ function mapGenerateResponse2(response) {
     usage: mapUsage(response.usage)
   };
 }
-function mapReasoningPart(item) {
+function mapReasoningPart(item, providerId) {
   const text = getReasoningSummaryText(item.summary);
   const encryptedContent = typeof item.encrypted_content === "string" && item.encrypted_content.length > 0 ? item.encrypted_content : void 0;
   if (text.length === 0 && !encryptedContent) {
@@ -1535,9 +1690,10 @@ function mapReasoningPart(item) {
   return {
     type: "reasoning",
     text,
-    providerMetadata: {
-      openai: { ...encryptedContent ? { encryptedContent } : {} }
-    }
+    providerMetadata: createReasoningProviderMetadata(
+      providerId,
+      encryptedContent
+    )
   };
 }
 function getReasoningSummaryText(summary) {
@@ -1628,7 +1784,9 @@ function getReasoningEndTransition(reasoningStarted, providerMetadata) {
     }
   };
 }
-async function* transformStream2(stream) {
+async function* transformStream2(stream, adapterOptions = {}) {
+  const providerId = adapterOptions.providerId ?? DEFAULT_PROVIDER_ID;
+  const emptyReasoningMetadata = createReasoningProviderMetadata(providerId);
   const bufferedToolCalls = /* @__PURE__ */ new Map();
   const emittedToolCalls = /* @__PURE__ */ new Set();
   const startedToolCalls = /* @__PURE__ */ new Set();
@@ -1734,7 +1892,9 @@ async function* transformStream2(stream) {
       continue;
     }
     if (event.type === "response.output_text.delta") {
-      const reasoningEndEvent2 = getNextReasoningEndEvent({ openai: {} });
+      const reasoningEndEvent2 = getNextReasoningEndEvent(
+        emptyReasoningMetadata
+      );
       if (reasoningEndEvent2) {
         yield reasoningEndEvent2;
       }
@@ -1823,11 +1983,9 @@ async function* transformStream2(stream) {
             yield reasoningStartEvent;
           }
         }
-        const reasoningEndEvent2 = getNextReasoningEndEvent({
-          openai: {
-            ...encryptedContent ? { encryptedContent } : {}
-          }
-        });
+        const reasoningEndEvent2 = getNextReasoningEndEvent(
+          createReasoningProviderMetadata(providerId, encryptedContent)
+        );
         if (reasoningEndEvent2) {
           yield reasoningEndEvent2;
         }
@@ -1866,7 +2024,9 @@ async function* transformStream2(stream) {
     if (event.type === "response.completed") {
       latestResponse = event.response;
       yield* closeText();
-      const reasoningEndEvent2 = getNextReasoningEndEvent({ openai: {} });
+      const reasoningEndEvent2 = getNextReasoningEndEvent(
+        emptyReasoningMetadata
+      );
       if (reasoningEndEvent2) {
         yield reasoningEndEvent2;
       }
@@ -1895,9 +2055,7 @@ async function* transformStream2(stream) {
       return;
     }
   }
-  const reasoningEndEvent = getNextReasoningEndEvent({
-    openai: {}
-  });
+  const reasoningEndEvent = getNextReasoningEndEvent(emptyReasoningMetadata);
   yield* closeText();
   if (reasoningEndEvent) {
     yield reasoningEndEvent;
@@ -1911,11 +2069,10 @@ async function* transformStream2(stream) {
     usage
   };
 }
-function mapReasoningToRequestFields2(modelId, options) {
+function mapReasoningToRequestFields2(options, capabilities) {
   if (!options.reasoning) {
     return {};
   }
-  const capabilities = getOpenAIModelCapabilities(modelId);
   if (capabilities.reasoning.mode === "unsupported") {
     return {};
   }
@@ -1943,8 +2100,9 @@ function isReasoningItem(item) {
 }
 
 // src/chat-model.ts
-function createOpenAIChatModel(client, modelId, capabilities, providerId = "openai") {
+function createOpenAIChatModel(client, modelId, capabilities, providerId = DEFAULT_PROVIDER_ID) {
   const provider = providerId;
+  const adapterOptions = { capabilities, providerId };
   async function callOpenAIResponsesApi(request, signal) {
     try {
       return await client.responses.create(request, {
@@ -1955,18 +2113,19 @@ function createOpenAIChatModel(client, modelId, capabilities, providerId = "open
     }
   }
   async function generateChat(options) {
-    const request = createGenerateRequest2(modelId, options);
+    const request = createGenerateRequest2(modelId, options, adapterOptions);
     const response = await callOpenAIResponsesApi(
       request,
       options.signal
     );
-    return mapGenerateResponse2(response);
+    return mapGenerateResponse2(response, { providerId: provider });
   }
   async function streamChat(options) {
-    const request = createStreamRequest2(modelId, options);
+    const request = createStreamRequest2(modelId, options, adapterOptions);
     return createChatStream2(
       async () => transformStream2(
-        await callOpenAIResponsesApi(request, options.signal)
+        await callOpenAIResponsesApi(request, options.signal),
+        { providerId: provider }
       ),
       { signal: options.signal }
     );
@@ -2110,7 +2269,12 @@ function createOpenAIProvider(options, factoryOptions = {}) {
       factoryOptions.modelCapabilities,
       modelId
     ) ?? getOpenAIModelCapabilities(modelId);
-    return createOpenAIChatModel(client, modelId, capabilities, providerId);
+    return createOpenAIChatModel(
+      client,
+      modelId,
+      toOpenAIResponsesCapabilities(capabilities),
+      providerId
+    );
   };
   const createChatCompletionsModel = (modelId) => {
     const capabilities = getRegisteredModelCapabilities2(

package/dist/compat.js

@@ -4,7 +4,7 @@ import {
   getOpenAIModelCapabilities,
   openaiCompatGenerateProviderOptionsSchema,
   openaiCompatProviderOptionsSchema
-} from "./chunk-LVGNSX5F.js";
+} from "./chunk-MKAXZHMO.js";
 
 // src/compat/provider.ts
 import OpenAI from "openai";

package/dist/index.js

@@ -10,7 +10,7 @@ import {
   openaiImageProviderOptionsSchema,
   openaiResponsesGenerateProviderOptionsSchema,
   openaiResponsesProviderOptionsSchema
-} from "./chunk-LVGNSX5F.js";
+} from "./chunk-MKAXZHMO.js";
 
 // src/provider.ts
 function createOpenAI(options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/openai",
-    "version": "0.18.0",
+    "version": "0.20.0",
     "description": "OpenAI provider package for @core-ai/core-ai",
     "license": "MIT",
     "author": "Omnifact (https://omnifact.ai)",
@@ -50,7 +50,7 @@
         "test:watch": "vitest"
     },
     "dependencies": {
-        "@core-ai/core-ai": "^0.18.0",
+        "@core-ai/core-ai": "^0.20.0",
         "openai": "^6.46.0"
     },
     "peerDependencies": {