@core-ai/openai 0.18.0 → 0.19.0

package/dist/{chunk-LVGNSX5F.js → chunk-UGCMGRDL.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,9 +1383,24 @@ 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),
+    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;
   return messages.flatMap(
@@ -1394,46 +1509,57 @@ 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,
@@ -1442,10 +1568,20 @@ function createRequestBase2(modelId, options) {
     }),
     ...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",
@@ -1911,11 +2047,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 +2078,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,7 +2091,7 @@ 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
@@ -1963,7 +2099,7 @@ function createOpenAIChatModel(client, modelId, capabilities, providerId = "open
     return mapGenerateResponse2(response);
   }
   async function streamChat(options) {
-    const request = createStreamRequest2(modelId, options);
+    const request = createStreamRequest2(modelId, options, adapterOptions);
     return createChatStream2(
       async () => transformStream2(
         await callOpenAIResponsesApi(request, options.signal)
@@ -2110,7 +2246,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-UGCMGRDL.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-UGCMGRDL.js";
 
 // src/provider.ts
 function createOpenAI(options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/openai",
-    "version": "0.18.0",
+    "version": "0.19.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.19.0",
         "openai": "^6.46.0"
     },
     "peerDependencies": {