@core-ai/openai 0.15.0 → 0.17.0

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

@@ -1,6 +1,8 @@
 // src/model-capabilities.ts
 import {
-  stripModelDateSuffix
+  getRegisteredModelCapabilities,
+  stripModelDateSuffix,
+  UNKNOWN_MODEL
 } from "@core-ai/core-ai";
 var STANDARD_EFFORTS = [
   "low",
@@ -28,9 +30,10 @@ var HIGH_EFFORT = ["high"];
 function createCapabilities(supportedEfforts, restrictsSamplingParams, maxTokensParameter = "max_completion_tokens") {
   return {
     reasoning: {
-      supported: true,
+      mode: "optional",
       supportedEfforts,
-      restrictsSamplingParams
+      restrictsSamplingParams,
+      supportedToolChoices: ["auto", "none", "required", "tool"]
     },
     chatCompletions: {
       maxTokensParameter
@@ -54,21 +57,28 @@ var GPT_5_MINIMAL_REASONING_CAPABILITIES = createCapabilities(
 );
 var GPT_5_PRO_REASONING_CAPABILITIES = createCapabilities(PRO_EFFORTS, true);
 var GPT_5_HIGH_REASONING_CAPABILITIES = createCapabilities(HIGH_EFFORT, true);
-var NO_REASONING_EFFORT_CAPABILITIES = {
-  reasoning: {
-    supported: false,
-    supportedEfforts: [],
-    restrictsSamplingParams: false
-  },
-  chatCompletions: {
-    maxTokensParameter: "max_completion_tokens"
-  }
-};
+function createNoReasoningCapabilities(maxTokensParameter) {
+  return {
+    reasoning: {
+      mode: "unsupported",
+      supportedEfforts: [],
+      restrictsSamplingParams: false,
+      supportedToolChoices: ["auto", "none", "required", "tool"]
+    },
+    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 MODEL_CAPABILITIES = {
+var OPENAI_MODEL_CAPABILITIES = {
   "gpt-5.6-sol": GPT_5_MAX_REASONING_CAPABILITIES,
   "gpt-5.6-terra": SAMPLING_RESTRICTED_STANDARD_CAPABILITIES,
   "gpt-5.6-luna": GPT_5_MINIMAL_REASONING_CAPABILITIES,
@@ -96,7 +106,15 @@ var MODEL_CAPABILITIES = {
   "o3-mini": DEFAULT_CAPABILITIES,
   "o4-mini": DEFAULT_CAPABILITIES,
   o1: DEFAULT_CAPABILITIES,
-  "o1-mini": NO_REASONING_EFFORT_CAPABILITIES
+  "o1-mini": NO_REASONING_EFFORT_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,
+  [UNKNOWN_MODEL]: UNKNOWN_MODEL_CAPABILITIES
 };
 var OPENAI_REASONING_EFFORT_MAP = {
   minimal: "minimal",
@@ -106,11 +124,7 @@ var OPENAI_REASONING_EFFORT_MAP = {
   max: "xhigh"
 };
 function getOpenAIModelCapabilities(modelId) {
-  const normalizedModelId = normalizeModelId(modelId);
-  return MODEL_CAPABILITIES[normalizedModelId] ?? UNKNOWN_MODEL_CAPABILITIES;
-}
-function normalizeModelId(modelId) {
-  return stripModelDateSuffix(modelId);
+  return getRegisteredModelCapabilities(OPENAI_MODEL_CAPABILITIES, modelId) ?? UNKNOWN_MODEL_CAPABILITIES;
 }
 function toOpenAIReasoningEffort(effort) {
   return OPENAI_REASONING_EFFORT_MAP[effort];
@@ -147,8 +161,8 @@ var openaiImageProviderOptionsSchema = z.object({
   style: z.enum(["vivid", "natural"]).optional(),
   user: z.string().optional()
 }).strict();
-function parseOpenAIProviderOptions(providerOptions, schema) {
-  const rawOptions = providerOptions?.openai;
+function parseOpenAIProviderOptions(providerOptions, key, schema) {
+  const rawOptions = providerOptions?.[key];
   if (rawOptions === void 0) {
     return void 0;
   }
@@ -157,24 +171,31 @@ function parseOpenAIProviderOptions(providerOptions, schema) {
 function parseOpenAIResponsesGenerateProviderOptions(providerOptions) {
   return parseOpenAIProviderOptions(
     providerOptions,
+    "openai",
     openaiResponsesGenerateProviderOptionsSchema
   );
 }
-function parseOpenAIChatGenerateProviderOptions(providerOptions) {
+function parseOpenAIChatGenerateProviderOptions(providerOptions, config = {
+  key: "openai",
+  schema: openaiChatGenerateProviderOptionsSchema
+}) {
   return parseOpenAIProviderOptions(
     providerOptions,
-    openaiChatGenerateProviderOptionsSchema
+    config.key,
+    config.schema
   );
 }
 function parseOpenAIEmbedProviderOptions(providerOptions) {
   return parseOpenAIProviderOptions(
     providerOptions,
+    "openai",
     openaiEmbedProviderOptionsSchema
   );
 }
 function parseOpenAIImageProviderOptions(providerOptions) {
   return parseOpenAIProviderOptions(
     providerOptions,
+    "openai",
     openaiImageProviderOptionsSchema
   );
 }
@@ -186,7 +207,7 @@ var openaiCompatGenerateProviderOptionsSchema = openaiChatGenerateProviderOption
 import { createObjectStream, createChatStream } from "@core-ai/core-ai";
 
 // src/chat-completions/chat-adapter.ts
-import { clampReasoningEffort } from "@core-ai/core-ai";
+import { clampReasoningEffort, getProviderMetadata } from "@core-ai/core-ai";
 
 // src/shared/tools.ts
 import { zodSchemaToJsonSchema } from "@core-ai/core-ai";
@@ -226,25 +247,40 @@ function safeParseJsonObject(json) {
   }
 }
 function validateOpenAIReasoningConfig(modelId, options) {
-  if (!options.reasoning) {
-    return;
-  }
-  const capabilities = getOpenAIModelCapabilities(modelId);
-  if (!capabilities.reasoning.restrictsSamplingParams) {
+  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) {
     return;
   }
-  const restrictedSamplingParams = [
-    { name: "temperature", value: options.temperature },
-    { name: "topP", value: options.topP }
-  ];
-  for (const { name, value } of restrictedSamplingParams) {
-    if (value === void 0) {
-      continue;
+  if (capabilities.reasoning.restrictsSamplingParams) {
+    const restrictedSamplingParams = [
+      { name: "temperature", value: options.temperature },
+      { name: "topP", value: options.topP }
+    ];
+    for (const { name, value } of restrictedSamplingParams) {
+      if (value === void 0) {
+        continue;
+      }
+      throw new ValidationError(
+        `${providerId} model "${modelId}" does not support ${name} when reasoning is enabled`,
+        void 0,
+        providerId
+      );
     }
+  }
+  const toolChoiceMode = typeof options.toolChoice === "object" ? options.toolChoice.type : options.toolChoice;
+  if (toolChoiceMode !== void 0 && !capabilities.reasoning.supportedToolChoices.includes(toolChoiceMode)) {
     throw new ValidationError(
-      `OpenAI model "${modelId}" does not support ${name} when reasoning is enabled`,
+      `${providerId} model "${modelId}" does not support toolChoice "${toolChoiceMode}" when reasoning is enabled`,
       void 0,
-      "openai"
+      providerId
     );
   }
 }
@@ -262,10 +298,10 @@ function extractCompatibleReasoningText(source) {
 }
 
 // src/chat-completions/chat-adapter.ts
-function convertMessages(messages) {
-  return messages.map(convertMessage);
+function convertMessages(messages, adapterOptions = {}) {
+  return messages.map((message) => convertMessage(message, adapterOptions));
 }
-function convertMessage(message) {
+function convertMessage(message, adapterOptions) {
   if (message.role === "system") {
     return {
       role: "system",
@@ -279,19 +315,32 @@ function convertMessage(message) {
     };
   }
   if (message.role === "assistant") {
-    const text = message.parts.flatMap((part) => {
-      if (part.type === "text") return [part.text];
-      if (part.type === "reasoning" && part.text.length > 0) {
-        return [`<thinking>${part.text}</thinking>`];
+    const nativeReasoning = [];
+    const text = [];
+    for (const part of message.parts) {
+      if (part.type === "text") {
+        text.push(part.text);
+        continue;
       }
-      return [];
-    }).join("\n\n");
+      if (part.type !== "reasoning" || part.text.length === 0) {
+        continue;
+      }
+      const reasoningOptions = adapterOptions.reasoning;
+      if (reasoningOptions && getProviderMetadata(
+        part.providerMetadata,
+        reasoningOptions.providerMetadataKey
+      )) {
+        nativeReasoning.push(part.text);
+      } else {
+        text.push(`<thinking>${part.text}</thinking>`);
+      }
+    }
     const toolCalls = message.parts.flatMap(
       (part) => part.type === "tool-call" ? [part.toolCall] : []
     );
-    return {
+    const assistantMessage = {
       role: "assistant",
-      content: text.length > 0 ? text : null,
+      content: text.length > 0 ? text.join("\n\n") : null,
       ...toolCalls.length > 0 ? {
         tool_calls: toolCalls.map((toolCall) => ({
           id: toolCall.id,
@@ -303,6 +352,12 @@ function convertMessage(message) {
         }))
       } : {}
     };
+    if (adapterOptions.reasoning && nativeReasoning.length > 0) {
+      return Object.assign(assistantMessage, {
+        [adapterOptions.reasoning.requestField]: nativeReasoning.join("\n\n")
+      });
+    }
+    return assistantMessage;
   }
   return {
     role: "tool",
@@ -334,17 +389,17 @@ function convertUserContentPart(part) {
     }
   };
 }
-function createGenerateRequest(modelId, options, adapterOptions = {}) {
+function createGenerateRequest(modelId, options, adapterOptions) {
   return createRequest(modelId, options, false, adapterOptions);
 }
-function createStreamRequest(modelId, options, adapterOptions = {}) {
+function createStreamRequest(modelId, options, adapterOptions) {
   return createRequest(modelId, options, true, adapterOptions);
 }
 function createRequest(modelId, options, stream, adapterOptions) {
   const openaiOptions = parseOpenAIChatGenerateProviderOptions(
-    options.providerOptions
+    options.providerOptions,
+    adapterOptions.providerOptions
   );
-  const structuredOutputFormat = options.structuredOutputFormat;
   return {
     ...createRequestBase(modelId, options, adapterOptions),
     ...stream ? {
@@ -353,28 +408,24 @@ function createRequest(modelId, options, stream, adapterOptions) {
         include_usage: true
       }
     } : {},
-    ...structuredOutputFormat ? {
-      response_format: {
-        type: "json_schema",
-        json_schema: {
-          name: structuredOutputFormat.name,
-          ...structuredOutputFormat.description ? {
-            description: structuredOutputFormat.description
-          } : {},
-          strict: structuredOutputFormat.strict,
-          schema: structuredOutputFormat.schema
-        }
-      }
-    } : {},
-    ...mapOpenAIProviderOptionsToRequestFields(openaiOptions)
+    ...mapOpenAIProviderOptionsToRequestFields(openaiOptions),
+    ...mapResponseFormatToRequestFields(options.structuredOutputFormat)
   };
 }
 function createRequestBase(modelId, options, adapterOptions) {
-  validateOpenAIReasoningConfig(modelId, options);
-  const reasoningFields = mapReasoningToRequestFields(modelId, options);
+  validateReasoningConfig(
+    modelId,
+    options,
+    adapterOptions.capabilities,
+    adapterOptions.providerId
+  );
+  const reasoningFields = mapReasoningToRequestFields(
+    options,
+    adapterOptions.capabilities
+  );
   return {
     model: modelId,
-    messages: convertMessages(options.messages),
+    messages: convertMessages(options.messages, adapterOptions),
     ...options.tools && Object.keys(options.tools).length > 0 ? { tools: convertTools(options.tools) } : {},
     ...options.toolChoice ? { tool_choice: convertToolChoice(options.toolChoice) } : {},
     ...reasoningFields,
@@ -401,6 +452,29 @@ function mapOpenAIProviderOptionsToRequestFields(options) {
     ...options?.seed !== void 0 ? { seed: options.seed } : {}
   };
 }
+function mapResponseFormatToRequestFields(format) {
+  if (!format) {
+    return {};
+  }
+  if (format.type === "json_object") {
+    return {
+      response_format: {
+        type: "json_object"
+      }
+    };
+  }
+  return {
+    response_format: {
+      type: "json_schema",
+      json_schema: {
+        name: format.name,
+        ...format.description ? { description: format.description } : {},
+        strict: format.strict,
+        schema: format.schema
+      }
+    }
+  };
+}
 function mapGenerateResponse(response, adapterOptions = {}) {
   const firstChoice = response.choices[0];
   if (!firstChoice) {
@@ -425,7 +499,12 @@ function mapGenerateResponse(response, adapterOptions = {}) {
   const content = extractTextContent(firstChoice.message.content);
   const reasoning = adapterOptions.compatibility ? extractCompatibleReasoningText(firstChoice.message) ?? null : null;
   const toolCalls = parseToolCalls(firstChoice.message.tool_calls);
-  const parts = createAssistantParts(reasoning, content, toolCalls);
+  const parts = createAssistantParts(
+    reasoning,
+    content,
+    toolCalls,
+    adapterOptions.reasoning?.providerMetadataKey
+  );
   return {
     parts,
     content,
@@ -519,7 +598,14 @@ async function* transformStream(stream, adapterOptions = {}) {
       return;
     }
     reasoningOpen = false;
-    yield { type: "reasoning-end" };
+    yield {
+      type: "reasoning-end",
+      ...adapterOptions.reasoning ? {
+        providerMetadata: {
+          [adapterOptions.reasoning.providerMetadataKey]: {}
+        }
+      } : {}
+    };
   };
   for await (const chunk of stream) {
     if (chunk.usage) {
@@ -623,12 +709,11 @@ async function* transformStream(stream, adapterOptions = {}) {
     usage
   };
 }
-function mapReasoningToRequestFields(modelId, options) {
+function mapReasoningToRequestFields(options, capabilities) {
   if (!options.reasoning) {
     return {};
   }
-  const capabilities = getOpenAIModelCapabilities(modelId);
-  if (!capabilities.reasoning.supported) {
+  if (capabilities.reasoning.mode === "unsupported" || capabilities.reasoning.supportedEfforts.length === 0) {
     return {};
   }
   const clampedEffort = clampReasoningEffort(
@@ -639,12 +724,17 @@ function mapReasoningToRequestFields(modelId, options) {
     reasoning_effort: toOpenAIReasoningEffort(clampedEffort)
   };
 }
-function createAssistantParts(reasoning, content, toolCalls) {
+function createAssistantParts(reasoning, content, toolCalls, reasoningProviderMetadataKey) {
   const parts = [];
   if (reasoning) {
     parts.push({
       type: "reasoning",
-      text: reasoning
+      text: reasoning,
+      ...reasoningProviderMetadataKey ? {
+        providerMetadata: {
+          [reasoningProviderMetadataKey]: {}
+        }
+      } : {}
     });
   }
   if (content) {
@@ -680,28 +770,176 @@ function extractTextContent(content) {
 
 // src/openai-error.ts
 import { APIError, APIUserAbortError } from "openai";
-import { AbortedError, ProviderError } from "@core-ai/core-ai";
-function isOpenAIAbortError(error) {
-  return error instanceof APIUserAbortError || error instanceof Error && error.name === "AbortError";
-}
+import {
+  AbortedError,
+  ContextLengthExceededError,
+  ModelOverloadedError,
+  ProviderError,
+  RateLimitError,
+  ServiceUnavailableError,
+  asRecord,
+  getErrorMessage,
+  getHttpStatusCode,
+  getRetryAfterSecondsFromError,
+  getString,
+  isAbortErrorByName,
+  isRateLimitStatus,
+  isTransientUnavailableStatus
+} from "@core-ai/core-ai";
+var CONTEXT_LENGTH_ERROR_CODES = /* @__PURE__ */ new Set([
+  "context_length_exceeded",
+  "string_above_max_length"
+]);
+var TOKEN_LIMIT_PATTERNS = [
+  /maximum context length is (\d+) tokens.*resulted in (\d+) tokens/i,
+  /maximum context length is (\d+) tokens.*you requested (\d+) tokens/i,
+  /configured limit of (\d+) tokens.*resulted in (\d+) tokens/i
+];
+var OVERLOAD_MESSAGE_ELIGIBLE_STATUS_CODES = /* @__PURE__ */ new Set([500, 502, 503, 504]);
 function wrapOpenAIError(error, provider = "openai") {
   if (isOpenAIAbortError(error)) {
     return new AbortedError(error, provider);
   }
+  const message = getErrorMessage(error);
+  const statusCode = error instanceof APIError ? error.status : getHttpStatusCode(error, ["status"]);
+  const options = { statusCode, cause: error };
+  const contextLength = getContextLengthDetails(error, message);
+  if (contextLength) {
+    return new ContextLengthExceededError(message, provider, {
+      ...options,
+      ...contextLength
+    });
+  }
+  if (isAzureOpenAIBackendCapacityError(error)) {
+    return new ServiceUnavailableError(message, provider, options);
+  }
+  if (isOpenAIInsufficientQuota(error)) {
+    return new ProviderError(message, provider, options);
+  }
+  if (isAzureOpenAINoCapacity(error)) {
+    return new ModelOverloadedError(message, provider, options);
+  }
+  if (isOpenAIOverloaded(error, message, statusCode)) {
+    return new ModelOverloadedError(message, provider, options);
+  }
+  if (isOpenAIRateLimit(error, statusCode)) {
+    return new RateLimitError(message, provider, {
+      ...options,
+      retryAfterSeconds: getRetryAfterSecondsFromError(error)
+    });
+  }
+  if (isTransientUnavailableStatus(statusCode)) {
+    return new ServiceUnavailableError(message, provider, options);
+  }
+  return new ProviderError(message, provider, options);
+}
+function isOpenAIAbortError(error) {
+  return error instanceof APIUserAbortError || isAbortErrorByName(error);
+}
+function isOpenAIRateLimit(error, statusCode) {
+  if (isRateLimitStatus(statusCode)) {
+    return true;
+  }
+  const code = getProviderErrorCode(error);
+  const type = getProviderErrorType(error);
+  return code === "rate_limit_exceeded" || type === "rate_limit_error";
+}
+function isOpenAIOverloaded(error, message, statusCode) {
+  const providerMessage = getProviderMessage(error) ?? "";
+  return indicatesOpenAIOverload(`${providerMessage} ${message}`, statusCode);
+}
+function indicatesOpenAIOverload(text, statusCode) {
+  if (statusCode !== void 0 && !OVERLOAD_MESSAGE_ELIGIBLE_STATUS_CODES.has(statusCode)) {
+    return false;
+  }
+  const lower = text.toLowerCase();
+  return /\boverloaded\b/.test(lower) || /\bhigh demand\b/.test(lower) || /\brunning out of capacity\b/.test(lower) || /\bspikes in demand\b/.test(lower);
+}
+function getContextLengthDetails(error, fallbackMessage) {
+  const providerMessage = getProviderMessage(error) ?? fallbackMessage;
+  const code = getProviderErrorCode(error);
+  const isKnownContextLengthCode = code !== void 0 && CONTEXT_LENGTH_ERROR_CODES.has(code);
+  const tokenCounts = matchTokenLimitCounts(providerMessage);
+  if (tokenCounts) {
+    return tokenCounts;
+  }
+  if (!isKnownContextLengthCode) {
+    return void 0;
+  }
+  return {};
+}
+function matchTokenLimitCounts(providerMessage) {
+  for (const pattern of TOKEN_LIMIT_PATTERNS) {
+    const match = providerMessage.match(pattern);
+    if (!match) {
+      continue;
+    }
+    const maxTokens = match[1];
+    const actualTokens = match[2];
+    if (maxTokens === void 0 || actualTokens === void 0) {
+      continue;
+    }
+    return {
+      maxTokens: parseInt(maxTokens, 10),
+      actualTokens: parseInt(actualTokens, 10)
+    };
+  }
+  return void 0;
+}
+function isAzureOpenAIBackendCapacityError(error) {
+  const type = getProviderErrorType(error);
+  const providerMessage = getProviderMessage(error);
+  return type === "invalid_request_error" && providerMessage?.toLowerCase() === "backend error.";
+}
+function isOpenAIInsufficientQuota(error) {
+  const code = getProviderErrorCode(error);
+  const type = getProviderErrorType(error);
+  return code === "insufficient_quota" || type === "insufficient_quota";
+}
+function isAzureOpenAINoCapacity(error) {
+  return getProviderErrorCode(error) === "NoCapacity";
+}
+function getProviderMessage(error) {
   if (error instanceof APIError) {
-    return new ProviderError(
-      error.message,
-      provider,
-      error.status,
-      error
-    );
+    const nested2 = asRecord(error.error);
+    return getString(nested2, "message") ?? error.message;
   }
-  return new ProviderError(
-    error instanceof Error ? error.message : String(error),
-    provider,
-    void 0,
-    error
-  );
+  const record = asRecord(error);
+  if (!record) {
+    return void 0;
+  }
+  const nested = asRecord(record.error);
+  return getString(nested, "message") ?? getString(record, "message");
+}
+function getProviderErrorCode(error) {
+  if (error instanceof APIError) {
+    if (typeof error.code === "string") {
+      return error.code;
+    }
+    const nested2 = asRecord(error.error);
+    return getString(nested2, "code");
+  }
+  const record = asRecord(error);
+  if (!record) {
+    return void 0;
+  }
+  const nested = asRecord(record.error);
+  return getString(record, "code") ?? getString(nested, "code");
+}
+function getProviderErrorType(error) {
+  if (error instanceof APIError) {
+    if (typeof error.type === "string") {
+      return error.type;
+    }
+    const nested2 = asRecord(error.error);
+    return getString(nested2, "type");
+  }
+  const record = asRecord(error);
+  if (!record) {
+    return void 0;
+  }
+  const nested = asRecord(record.error);
+  return getString(record, "type") ?? getString(nested, "type");
 }
 
 // src/shared/structured-output.ts
@@ -716,7 +954,7 @@ var DEFAULT_STRUCTURED_OUTPUT_DESCRIPTION = "Return a JSON object that matches t
 function getStructuredOutputName(options) {
   return options.schemaName?.trim() || DEFAULT_STRUCTURED_OUTPUT_NAME;
 }
-function createStructuredOutputRequestOptions(options, mode = "native") {
+function createStructuredOutputRequestOptions(options, mode = "json-schema") {
   const baseOptions = {
     messages: options.messages,
     reasoning: options.reasoning,
@@ -743,11 +981,43 @@ function createStructuredOutputRequestOptions(options, mode = "native") {
       }
     };
   }
+  if (mode === "json-object") {
+    const format = createOpenAIStructuredOutputFormat(options);
+    const description = format.description ?? DEFAULT_STRUCTURED_OUTPUT_DESCRIPTION;
+    const instruction = [
+      "Return only a valid JSON object.",
+      `Schema name: ${format.name}.`,
+      `Description: ${description}`,
+      `JSON Schema: ${JSON.stringify(format.schema)}`,
+      "Do not include markdown, prose, or any text outside the JSON object."
+    ].join("\n");
+    return {
+      ...baseOptions,
+      messages: insertStructuredOutputSystemMessage(
+        options.messages,
+        instruction
+      ),
+      structuredOutputFormat: {
+        type: "json_object"
+      }
+    };
+  }
   return {
     ...baseOptions,
     structuredOutputFormat: createOpenAIStructuredOutputFormat(options)
   };
 }
+function insertStructuredOutputSystemMessage(messages, content) {
+  const firstNonSystemMessageIndex = messages.findIndex(
+    (message) => message.role !== "system"
+  );
+  const insertionIndex = firstNonSystemMessageIndex === -1 ? messages.length : firstNonSystemMessageIndex;
+  return [
+    ...messages.slice(0, insertionIndex),
+    { role: "system", content },
+    ...messages.slice(insertionIndex)
+  ];
+}
 function createOpenAIStructuredOutputFormat(options) {
   const name = getStructuredOutputName(options);
   const format = zodTextFormat(
@@ -916,10 +1186,19 @@ function formatZodIssues(issues) {
 }
 
 // src/chat-completions/chat-model.ts
-function createOpenAIChatCompletionsModel(client, modelId, modelOptions = {}) {
+function createOpenAIChatCompletionsModel(client, modelId, modelOptions) {
   const provider = modelOptions.providerId ?? "openai";
-  const structuredOutputMode = modelOptions.structuredOutputMode ?? (modelOptions.compatibility ? "tool" : "native");
-  const nonStandardReasoning = modelOptions.nonStandardReasoning ?? modelOptions.compatibility;
+  const capabilities = modelOptions.capabilities;
+  const compatibilityOptions = modelOptions.compatibility;
+  const structuredOutputMode = compatibilityOptions?.structuredOutputMode ?? (compatibilityOptions ? "tool" : "json-schema");
+  const adapterOptions = {
+    capabilities,
+    compatibility: compatibilityOptions !== void 0 && compatibilityOptions.reasoning !== false,
+    maxTokensParameter: compatibilityOptions?.maxTokensParameter,
+    providerId: provider,
+    providerOptions: modelOptions.providerOptions,
+    reasoning: typeof compatibilityOptions?.reasoning === "object" ? compatibilityOptions.reasoning : void 0
+  };
   async function callOpenAIChatCompletionsApi(request, signal) {
     try {
       return await client.chat.completions.create(request, {
@@ -930,20 +1209,19 @@ function createOpenAIChatCompletionsModel(client, modelId, modelOptions = {}) {
     }
   }
   async function generateChat(options) {
-    const request = createGenerateRequest(modelId, options, modelOptions);
-    const response = await callOpenAIChatCompletionsApi(request, options.signal);
-    return mapGenerateResponse(response, {
-      compatibility: nonStandardReasoning
-    });
+    const request = createGenerateRequest(modelId, options, adapterOptions);
+    const response = await callOpenAIChatCompletionsApi(
+      request,
+      options.signal
+    );
+    return mapGenerateResponse(response, adapterOptions);
   }
   async function streamChat(options) {
-    const request = createStreamRequest(modelId, options, modelOptions);
+    const request = createStreamRequest(modelId, options, adapterOptions);
     return createChatStream(
       async () => transformStream(
         await callOpenAIChatCompletionsApi(request, options.signal),
-        {
-          compatibility: nonStandardReasoning
-        }
+        adapterOptions
       ),
       { signal: options.signal }
     );
@@ -951,7 +1229,7 @@ function createOpenAIChatCompletionsModel(client, modelId, modelOptions = {}) {
   return {
     provider,
     modelId,
-    capabilities: getOpenAIModelCapabilities(modelId),
+    capabilities,
     generate: generateChat,
     stream: streamChat,
     async generateObject(options) {
@@ -997,18 +1275,24 @@ function createOpenAIChatCompletionsModel(client, modelId, modelOptions = {}) {
 
 // src/shared/provider-factory.ts
 import OpenAI from "openai";
+import {
+  getRegisteredModelCapabilities as getRegisteredModelCapabilities2
+} from "@core-ai/core-ai";
 
 // src/chat-model.ts
 import { createObjectStream as createObjectStream2, createChatStream as createChatStream2 } from "@core-ai/core-ai";
 
 // src/chat-adapter.ts
-import { getProviderMetadata, clampReasoningEffort as clampReasoningEffort2 } from "@core-ai/core-ai";
+import { getProviderMetadata as getProviderMetadata2, clampReasoningEffort as clampReasoningEffort2 } from "@core-ai/core-ai";
 var ENCRYPTED_REASONING_INCLUDE = "reasoning.encrypted_content";
 var REASONING_SUMMARY_SEPARATOR = "\n\n";
-function convertMessages2(messages) {
-  return messages.flatMap(convertMessage2);
+function convertMessages2(messages, options = {}) {
+  const includeReasoning = options.includeReasoning ?? true;
+  return messages.flatMap(
+    (message) => convertMessage2(message, includeReasoning)
+  );
 }
-function convertMessage2(message) {
+function convertMessage2(message, includeReasoning) {
   if (message.role === "system") {
     return [
       {
@@ -1026,7 +1310,7 @@ function convertMessage2(message) {
     ];
   }
   if (message.role === "assistant") {
-    return convertAssistantMessage(message.parts);
+    return convertAssistantMessage(message.parts, includeReasoning);
   }
   return [
     {
@@ -1036,7 +1320,7 @@ function convertMessage2(message) {
     }
   ];
 }
-function convertAssistantMessage(parts) {
+function convertAssistantMessage(parts, includeReasoning) {
   const items = [];
   const textParts = [];
   const flushTextBuffer = () => {
@@ -1055,7 +1339,7 @@ function convertAssistantMessage(parts) {
       continue;
     }
     if (part.type === "reasoning") {
-      if (getProviderMetadata(
+      if (!includeReasoning || getProviderMetadata2(
         part.providerMetadata,
         "openai"
       ) == null) {
@@ -1090,7 +1374,7 @@ function convertAssistantMessage(parts) {
   return items;
 }
 function getEncryptedReasoningContent(part) {
-  const { encryptedContent } = getProviderMetadata(
+  const { encryptedContent } = getProviderMetadata2(
     part.providerMetadata,
     "openai"
   ) ?? {};
@@ -1140,7 +1424,7 @@ function createRequest2(modelId, options, stream) {
     ...options.structuredOutputFormat ? { text: { format: options.structuredOutputFormat } } : {},
     ...mapOpenAIProviderOptionsToRequestFields2(openaiOptions)
   };
-  if (options.reasoning && getOpenAIModelCapabilities(modelId).reasoning.supported) {
+  if (options.reasoning && getOpenAIModelCapabilities(modelId).reasoning.mode !== "unsupported") {
     request.include = mergeInclude(request.include, [
       ENCRYPTED_REASONING_INCLUDE
     ]);
@@ -1149,10 +1433,13 @@ function createRequest2(modelId, options, stream) {
 }
 function createRequestBase2(modelId, options) {
   validateOpenAIReasoningConfig(modelId, options);
+  const capabilities = getOpenAIModelCapabilities(modelId);
   return {
     model: modelId,
     store: false,
-    input: convertMessages2(options.messages),
+    input: convertMessages2(options.messages, {
+      includeReasoning: capabilities.reasoning.mode !== "unsupported"
+    }),
     ...options.tools && Object.keys(options.tools).length > 0 ? { tools: convertResponseTools(options.tools) } : {},
     ...options.toolChoice ? { tool_choice: convertResponseToolChoice(options.toolChoice) } : {},
     ...mapReasoningToRequestFields2(modelId, options),
@@ -1629,7 +1916,7 @@ function mapReasoningToRequestFields2(modelId, options) {
     return {};
   }
   const capabilities = getOpenAIModelCapabilities(modelId);
-  if (!capabilities.reasoning.supported) {
+  if (capabilities.reasoning.mode === "unsupported") {
     return {};
   }
   const effort = toOpenAIReasoningEffort(
@@ -1656,7 +1943,7 @@ function isReasoningItem(item) {
 }
 
 // src/chat-model.ts
-function createOpenAIChatModel(client, modelId, providerId = "openai") {
+function createOpenAIChatModel(client, modelId, capabilities, providerId = "openai") {
   const provider = providerId;
   async function callOpenAIResponsesApi(request, signal) {
     try {
@@ -1687,7 +1974,7 @@ function createOpenAIChatModel(client, modelId, providerId = "openai") {
   return {
     provider,
     modelId,
-    capabilities: getOpenAIModelCapabilities(modelId),
+    capabilities,
     generate: generateChat,
     stream: streamChat,
     async generateObject(options) {
@@ -1817,16 +2104,37 @@ function createOpenAIProvider(options, factoryOptions = {}) {
     baseURL: options.baseURL
   });
   const providerId = factoryOptions.providerId ?? "openai";
-  const compatibilityEnabled = factoryOptions.compatibility === true || typeof factoryOptions.compatibility === "object";
   const compatibilityOptions = typeof factoryOptions.compatibility === "object" ? factoryOptions.compatibility : void 0;
-  const createResponsesModel = (modelId) => createOpenAIChatModel(client, modelId, providerId);
-  const createChatCompletionsModel = (modelId) => createOpenAIChatCompletionsModel(client, modelId, {
-    providerId,
-    compatibility: compatibilityEnabled,
-    nonStandardReasoning: compatibilityEnabled && (compatibilityOptions?.reasoning ?? true),
-    structuredOutputMode: compatibilityOptions?.structuredOutputMode,
-    maxTokensParameter: compatibilityOptions?.maxTokensParameter
-  });
+  const createResponsesModel = (modelId) => {
+    const capabilities = getRegisteredModelCapabilities2(
+      factoryOptions.modelCapabilities,
+      modelId
+    ) ?? getOpenAIModelCapabilities(modelId);
+    return createOpenAIChatModel(client, modelId, capabilities, providerId);
+  };
+  const createChatCompletionsModel = (modelId) => {
+    const capabilities = getRegisteredModelCapabilities2(
+      factoryOptions.modelCapabilities,
+      modelId
+    ) ?? getOpenAIModelCapabilities(modelId);
+    const compatibility = factoryOptions.compatibility ? {
+      reasoning: typeof compatibilityOptions?.reasoning === "object" ? {
+        ...compatibilityOptions.reasoning,
+        providerMetadataKey: compatibilityOptions.reasoning.providerMetadataKey ?? providerId
+      } : compatibilityOptions?.reasoning ?? true,
+      structuredOutputMode: compatibilityOptions?.structuredOutputMode,
+      maxTokensParameter: compatibilityOptions?.maxTokensParameter
+    } : void 0;
+    return createOpenAIChatCompletionsModel(client, modelId, {
+      providerId,
+      capabilities,
+      compatibility,
+      providerOptions: {
+        key: factoryOptions.providerOptionsKey ?? providerId,
+        schema: factoryOptions.providerOptionsSchema ?? openaiChatGenerateProviderOptionsSchema
+      }
+    });
+  };
   const chat = {
     chatModel: createChatCompletionsModel
   };
@@ -1839,6 +2147,7 @@ function createOpenAIProvider(options, factoryOptions = {}) {
 }
 
 export {
+  OPENAI_MODEL_CAPABILITIES,
   getOpenAIModelCapabilities,
   openaiResponsesGenerateProviderOptionsSchema,
   openaiChatGenerateProviderOptionsSchema,

package/dist/compat.d.ts

@@ -1,7 +1,7 @@
 import * as _core_ai_core_ai from '@core-ai/core-ai';
 import { ChatModel } from '@core-ai/core-ai';
-import { O as OpenAIChatClient, a as OpenAIProvider, b as OpenAIProviderBaseOptions } from './provider-options-CpxtGjm0.js';
-export { c as OpenAICompatGenerateProviderOptions, d as OpenAICompatRequestOptions, o as openaiCompatGenerateProviderOptionsSchema, e as openaiCompatProviderOptionsSchema } from './provider-options-CpxtGjm0.js';
+import { O as OpenAIChatClient, a as OpenAIProvider, b as OpenAIProviderBaseOptions } from './provider-factory-DaVZWYPo.js';
+export { c as OpenAICompatGenerateProviderOptions, d as OpenAICompatRequestOptions, o as openaiCompatGenerateProviderOptionsSchema, e as openaiCompatProviderOptionsSchema } from './provider-factory-DaVZWYPo.js';
 import 'openai';
 import 'zod';
 

package/dist/compat.js

@@ -1,9 +1,10 @@
 import {
   createOpenAIChatCompletionsModel,
   createOpenAIProvider,
+  getOpenAIModelCapabilities,
   openaiCompatGenerateProviderOptionsSchema,
   openaiCompatProviderOptionsSchema
-} from "./chunk-YORO2XQ3.js";
+} from "./chunk-LVGNSX5F.js";
 
 // src/compat/provider.ts
 import OpenAI from "openai";
@@ -20,8 +21,9 @@ function createOpenAICompatChatProvider(options = {}, providerId = "openai") {
   });
   return {
     chatModel: (modelId) => createOpenAIChatCompletionsModel(client, modelId, {
+      capabilities: getOpenAIModelCapabilities(modelId),
       providerId,
-      compatibility: true
+      compatibility: { reasoning: true }
     })
   };
 }
@@ -29,8 +31,9 @@ function createOpenAICompatChatProvider(options = {}, providerId = "openai") {
 // src/compat/chat-model.ts
 function createOpenAICompatChatModel(client, modelId, providerId = "openai") {
   return createOpenAIChatCompletionsModel(client, modelId, {
+    capabilities: getOpenAIModelCapabilities(modelId),
     providerId,
-    compatibility: true
+    compatibility: { reasoning: true }
   });
 }
 export {

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { a as OpenAIProvider$1, b as OpenAIProviderBaseOptions } from './provider-options-CpxtGjm0.js';
-export { O as OpenAIChatClient, f as OpenAIChatCompletionsModelOptions, g as OpenAIChatGenerateProviderOptions, h as OpenAIChatProvider, c as OpenAICompatGenerateProviderOptions, d as OpenAICompatRequestOptions, i as OpenAICompatibility, j as OpenAICompatibilityOptions, k as OpenAIEmbedProviderOptions, l as OpenAIImageProviderOptions, m as OpenAIModelCapabilities, n as OpenAIProviderFactoryOptions, p as OpenAIResponsesGenerateProviderOptions, q as OpenAIResponsesProviderOptions, r as OpenAIStructuredOutputMode, s as createOpenAIChatCompletionsModel, t as createOpenAIProvider, u as getOpenAIModelCapabilities, v as openaiChatGenerateProviderOptionsSchema, o as openaiCompatGenerateProviderOptionsSchema, e as openaiCompatProviderOptionsSchema, w as openaiEmbedProviderOptionsSchema, x as openaiImageProviderOptionsSchema, y as openaiResponsesGenerateProviderOptionsSchema, z as openaiResponsesProviderOptionsSchema } from './provider-options-CpxtGjm0.js';
+import { a as OpenAIProvider$1, b as OpenAIProviderBaseOptions } from './provider-factory-DaVZWYPo.js';
+export { O as OpenAIChatClient, f as OpenAIChatCompletionsModelOptions, g as OpenAIChatGenerateProviderOptions, h as OpenAIChatProvider, c as OpenAICompatGenerateProviderOptions, d as OpenAICompatRequestOptions, i as OpenAICompatibility, j as OpenAICompatibilityOptions, k as OpenAIEmbedProviderOptions, l as OpenAIImageProviderOptions, m as OpenAIModelCapabilities, n as OpenAIProviderFactoryOptions, p as OpenAIResponsesGenerateProviderOptions, q as OpenAIResponsesProviderOptions, r as OpenAIStructuredOutputMode, s as createOpenAIChatCompletionsModel, t as createOpenAIProvider, u as getOpenAIModelCapabilities, v as openaiChatGenerateProviderOptionsSchema, o as openaiCompatGenerateProviderOptionsSchema, e as openaiCompatProviderOptionsSchema, w as openaiEmbedProviderOptionsSchema, x as openaiImageProviderOptionsSchema, y as openaiResponsesGenerateProviderOptionsSchema, z as openaiResponsesProviderOptionsSchema } from './provider-factory-DaVZWYPo.js';
 import 'openai';
 import '@core-ai/core-ai';
 import 'zod';

package/dist/index.js

@@ -1,4 +1,5 @@
 import {
+  OPENAI_MODEL_CAPABILITIES,
   createOpenAIChatCompletionsModel,
   createOpenAIProvider,
   getOpenAIModelCapabilities,
@@ -9,11 +10,13 @@ import {
   openaiImageProviderOptionsSchema,
   openaiResponsesGenerateProviderOptionsSchema,
   openaiResponsesProviderOptionsSchema
-} from "./chunk-YORO2XQ3.js";
+} from "./chunk-LVGNSX5F.js";
 
 // src/provider.ts
 function createOpenAI(options = {}) {
-  return createOpenAIProvider(options);
+  return createOpenAIProvider(options, {
+    modelCapabilities: OPENAI_MODEL_CAPABILITIES
+  });
 }
 export {
   createOpenAI,

package/dist/{provider-options-CpxtGjm0.d.ts → provider-factory-DaVZWYPo.d.ts}

@@ -1,5 +1,5 @@
 import OpenAI from 'openai';
-import { ModelCapabilities, ChatModel, EmbeddingModel, ImageModel } from '@core-ai/core-ai';
+import { ModelCapabilities, ChatModel, EmbeddingModel, ImageModel, ModelCapabilitiesRegistry } from '@core-ai/core-ai';
 import { z } from 'zod';
 
 type OpenAIChatCompletionsCapabilities = {
@@ -10,49 +10,22 @@ type OpenAIModelCapabilities = ModelCapabilities & {
 };
 declare function getOpenAIModelCapabilities(modelId: string): OpenAIModelCapabilities;
 
-type OpenAIChatCompletionsAdapterOptions = {
-    compatibility?: boolean;
-    maxTokensParameter?: OpenAIChatCompletionsCapabilities['maxTokensParameter'];
-};
-
-type OpenAIStructuredOutputMode = 'native' | 'tool';
-
-type OpenAIChatClient = {
-    chat: OpenAI['chat'];
-};
-type OpenAIChatCompletionsModelOptions = OpenAIChatCompletionsAdapterOptions & {
-    providerId?: string;
-    nonStandardReasoning?: boolean;
-    structuredOutputMode?: OpenAIStructuredOutputMode;
-};
-declare function createOpenAIChatCompletionsModel(client: OpenAIChatClient, modelId: string, modelOptions?: OpenAIChatCompletionsModelOptions): ChatModel;
+type OpenAIStructuredOutputMode = 'json-schema' | 'tool' | 'json-object';
 
-type OpenAIProviderBaseOptions = {
-    apiKey?: string;
-    baseURL?: string;
-    client?: OpenAI;
-};
-type OpenAIProvider = {
-    chatModel(modelId: string): ChatModel;
-    chat: OpenAIChatProvider;
-    embeddingModel(modelId: string): EmbeddingModel;
-    imageModel(modelId: string): ImageModel;
-};
-type OpenAIChatProvider = {
-    chatModel(modelId: string): ChatModel;
+type OpenAIReasoningCompatibilityOptions = {
+    requestField: 'reasoning_content' | 'reasoning';
+    providerMetadataKey?: string;
 };
 type OpenAICompatibilityOptions = {
-    reasoning?: boolean;
-    structuredOutputMode?: OpenAIChatCompletionsModelOptions['structuredOutputMode'];
-    maxTokensParameter?: OpenAIChatCompletionsModelOptions['maxTokensParameter'];
+    reasoning?: boolean | OpenAIReasoningCompatibilityOptions;
+    structuredOutputMode?: OpenAIStructuredOutputMode;
+    maxTokensParameter?: OpenAIChatCompletionsCapabilities['maxTokensParameter'];
 };
 type OpenAICompatibility = boolean | OpenAICompatibilityOptions;
-type OpenAIProviderFactoryOptions = {
-    providerId?: string;
-    defaultApi?: 'responses' | 'chat-completions';
-    compatibility?: OpenAICompatibility;
+type OpenAIResolvedReasoningCompatibilityOptions = Required<OpenAIReasoningCompatibilityOptions>;
+type OpenAIResolvedCompatibilityOptions = Pick<OpenAICompatibilityOptions, 'structuredOutputMode' | 'maxTokensParameter'> & {
+    reasoning: boolean | OpenAIResolvedReasoningCompatibilityOptions;
 };
-declare function createOpenAIProvider(options: OpenAIProviderBaseOptions, factoryOptions?: OpenAIProviderFactoryOptions): OpenAIProvider;
 
 declare const openaiResponsesGenerateProviderOptionsSchema: z.ZodObject<{
     store: z.ZodOptional<z.ZodBoolean>;
@@ -69,6 +42,7 @@ declare const openaiResponsesGenerateProviderOptionsSchema: z.ZodObject<{
 }, z.core.$strict>;
 type OpenAIResponsesGenerateProviderOptions = z.infer<typeof openaiResponsesGenerateProviderOptionsSchema>;
 declare const openaiChatGenerateProviderOptionsSchema: z.ZodObject<{
+    user: z.ZodOptional<z.ZodString>;
     store: z.ZodOptional<z.ZodBoolean>;
     serviceTier: z.ZodOptional<z.ZodEnum<{
         auto: "auto";
@@ -78,13 +52,16 @@ declare const openaiChatGenerateProviderOptionsSchema: z.ZodObject<{
         priority: "priority";
     }>>;
     parallelToolCalls: z.ZodOptional<z.ZodBoolean>;
-    user: z.ZodOptional<z.ZodString>;
     stopSequences: z.ZodOptional<z.ZodArray<z.ZodString>>;
     frequencyPenalty: z.ZodOptional<z.ZodNumber>;
     presencePenalty: z.ZodOptional<z.ZodNumber>;
     seed: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
 type OpenAIChatGenerateProviderOptions = z.infer<typeof openaiChatGenerateProviderOptionsSchema>;
+type OpenAIChatGenerateProviderOptionsConfig = {
+    key: string;
+    schema: z.ZodType<OpenAIChatGenerateProviderOptions>;
+};
 declare const openaiEmbedProviderOptionsSchema: z.ZodObject<{
     encodingFormat: z.ZodOptional<z.ZodEnum<{
         float: "float";
@@ -154,6 +131,7 @@ declare const openaiResponsesProviderOptionsSchema: z.ZodObject<{
 }, z.core.$strict>;
 type OpenAIResponsesProviderOptions = OpenAIResponsesGenerateProviderOptions;
 declare const openaiCompatProviderOptionsSchema: z.ZodObject<{
+    user: z.ZodOptional<z.ZodString>;
     store: z.ZodOptional<z.ZodBoolean>;
     serviceTier: z.ZodOptional<z.ZodEnum<{
         auto: "auto";
@@ -163,13 +141,13 @@ declare const openaiCompatProviderOptionsSchema: z.ZodObject<{
         priority: "priority";
     }>>;
     parallelToolCalls: z.ZodOptional<z.ZodBoolean>;
-    user: z.ZodOptional<z.ZodString>;
     stopSequences: z.ZodOptional<z.ZodArray<z.ZodString>>;
     frequencyPenalty: z.ZodOptional<z.ZodNumber>;
     presencePenalty: z.ZodOptional<z.ZodNumber>;
     seed: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
 declare const openaiCompatGenerateProviderOptionsSchema: z.ZodObject<{
+    user: z.ZodOptional<z.ZodString>;
     store: z.ZodOptional<z.ZodBoolean>;
     serviceTier: z.ZodOptional<z.ZodEnum<{
         auto: "auto";
@@ -179,7 +157,6 @@ declare const openaiCompatGenerateProviderOptionsSchema: z.ZodObject<{
         priority: "priority";
     }>>;
     parallelToolCalls: z.ZodOptional<z.ZodBoolean>;
-    user: z.ZodOptional<z.ZodString>;
     stopSequences: z.ZodOptional<z.ZodArray<z.ZodString>>;
     frequencyPenalty: z.ZodOptional<z.ZodNumber>;
     presencePenalty: z.ZodOptional<z.ZodNumber>;
@@ -188,4 +165,48 @@ declare const openaiCompatGenerateProviderOptionsSchema: z.ZodObject<{
 type OpenAICompatGenerateProviderOptions = OpenAIChatGenerateProviderOptions;
 type OpenAICompatRequestOptions = OpenAIChatGenerateProviderOptions;
 
+type OpenAIChatCompletionsAdapterOptions = {
+    capabilities?: ModelCapabilities;
+    compatibility?: boolean;
+    maxTokensParameter?: OpenAIChatCompletionsCapabilities['maxTokensParameter'];
+    providerId?: string;
+    providerOptions?: OpenAIChatGenerateProviderOptionsConfig;
+    reasoning?: OpenAIResolvedReasoningCompatibilityOptions;
+};
+
+type OpenAIChatClient = {
+    chat: OpenAI['chat'];
+};
+type OpenAIChatCompletionsModelOptions = {
+    capabilities: ModelCapabilities;
+    providerId?: string;
+    compatibility?: OpenAIResolvedCompatibilityOptions;
+    providerOptions?: OpenAIChatCompletionsAdapterOptions['providerOptions'];
+};
+declare function createOpenAIChatCompletionsModel(client: OpenAIChatClient, modelId: string, modelOptions: OpenAIChatCompletionsModelOptions): ChatModel;
+
+type OpenAIProviderBaseOptions = {
+    apiKey?: string;
+    baseURL?: string;
+    client?: OpenAI;
+};
+type OpenAIProvider = {
+    chatModel(modelId: string): ChatModel;
+    chat: OpenAIChatProvider;
+    embeddingModel(modelId: string): EmbeddingModel;
+    imageModel(modelId: string): ImageModel;
+};
+type OpenAIChatProvider = {
+    chatModel(modelId: string): ChatModel;
+};
+type OpenAIProviderFactoryOptions = {
+    modelCapabilities?: ModelCapabilitiesRegistry;
+    providerId?: string;
+    providerOptionsKey?: string;
+    providerOptionsSchema?: OpenAIChatGenerateProviderOptionsConfig['schema'];
+    defaultApi?: 'responses' | 'chat-completions';
+    compatibility?: OpenAICompatibility;
+};
+declare function createOpenAIProvider(options: OpenAIProviderBaseOptions, factoryOptions?: OpenAIProviderFactoryOptions): OpenAIProvider;
+
 export { type OpenAIChatClient as O, type OpenAIProvider as a, type OpenAIProviderBaseOptions as b, type OpenAICompatGenerateProviderOptions as c, type OpenAICompatRequestOptions as d, openaiCompatProviderOptionsSchema as e, type OpenAIChatCompletionsModelOptions as f, type OpenAIChatGenerateProviderOptions as g, type OpenAIChatProvider as h, type OpenAICompatibility as i, type OpenAICompatibilityOptions as j, type OpenAIEmbedProviderOptions as k, type OpenAIImageProviderOptions as l, type OpenAIModelCapabilities as m, type OpenAIProviderFactoryOptions as n, openaiCompatGenerateProviderOptionsSchema as o, type OpenAIResponsesGenerateProviderOptions as p, type OpenAIResponsesProviderOptions as q, type OpenAIStructuredOutputMode as r, createOpenAIChatCompletionsModel as s, createOpenAIProvider as t, getOpenAIModelCapabilities as u, openaiChatGenerateProviderOptionsSchema as v, openaiEmbedProviderOptionsSchema as w, openaiImageProviderOptionsSchema as x, openaiResponsesGenerateProviderOptionsSchema as y, openaiResponsesProviderOptionsSchema as z };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/openai",
-    "version": "0.15.0",
+    "version": "0.17.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.15.0",
+        "@core-ai/core-ai": "^0.17.0",
         "openai": "^6.46.0"
     },
     "peerDependencies": {