@core-ai/openai 0.24.0 → 0.26.0

package/dist/{chunk-SCXEGDFV.js → chunk-FOVN4IGD.js}

@@ -2,8 +2,10 @@
 import {
   getRegisteredModelCapabilities,
   MULTIMODAL_INPUT_MODALITIES,
+  SUPPORTED_TOOL_SCHEMA_STRICTNESS,
   stripModelDateSuffix,
   TEXT_ONLY_MODALITIES,
+  UNSUPPORTED_TOOL_SCHEMA_STRICTNESS,
   UNKNOWN_MODEL
 } from "@core-ai/core-ai";
 var STANDARD_EFFORTS = [
@@ -37,7 +39,8 @@ function createCapabilities({
   supportedEfforts,
   restrictsSamplingParams,
   maxTokensParameter = "max_completion_tokens",
-  modalities = MULTIMODAL_INPUT_MODALITIES
+  modalities = MULTIMODAL_INPUT_MODALITIES,
+  strictToolSchemas = SUPPORTED_TOOL_SCHEMA_STRICTNESS
 }) {
   return {
     reasoning: {
@@ -47,6 +50,9 @@ function createCapabilities({
       supportedToolChoices: ["auto", "none", "required", "tool"]
     },
     modalities,
+    tools: {
+      strictSchemas: strictToolSchemas
+    },
     chatCompletions: {
       maxTokensParameter
     }
@@ -83,7 +89,8 @@ var GPT_5_HIGH_REASONING_CAPABILITIES = createCapabilities({
 });
 function createNoReasoningCapabilities({
   maxTokensParameter,
-  modalities = MULTIMODAL_INPUT_MODALITIES
+  modalities = MULTIMODAL_INPUT_MODALITIES,
+  strictToolSchemas = SUPPORTED_TOOL_SCHEMA_STRICTNESS
 }) {
   return {
     reasoning: {
@@ -93,6 +100,9 @@ function createNoReasoningCapabilities({
       supportedToolChoices: ["auto", "none", "required", "tool"]
     },
     modalities,
+    tools: {
+      strictSchemas: strictToolSchemas
+    },
     chatCompletions: {
       maxTokensParameter
     }
@@ -101,21 +111,19 @@ function createNoReasoningCapabilities({
 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
+  modalities: OPENAI_AUDIO_INPUT_MODALITIES,
+  strictToolSchemas: UNSUPPORTED_TOOL_SCHEMA_STRICTNESS
 });
 var GPT_4O_AUDIO_CAPABILITIES = createNoReasoningCapabilities({
   maxTokensParameter: "max_tokens",
-  modalities: OPENAI_AUDIO_INPUT_MODALITIES
+  modalities: OPENAI_AUDIO_INPUT_MODALITIES,
+  strictToolSchemas: UNSUPPORTED_TOOL_SCHEMA_STRICTNESS
 });
 var O_SERIES_MAX_REASONING_CAPABILITIES = createCapabilities({
   supportedEfforts: MAX_EFFORTS,
@@ -126,7 +134,17 @@ var O_SERIES_TEXT_ONLY_CAPABILITIES = createCapabilities({
   restrictsSamplingParams: false,
   modalities: TEXT_ONLY_MODALITIES
 });
+var LEGACY_NO_STRICT_TOOLS_CAPABILITIES = createNoReasoningCapabilities({
+  maxTokensParameter: "max_tokens",
+  strictToolSchemas: UNSUPPORTED_TOOL_SCHEMA_STRICTNESS
+});
+var LEGACY_NO_STRICT_TOOLS_TEXT_ONLY_CAPABILITIES = createNoReasoningCapabilities({
+  maxTokensParameter: "max_tokens",
+  modalities: TEXT_ONLY_MODALITIES,
+  strictToolSchemas: UNSUPPORTED_TOOL_SCHEMA_STRICTNESS
+});
 var OPENAI_MODEL_CAPABILITIES = {
+  "gpt-4o-2024-05-13": LEGACY_NO_STRICT_TOOLS_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,
@@ -160,8 +178,8 @@ var OPENAI_MODEL_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_TEXT_ONLY_CAPABILITIES,
+  "gpt-4-turbo": LEGACY_NO_STRICT_TOOLS_CAPABILITIES,
+  "gpt-3.5-turbo": LEGACY_NO_STRICT_TOOLS_TEXT_ONLY_CAPABILITIES,
   "gpt-audio-1.5": AUDIO_CAPABILITIES,
   "gpt-audio": AUDIO_CAPABILITIES,
   "gpt-audio-mini": AUDIO_CAPABILITIES,
@@ -177,7 +195,14 @@ var OPENAI_REASONING_EFFORT_MAP = {
   max: "xhigh"
 };
 function getOpenAIModelCapabilities(modelId) {
-  return getRegisteredModelCapabilities(OPENAI_MODEL_CAPABILITIES, modelId) ?? UNKNOWN_MODEL_CAPABILITIES;
+  return getRegisteredModelCapabilities(
+    OPENAI_MODEL_CAPABILITIES,
+    getFineTuneBaseModelId(modelId) ?? modelId
+  ) ?? UNKNOWN_MODEL_CAPABILITIES;
+}
+var FINE_TUNE_MODEL_ID_PATTERN = /^ft:([^:]+):/;
+function getFineTuneBaseModelId(modelId) {
+  return FINE_TUNE_MODEL_ID_PATTERN.exec(modelId)?.[1];
 }
 function toOpenAIResponsesCapabilities(capabilities) {
   if (!capabilities.modalities.input.includes("audio")) {
@@ -204,7 +229,8 @@ var openaiResponsesGenerateProviderOptionsSchema = z.object({
   serviceTier: z.enum(["auto", "default", "flex", "scale", "priority"]).optional(),
   include: z.array(z.string()).optional(),
   parallelToolCalls: z.boolean().optional(),
-  user: z.string().optional()
+  user: z.string().optional(),
+  promptCacheKey: z.string().optional()
 }).strict();
 var openaiChatGenerateProviderOptionsSchema = openaiResponsesGenerateProviderOptionsSchema.omit({
   include: true
@@ -235,11 +261,14 @@ function parseOpenAIProviderOptions(providerOptions, key, schema) {
   }
   return schema.parse(rawOptions);
 }
-function parseOpenAIResponsesGenerateProviderOptions(providerOptions) {
+function parseOpenAIResponsesGenerateProviderOptions(providerOptions, config = {
+  key: "openai",
+  schema: openaiResponsesGenerateProviderOptionsSchema
+}) {
   return parseOpenAIProviderOptions(
     providerOptions,
-    "openai",
-    openaiResponsesGenerateProviderOptionsSchema
+    config.key,
+    config.schema
   );
 }
 function parseOpenAIChatGenerateProviderOptions(providerOptions, config = {
@@ -285,17 +314,37 @@ import {
 } from "@core-ai/core-ai";
 
 // src/shared/tools.ts
-import { zodSchemaToJsonSchema } from "@core-ai/core-ai";
-function convertTools(tools) {
+import {
+  normalizeStrictJsonSchema,
+  validateToolSchemaStrictness,
+  zodSchemaToJsonSchema
+} from "@core-ai/core-ai";
+function convertTools(tools, options) {
+  validateToolSchemaStrictness({ tools, ...options });
   return Object.values(tools).map((tool) => ({
     type: "function",
     function: {
       name: tool.name,
       description: tool.description,
-      parameters: zodSchemaToJsonSchema(tool.parameters)
+      parameters: convertToolParameters(tool),
+      ...tool.strict === true ? { strict: true } : {}
     }
   }));
 }
+function convertResponseTools(tools, options) {
+  validateToolSchemaStrictness({ tools, ...options });
+  return Object.values(tools).map((tool) => ({
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    parameters: convertToolParameters(tool),
+    strict: tool.strict === true
+  }));
+}
+function convertToolParameters(tool) {
+  const schema = zodSchemaToJsonSchema(tool.parameters);
+  return tool.strict === true ? normalizeStrictJsonSchema(schema) : schema;
+}
 function convertToolChoice(choice) {
   if (typeof choice === "string") {
     return choice;
@@ -308,6 +357,14 @@ function convertToolChoice(choice) {
   };
 }
 
+// src/shared/usage.ts
+function normalizeOutputTokens(outputTokens, reasoningTokens, accounting = "included") {
+  if (accounting === "separate" && reasoningTokens !== void 0) {
+    return outputTokens + reasoningTokens;
+  }
+  return outputTokens;
+}
+
 // src/shared/utils.ts
 import { ValidationError } from "@core-ai/core-ai";
 function safeParseJsonObject(json) {
@@ -529,7 +586,13 @@ function createRequestBase(modelId, options, adapterOptions) {
   return {
     model: modelId,
     messages: convertMessages(options.messages, adapterOptions),
-    ...options.tools && Object.keys(options.tools).length > 0 ? { tools: convertTools(options.tools) } : {},
+    ...options.tools && Object.keys(options.tools).length > 0 ? {
+      tools: convertTools(options.tools, {
+        capabilities: adapterOptions.capabilities,
+        modelId,
+        providerId: adapterOptions.providerId
+      })
+    } : {},
     ...options.toolChoice ? { tool_choice: convertToolChoice(options.toolChoice) } : {},
     ...reasoningFields,
     ...mapSamplingToRequestFields(modelId, options, adapterOptions)
@@ -552,7 +615,8 @@ function mapOpenAIProviderOptionsToRequestFields(options) {
     ...options?.stopSequences ? { stop: options.stopSequences } : {},
     ...options?.frequencyPenalty !== void 0 ? { frequency_penalty: options.frequencyPenalty } : {},
     ...options?.presencePenalty !== void 0 ? { presence_penalty: options.presencePenalty } : {},
-    ...options?.seed !== void 0 ? { seed: options.seed } : {}
+    ...options?.seed !== void 0 ? { seed: options.seed } : {},
+    ...options?.promptCacheKey !== void 0 ? { prompt_cache_key: options.promptCacheKey } : {}
   };
 }
 function mapResponseFormatToRequestFields(format) {
@@ -616,7 +680,11 @@ function mapGenerateResponse(response, adapterOptions = {}) {
     finishReason: mapFinishReason(firstChoice.finish_reason),
     usage: {
       inputTokens: response.usage?.prompt_tokens ?? 0,
-      outputTokens: response.usage?.completion_tokens ?? 0,
+      outputTokens: normalizeOutputTokens(
+        response.usage?.completion_tokens ?? 0,
+        reasoningTokens,
+        adapterOptions.reasoningTokenAccounting
+      ),
       inputTokenDetails: {
         cacheReadTokens: response.usage?.prompt_tokens_details?.cached_tokens ?? 0,
         cacheWriteTokens: 0
@@ -715,7 +783,11 @@ async function* transformStream(stream, adapterOptions = {}) {
       const reasoningTokens = chunk.usage.completion_tokens_details?.reasoning_tokens;
       usage = {
         inputTokens: chunk.usage.prompt_tokens ?? 0,
-        outputTokens: chunk.usage.completion_tokens ?? 0,
+        outputTokens: normalizeOutputTokens(
+          chunk.usage.completion_tokens ?? 0,
+          reasoningTokens,
+          adapterOptions.reasoningTokenAccounting
+        ),
         inputTokenDetails: {
           cacheReadTokens: chunk.usage.prompt_tokens_details?.cached_tokens ?? 0,
           cacheWriteTokens: 0
@@ -1310,6 +1382,7 @@ function createOpenAIChatCompletionsModel(client, modelId, modelOptions) {
     capabilities,
     compatibility: compatibilityOptions !== void 0 && compatibilityOptions.reasoning !== false,
     maxTokensParameter: compatibilityOptions?.maxTokensParameter,
+    reasoningTokenAccounting: compatibilityOptions?.reasoningTokenAccounting,
     providerId: provider,
     providerOptions: modelOptions.providerOptions,
     reasoning: typeof compatibilityOptions?.reasoning === "object" ? compatibilityOptions.reasoning : void 0
@@ -1411,9 +1484,11 @@ import {
 } from "@core-ai/core-ai";
 var DEFAULT_PROVIDER_ID = "openai";
 function resolveAdapterOptions(modelId, adapterOptions) {
-  const capabilities = adapterOptions.capabilities ?? getOpenAIModelCapabilities(modelId);
   return {
-    capabilities: toOpenAIResponsesCapabilities(capabilities),
+    // Callers that pass capabilities (the provider factory) have already
+    // applied the Responses-specific restrictions; only the fallback
+    // lookup applies them here.
+    capabilities: adapterOptions.capabilities ?? toOpenAIResponsesCapabilities(getOpenAIModelCapabilities(modelId)),
     // Also the ownership key for encrypted reasoning metadata — Azure
     // (`azure-openai`) must not share the `openai` namespace.
     providerId: adapterOptions.providerId ?? DEFAULT_PROVIDER_ID
@@ -1573,7 +1648,8 @@ function createStreamRequest2(modelId, options, adapterOptions = {}) {
 function createRequest2(modelId, options, stream, adapterOptions) {
   const resolved = resolveAdapterOptions(modelId, adapterOptions);
   const openaiOptions = parseOpenAIResponsesGenerateProviderOptions(
-    options.providerOptions
+    options.providerOptions,
+    adapterOptions.providerOptions
   );
   const request = {
     ...createRequestBase2(modelId, options, resolved),
@@ -1581,7 +1657,8 @@ function createRequest2(modelId, options, stream, adapterOptions) {
     ...options.structuredOutputFormat ? { text: { format: options.structuredOutputFormat } } : {},
     ...mapOpenAIProviderOptionsToRequestFields2(openaiOptions)
   };
-  if (options.reasoning && resolved.capabilities.reasoning.mode !== "unsupported") {
+  const reasoningMode = resolved.capabilities.reasoning.mode;
+  if (reasoningMode === "always-on" || options.reasoning && reasoningMode !== "unsupported") {
     request.include = mergeInclude(request.include, [
       ENCRYPTED_REASONING_INCLUDE
     ]);
@@ -1603,7 +1680,13 @@ function createRequestBase2(modelId, options, { capabilities, providerId }) {
       includeReasoning: capabilities.reasoning.mode !== "unsupported",
       providerId
     }),
-    ...options.tools && Object.keys(options.tools).length > 0 ? { tools: convertResponseTools(options.tools) } : {},
+    ...options.tools && Object.keys(options.tools).length > 0 ? {
+      tools: convertResponseTools(options.tools, {
+        capabilities,
+        modelId,
+        providerId
+      })
+    } : {},
     ...options.toolChoice ? { tool_choice: convertResponseToolChoice(options.toolChoice) } : {},
     ...mapReasoningToRequestFields2(options, capabilities),
     ...mapSamplingToRequestFields2(options)
@@ -1619,14 +1702,6 @@ function validateResponsesInputModalities(options) {
     throw error;
   }
 }
-function convertResponseTools(tools) {
-  return convertTools(tools).map((tool) => ({
-    type: "function",
-    name: tool.function.name,
-    description: tool.function.description,
-    parameters: tool.function.parameters
-  }));
-}
 function convertResponseToolChoice(choice) {
   const converted = convertToolChoice(choice);
   if (typeof converted === "string") {
@@ -1659,7 +1734,8 @@ function mapOpenAIProviderOptionsToRequestFields2(options) {
     ...options?.serviceTier !== void 0 ? { service_tier: options.serviceTier } : {},
     ...options?.include ? { include: options.include } : {},
     ...options?.parallelToolCalls !== void 0 ? { parallel_tool_calls: options.parallelToolCalls } : {},
-    ...options?.user !== void 0 ? { user: options.user } : {}
+    ...options?.user !== void 0 ? { user: options.user } : {},
+    ...options?.promptCacheKey !== void 0 ? { prompt_cache_key: options.promptCacheKey } : {}
   };
 }
 function mapGenerateResponse2(response, adapterOptions = {}) {
@@ -2115,7 +2191,7 @@ function mapReasoningToRequestFields2(options, capabilities) {
   if (!options.reasoning) {
     return {};
   }
-  if (capabilities.reasoning.mode === "unsupported") {
+  if (capabilities.reasoning.mode === "unsupported" || capabilities.reasoning.supportedEfforts.length === 0) {
     return {};
   }
   const effort = toOpenAIReasoningEffort(
@@ -2142,9 +2218,13 @@ function isReasoningItem(item) {
 }
 
 // src/chat-model.ts
-function createOpenAIChatModel(client, modelId, capabilities, providerId = DEFAULT_PROVIDER_ID) {
-  const provider = providerId;
-  const adapterOptions = { capabilities, providerId };
+function createOpenAIChatModel(client, modelId, capabilities, modelOptions = {}) {
+  const provider = modelOptions.providerId ?? DEFAULT_PROVIDER_ID;
+  const adapterOptions = {
+    capabilities,
+    providerId: provider,
+    providerOptions: modelOptions.providerOptions
+  };
   async function callOpenAIResponsesApi(request, signal) {
     try {
       return await client.responses.create(request, {
@@ -2313,37 +2393,39 @@ function createOpenAIProvider(options, factoryOptions = {}) {
   });
   const providerId = factoryOptions.providerId ?? "openai";
   const compatibilityOptions = typeof factoryOptions.compatibility === "object" ? factoryOptions.compatibility : void 0;
-  const createResponsesModel = (modelId) => {
-    const capabilities = getRegisteredModelCapabilities2(
-      factoryOptions.modelCapabilities,
-      modelId
-    ) ?? getOpenAIModelCapabilities(modelId);
-    return createOpenAIChatModel(
-      client,
-      modelId,
-      toOpenAIResponsesCapabilities(capabilities),
-      providerId
-    );
-  };
+  const resolveCapabilities = (modelId) => getRegisteredModelCapabilities2(
+    factoryOptions.modelCapabilities,
+    modelId
+  ) ?? getOpenAIModelCapabilities(modelId);
+  const createResponsesModel = (modelId) => createOpenAIChatModel(
+    client,
+    modelId,
+    toOpenAIResponsesCapabilities(resolveCapabilities(modelId)),
+    {
+      providerId,
+      providerOptions: {
+        key: providerId,
+        schema: factoryOptions.responsesProviderOptionsSchema ?? openaiResponsesGenerateProviderOptionsSchema
+      }
+    }
+  );
   const createChatCompletionsModel = (modelId) => {
-    const capabilities = getRegisteredModelCapabilities2(
-      factoryOptions.modelCapabilities,
-      modelId
-    ) ?? getOpenAIModelCapabilities(modelId);
+    const capabilities = resolveCapabilities(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
+      maxTokensParameter: compatibilityOptions?.maxTokensParameter,
+      reasoningTokenAccounting: compatibilityOptions?.reasoningTokenAccounting
     } : void 0;
     return createOpenAIChatCompletionsModel(client, modelId, {
       providerId,
       capabilities,
       compatibility,
       providerOptions: {
-        key: factoryOptions.providerOptionsKey ?? providerId,
+        key: providerId,
         schema: factoryOptions.providerOptionsSchema ?? 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-factory-DaVZWYPo.js';
-export { c as OpenAICompatGenerateProviderOptions, d as OpenAICompatRequestOptions, o as openaiCompatGenerateProviderOptionsSchema, e as openaiCompatProviderOptionsSchema } from './provider-factory-DaVZWYPo.js';
+import { O as OpenAIChatClient, a as OpenAIProvider, b as OpenAIProviderBaseOptions } from './provider-factory-BIr9zZ2d.js';
+export { c as OpenAICompatGenerateProviderOptions, d as OpenAICompatRequestOptions, o as openaiCompatGenerateProviderOptionsSchema, e as openaiCompatProviderOptionsSchema } from './provider-factory-BIr9zZ2d.js';
 import 'openai';
 import 'zod';
 

package/dist/compat.js

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

package/dist/index.d.ts

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

package/dist/index.js

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

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

@@ -12,6 +12,13 @@ declare function getOpenAIModelCapabilities(modelId: string): OpenAIModelCapabil
 
 type OpenAIStructuredOutputMode = 'json-schema' | 'tool' | 'json-object';
 
+/**
+ * How an endpoint reports reasoning tokens relative to its output-token total.
+ * `included` (OpenAI): the output total already contains them. `separate`
+ * (e.g. xAI Chat Completions): they are reported only in the details object.
+ */
+type OpenAIReasoningTokenAccounting = 'included' | 'separate';
+
 type OpenAIReasoningCompatibilityOptions = {
     requestField: 'reasoning_content' | 'reasoning';
     providerMetadataKey?: string;
@@ -20,10 +27,12 @@ type OpenAICompatibilityOptions = {
     reasoning?: boolean | OpenAIReasoningCompatibilityOptions;
     structuredOutputMode?: OpenAIStructuredOutputMode;
     maxTokensParameter?: OpenAIChatCompletionsCapabilities['maxTokensParameter'];
+    /** Chat Completions only. Defaults to `included`. */
+    reasoningTokenAccounting?: OpenAIReasoningTokenAccounting;
 };
 type OpenAICompatibility = boolean | OpenAICompatibilityOptions;
 type OpenAIResolvedReasoningCompatibilityOptions = Required<OpenAIReasoningCompatibilityOptions>;
-type OpenAIResolvedCompatibilityOptions = Pick<OpenAICompatibilityOptions, 'structuredOutputMode' | 'maxTokensParameter'> & {
+type OpenAIResolvedCompatibilityOptions = Pick<OpenAICompatibilityOptions, 'structuredOutputMode' | 'maxTokensParameter' | 'reasoningTokenAccounting'> & {
     reasoning: boolean | OpenAIResolvedReasoningCompatibilityOptions;
 };
 
@@ -39,6 +48,7 @@ declare const openaiResponsesGenerateProviderOptionsSchema: z.ZodObject<{
     include: z.ZodOptional<z.ZodArray<z.ZodString>>;
     parallelToolCalls: z.ZodOptional<z.ZodBoolean>;
     user: z.ZodOptional<z.ZodString>;
+    promptCacheKey: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 type OpenAIResponsesGenerateProviderOptions = z.infer<typeof openaiResponsesGenerateProviderOptionsSchema>;
 declare const openaiChatGenerateProviderOptionsSchema: z.ZodObject<{
@@ -52,12 +62,17 @@ declare const openaiChatGenerateProviderOptionsSchema: z.ZodObject<{
         priority: "priority";
     }>>;
     parallelToolCalls: z.ZodOptional<z.ZodBoolean>;
+    promptCacheKey: 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 OpenAIResponsesGenerateProviderOptionsConfig = {
+    key: string;
+    schema: z.ZodType<OpenAIResponsesGenerateProviderOptions>;
+};
 type OpenAIChatGenerateProviderOptionsConfig = {
     key: string;
     schema: z.ZodType<OpenAIChatGenerateProviderOptions>;
@@ -128,6 +143,7 @@ declare const openaiResponsesProviderOptionsSchema: z.ZodObject<{
     include: z.ZodOptional<z.ZodArray<z.ZodString>>;
     parallelToolCalls: z.ZodOptional<z.ZodBoolean>;
     user: z.ZodOptional<z.ZodString>;
+    promptCacheKey: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 type OpenAIResponsesProviderOptions = OpenAIResponsesGenerateProviderOptions;
 declare const openaiCompatProviderOptionsSchema: z.ZodObject<{
@@ -141,6 +157,7 @@ declare const openaiCompatProviderOptionsSchema: z.ZodObject<{
         priority: "priority";
     }>>;
     parallelToolCalls: z.ZodOptional<z.ZodBoolean>;
+    promptCacheKey: z.ZodOptional<z.ZodString>;
     stopSequences: z.ZodOptional<z.ZodArray<z.ZodString>>;
     frequencyPenalty: z.ZodOptional<z.ZodNumber>;
     presencePenalty: z.ZodOptional<z.ZodNumber>;
@@ -157,6 +174,7 @@ declare const openaiCompatGenerateProviderOptionsSchema: z.ZodObject<{
         priority: "priority";
     }>>;
     parallelToolCalls: z.ZodOptional<z.ZodBoolean>;
+    promptCacheKey: z.ZodOptional<z.ZodString>;
     stopSequences: z.ZodOptional<z.ZodArray<z.ZodString>>;
     frequencyPenalty: z.ZodOptional<z.ZodNumber>;
     presencePenalty: z.ZodOptional<z.ZodNumber>;
@@ -172,6 +190,7 @@ type OpenAIChatCompletionsAdapterOptions = {
     providerId?: string;
     providerOptions?: OpenAIChatGenerateProviderOptionsConfig;
     reasoning?: OpenAIResolvedReasoningCompatibilityOptions;
+    reasoningTokenAccounting?: OpenAIReasoningTokenAccounting;
 };
 
 type OpenAIChatClient = {
@@ -201,12 +220,15 @@ type OpenAIChatProvider = {
 };
 type OpenAIProviderFactoryOptions = {
     modelCapabilities?: ModelCapabilitiesRegistry;
+    /** Also the `providerOptions` and reasoning `providerMetadata` key. */
     providerId?: string;
-    providerOptionsKey?: string;
+    /** Chat Completions provider options schema. */
     providerOptionsSchema?: OpenAIChatGenerateProviderOptionsConfig['schema'];
+    /** Responses API provider options schema. */
+    responsesProviderOptionsSchema?: OpenAIResponsesGenerateProviderOptionsConfig['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 };
+export { openaiImageProviderOptionsSchema as A, openaiResponsesGenerateProviderOptionsSchema as B, openaiResponsesProviderOptionsSchema as C, 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 OpenAIChatGenerateProviderOptionsConfig as h, type OpenAIChatProvider as i, type OpenAICompatibility as j, type OpenAICompatibilityOptions as k, type OpenAIEmbedProviderOptions as l, type OpenAIImageProviderOptions as m, type OpenAIModelCapabilities as n, openaiCompatGenerateProviderOptionsSchema as o, type OpenAIProviderFactoryOptions as p, type OpenAIReasoningTokenAccounting as q, type OpenAIResponsesGenerateProviderOptions as r, type OpenAIResponsesGenerateProviderOptionsConfig as s, type OpenAIResponsesProviderOptions as t, type OpenAIStructuredOutputMode as u, createOpenAIChatCompletionsModel as v, createOpenAIProvider as w, getOpenAIModelCapabilities as x, openaiChatGenerateProviderOptionsSchema as y, openaiEmbedProviderOptionsSchema as z };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/openai",
-    "version": "0.24.0",
+    "version": "0.26.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.24.0",
+        "@core-ai/core-ai": "^0.26.0",
         "openai": "^6.46.0"
     },
     "peerDependencies": {