@core-ai/openai 0.6.0 → 0.7.0

package/dist/{chunk-7CU5JW63.js → chunk-T4N4CRQS.js}

@@ -161,7 +161,7 @@ function mapOpenAIImageProviderOptionsToRequestFields(options) {
 }
 
 // src/shared/tools.ts
-import { zodToJsonSchema } from "zod-to-json-schema";
+import { zodSchemaToJsonSchema } from "@core-ai/core-ai";
 var DEFAULT_STRUCTURED_OUTPUT_TOOL_NAME = "core_ai_generate_object";
 var DEFAULT_STRUCTURED_OUTPUT_TOOL_DESCRIPTION = "Return a JSON object that matches the requested schema.";
 function convertTools(tools) {
@@ -170,7 +170,7 @@ function convertTools(tools) {
     function: {
       name: tool.name,
       description: tool.description,
-      parameters: zodToJsonSchema(tool.parameters)
+      parameters: zodSchemaToJsonSchema(tool.parameters)
     }
   }));
 }
@@ -221,6 +221,20 @@ var DEFAULT_CAPABILITIES = {
   }
 };
 var MODEL_CAPABILITIES = {
+  "gpt-5.4": {
+    reasoning: {
+      supportsEffort: true,
+      supportedRange: ["low", "medium", "high", "max"],
+      restrictsSamplingParams: true
+    }
+  },
+  "gpt-5.4-pro": {
+    reasoning: {
+      supportsEffort: true,
+      supportedRange: ["low", "medium", "high", "max"],
+      restrictsSamplingParams: true
+    }
+  },
   "gpt-5.2": {
     reasoning: {
       supportsEffort: true,

package/dist/compat.d.ts

@@ -1,6 +1,6 @@
 import OpenAI from 'openai';
 import { ChatModel, EmbeddingModel, ImageModel } from '@core-ai/core-ai';
-export { O as OpenAICompatGenerateProviderOptions, a as OpenAICompatRequestOptions, o as openaiCompatGenerateProviderOptionsSchema, b as openaiCompatProviderOptionsSchema } from './provider-options-DK-Tz0pz.js';
+export { O as OpenAICompatGenerateProviderOptions, a as OpenAICompatRequestOptions, o as openaiCompatGenerateProviderOptionsSchema, b as openaiCompatProviderOptionsSchema } from './provider-options-l7CmAA94.js';
 import 'zod';
 
 type OpenAICompatProviderOptions = {

package/dist/compat.js

@@ -14,7 +14,7 @@ import {
   toOpenAIReasoningEffort,
   validateOpenAIReasoningConfig,
   wrapOpenAIError
-} from "./chunk-7CU5JW63.js";
+} from "./chunk-T4N4CRQS.js";
 
 // src/compat/provider.ts
 import OpenAI from "openai";

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import OpenAI from 'openai';
 import { ChatModel, EmbeddingModel, ImageModel } from '@core-ai/core-ai';
-export { O as OpenAICompatGenerateProviderOptions, a as OpenAICompatRequestOptions, c as OpenAIEmbedProviderOptions, d as OpenAIImageProviderOptions, e as OpenAIResponsesGenerateProviderOptions, f as OpenAIResponsesProviderOptions, o as openaiCompatGenerateProviderOptionsSchema, b as openaiCompatProviderOptionsSchema, g as openaiEmbedProviderOptionsSchema, h as openaiImageProviderOptionsSchema, i as openaiResponsesGenerateProviderOptionsSchema, j as openaiResponsesProviderOptionsSchema } from './provider-options-DK-Tz0pz.js';
+export { O as OpenAICompatGenerateProviderOptions, a as OpenAICompatRequestOptions, c as OpenAIEmbedProviderOptions, d as OpenAIImageProviderOptions, e as OpenAIResponsesGenerateProviderOptions, f as OpenAIResponsesProviderOptions, o as openaiCompatGenerateProviderOptionsSchema, b as openaiCompatProviderOptionsSchema, g as openaiEmbedProviderOptionsSchema, h as openaiImageProviderOptionsSchema, i as openaiResponsesGenerateProviderOptionsSchema, j as openaiResponsesProviderOptionsSchema } from './provider-options-l7CmAA94.js';
 import 'zod';
 
 type OpenAIProviderOptions = {

package/dist/index.js

@@ -18,7 +18,7 @@ import {
   toOpenAIReasoningEffort,
   validateOpenAIReasoningConfig,
   wrapOpenAIError
-} from "./chunk-7CU5JW63.js";
+} from "./chunk-T4N4CRQS.js";
 
 // src/provider.ts
 import OpenAI from "openai";
@@ -242,9 +242,7 @@ function mapGenerateResponse(response) {
       continue;
     }
     if (isOutputMessage(item)) {
-      for (const part of mapMessageTextParts(item)) {
-        parts.push(part);
-      }
+      parts.push(...mapMessageTextParts(item));
       continue;
     }
     if (isFunctionToolCall(item)) {
@@ -293,12 +291,16 @@ function mapMessageTextParts(message) {
   );
 }
 function getTextContent(parts) {
-  const text = parts.flatMap((part) => part.type === "text" ? [part.text] : []).join("");
-  return text.length > 0 ? text : null;
+  return getJoinedPartText(parts, "text");
 }
 function getReasoningText(parts) {
-  const reasoning = parts.flatMap((part) => part.type === "reasoning" ? [part.text] : []).join("");
-  return reasoning.length > 0 ? reasoning : null;
+  return getJoinedPartText(parts, "reasoning");
+}
+function getJoinedPartText(parts, type) {
+  const text = parts.flatMap(
+    (part) => part.type === type && "text" in part ? [part.text] : []
+  ).join("");
+  return text.length > 0 ? text : null;
 }
 function getToolCalls(parts) {
   return parts.flatMap(
@@ -335,6 +337,33 @@ function mapUsage(usage) {
     }
   };
 }
+function getReasoningStartTransition(reasoningStarted) {
+  if (reasoningStarted) {
+    return {
+      nextReasoningStarted: true,
+      event: null
+    };
+  }
+  return {
+    nextReasoningStarted: true,
+    event: { type: "reasoning-start" }
+  };
+}
+function getReasoningEndTransition(reasoningStarted, providerMetadata) {
+  if (!reasoningStarted) {
+    return {
+      nextReasoningStarted: false,
+      event: null
+    };
+  }
+  return {
+    nextReasoningStarted: false,
+    event: {
+      type: "reasoning-end",
+      providerMetadata
+    }
+  };
+}
 async function* transformStream(stream) {
   const bufferedToolCalls = /* @__PURE__ */ new Map();
   const emittedToolCalls = /* @__PURE__ */ new Set();
@@ -343,13 +372,19 @@ async function* transformStream(stream) {
   const emittedReasoningItems = /* @__PURE__ */ new Set();
   let latestResponse;
   let reasoningStarted = false;
+  const upsertBufferedToolCall = (outputIndex, getNextToolCall) => {
+    const nextToolCall = getNextToolCall(bufferedToolCalls.get(outputIndex));
+    bufferedToolCalls.set(outputIndex, nextToolCall);
+    return nextToolCall;
+  };
   for await (const event of stream) {
     if (event.type === "response.reasoning_summary_text.delta") {
       seenSummaryDeltas.add(`${event.item_id}:${event.summary_index}`);
       emittedReasoningItems.add(event.item_id);
-      if (!reasoningStarted) {
-        reasoningStarted = true;
-        yield { type: "reasoning-start" };
+      const reasoningStartTransition = getReasoningStartTransition(reasoningStarted);
+      reasoningStarted = reasoningStartTransition.nextReasoningStarted;
+      if (reasoningStartTransition.event) {
+        yield reasoningStartTransition.event;
       }
       yield {
         type: "reasoning-delta",
@@ -361,9 +396,10 @@ async function* transformStream(stream) {
       const key = `${event.item_id}:${event.summary_index}`;
       if (!seenSummaryDeltas.has(key) && event.text.length > 0) {
         emittedReasoningItems.add(event.item_id);
-        if (!reasoningStarted) {
-          reasoningStarted = true;
-          yield { type: "reasoning-start" };
+        const reasoningStartTransition = getReasoningStartTransition(reasoningStarted);
+        reasoningStarted = reasoningStartTransition.nextReasoningStarted;
+        if (reasoningStartTransition.event) {
+          yield reasoningStartTransition.event;
         }
         yield {
           type: "reasoning-delta",
@@ -384,32 +420,38 @@ async function* transformStream(stream) {
         continue;
       }
       const toolCallId = event.item.call_id;
-      bufferedToolCalls.set(event.output_index, {
-        id: toolCallId,
-        name: event.item.name,
-        arguments: event.item.arguments
-      });
-      if (!startedToolCalls.has(toolCallId)) {
+      const toolCallName = event.item.name;
+      const toolCallArguments = event.item.arguments;
+      upsertBufferedToolCall(
+        event.output_index,
+        () => ({
+          id: toolCallId,
+          name: toolCallName,
+          arguments: toolCallArguments
+        })
+      );
+      const shouldStartToolCall = !startedToolCalls.has(toolCallId);
+      if (shouldStartToolCall) {
         startedToolCalls.add(toolCallId);
         yield {
           type: "tool-call-start",
           toolCallId,
-          toolName: event.item.name
+          toolName: toolCallName
         };
       }
       continue;
     }
     if (event.type === "response.function_call_arguments.delta") {
-      const currentToolCall = bufferedToolCalls.get(
-        event.output_index
-      ) ?? {
-        id: event.item_id,
-        name: "",
-        arguments: ""
-      };
-      currentToolCall.arguments += event.delta;
-      bufferedToolCalls.set(event.output_index, currentToolCall);
-      if (!startedToolCalls.has(currentToolCall.id)) {
+      const currentToolCall = upsertBufferedToolCall(
+        event.output_index,
+        (bufferedToolCall) => ({
+          id: bufferedToolCall?.id ?? event.item_id,
+          name: bufferedToolCall?.name ?? "",
+          arguments: `${bufferedToolCall?.arguments ?? ""}${event.delta}`
+        })
+      );
+      const shouldStartToolCall = !startedToolCalls.has(currentToolCall.id);
+      if (shouldStartToolCall) {
         startedToolCalls.add(currentToolCall.id);
         yield {
           type: "tool-call-start",
@@ -431,9 +473,10 @@ async function* transformStream(stream) {
             event.item.summary
           );
           if (summaryText.length > 0) {
-            if (!reasoningStarted) {
-              reasoningStarted = true;
-              yield { type: "reasoning-start" };
+            const reasoningStartTransition = getReasoningStartTransition(reasoningStarted);
+            reasoningStarted = reasoningStartTransition.nextReasoningStarted;
+            if (reasoningStartTransition.event) {
+              yield reasoningStartTransition.event;
             }
             yield {
               type: "reasoning-delta",
@@ -442,36 +485,41 @@ async function* transformStream(stream) {
           }
         }
         const encryptedContent = typeof event.item.encrypted_content === "string" && event.item.encrypted_content.length > 0 ? event.item.encrypted_content : void 0;
-        if (!reasoningStarted && encryptedContent) {
-          reasoningStarted = true;
-          yield { type: "reasoning-start" };
+        if (encryptedContent) {
+          const reasoningStartTransition = getReasoningStartTransition(reasoningStarted);
+          reasoningStarted = reasoningStartTransition.nextReasoningStarted;
+          if (reasoningStartTransition.event) {
+            yield reasoningStartTransition.event;
+          }
         }
-        if (reasoningStarted) {
-          reasoningStarted = false;
-          yield {
-            type: "reasoning-end",
-            providerMetadata: {
-              openai: {
-                ...encryptedContent ? { encryptedContent } : {}
-              }
+        const reasoningEndTransition2 = getReasoningEndTransition(
+          reasoningStarted,
+          {
+            openai: {
+              ...encryptedContent ? { encryptedContent } : {}
             }
-          };
+          }
+        );
+        reasoningStarted = reasoningEndTransition2.nextReasoningStarted;
+        if (reasoningEndTransition2.event) {
+          yield reasoningEndTransition2.event;
         }
         continue;
       }
       if (!isFunctionToolCall(event.item)) {
         continue;
       }
-      const currentToolCall = bufferedToolCalls.get(
-        event.output_index
-      ) ?? {
-        id: event.item.call_id,
-        name: event.item.name,
-        arguments: ""
-      };
-      currentToolCall.id = event.item.call_id;
-      currentToolCall.name = event.item.name;
-      currentToolCall.arguments = event.item.arguments || currentToolCall.arguments;
+      const toolCallId = event.item.call_id;
+      const toolCallName = event.item.name;
+      const toolCallArguments = event.item.arguments;
+      const currentToolCall = upsertBufferedToolCall(
+        event.output_index,
+        (bufferedToolCall) => ({
+          id: toolCallId,
+          name: toolCallName,
+          arguments: toolCallArguments || bufferedToolCall?.arguments || ""
+        })
+      );
       if (!emittedToolCalls.has(currentToolCall.id)) {
         emittedToolCalls.add(currentToolCall.id);
         yield {
@@ -489,12 +537,13 @@ async function* transformStream(stream) {
     }
     if (event.type === "response.completed") {
       latestResponse = event.response;
-      if (reasoningStarted) {
-        reasoningStarted = false;
-        yield {
-          type: "reasoning-end",
-          providerMetadata: { openai: {} }
-        };
+      const reasoningEndTransition2 = getReasoningEndTransition(
+        reasoningStarted,
+        { openai: {} }
+      );
+      reasoningStarted = reasoningEndTransition2.nextReasoningStarted;
+      if (reasoningEndTransition2.event) {
+        yield reasoningEndTransition2.event;
       }
       for (const bufferedToolCall of bufferedToolCalls.values()) {
         if (emittedToolCalls.has(bufferedToolCall.id)) {
@@ -521,8 +570,12 @@ async function* transformStream(stream) {
       return;
     }
   }
-  if (reasoningStarted) {
-    yield { type: "reasoning-end", providerMetadata: { openai: {} } };
+  const reasoningEndTransition = getReasoningEndTransition(reasoningStarted, {
+    openai: {}
+  });
+  reasoningStarted = reasoningEndTransition.nextReasoningStarted;
+  if (reasoningEndTransition.event) {
+    yield reasoningEndTransition.event;
   }
   const hasToolCalls = bufferedToolCalls.size > 0;
   const usage = latestResponse ? mapUsage(latestResponse.usage) : mapUsage(void 0);

package/dist/provider-options-l7CmAA94.d.ts

@@ -0,0 +1,120 @@
+import { z } from 'zod';
+
+declare const openaiResponsesGenerateProviderOptionsSchema: z.ZodObject<{
+    store: z.ZodOptional<z.ZodBoolean>;
+    serviceTier: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        default: "default";
+        flex: "flex";
+        scale: "scale";
+        priority: "priority";
+    }>>;
+    include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    parallelToolCalls: z.ZodOptional<z.ZodBoolean>;
+    user: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type OpenAIResponsesGenerateProviderOptions = z.infer<typeof openaiResponsesGenerateProviderOptionsSchema>;
+declare const openaiCompatGenerateProviderOptionsSchema: z.ZodObject<{
+    store: z.ZodOptional<z.ZodBoolean>;
+    serviceTier: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        default: "default";
+        flex: "flex";
+        scale: "scale";
+        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 OpenAICompatGenerateProviderOptions = z.infer<typeof openaiCompatGenerateProviderOptionsSchema>;
+declare const openaiEmbedProviderOptionsSchema: z.ZodObject<{
+    encodingFormat: z.ZodOptional<z.ZodEnum<{
+        float: "float";
+        base64: "base64";
+    }>>;
+    user: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type OpenAIEmbedProviderOptions = z.infer<typeof openaiEmbedProviderOptionsSchema>;
+declare const openaiImageProviderOptionsSchema: z.ZodObject<{
+    background: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        transparent: "transparent";
+        opaque: "opaque";
+    }>>;
+    moderation: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        auto: "auto";
+    }>>;
+    outputCompression: z.ZodOptional<z.ZodNumber>;
+    outputFormat: z.ZodOptional<z.ZodEnum<{
+        png: "png";
+        jpeg: "jpeg";
+        webp: "webp";
+    }>>;
+    quality: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        auto: "auto";
+        standard: "standard";
+        hd: "hd";
+    }>>;
+    responseFormat: z.ZodOptional<z.ZodEnum<{
+        url: "url";
+        b64_json: "b64_json";
+    }>>;
+    style: z.ZodOptional<z.ZodEnum<{
+        vivid: "vivid";
+        natural: "natural";
+    }>>;
+    user: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type OpenAIImageProviderOptions = z.infer<typeof openaiImageProviderOptionsSchema>;
+declare module '@core-ai/core-ai' {
+    interface GenerateProviderOptions {
+        openai?: OpenAIResponsesGenerateProviderOptions | OpenAICompatGenerateProviderOptions;
+    }
+    interface EmbedProviderOptions {
+        openai?: OpenAIEmbedProviderOptions;
+    }
+    interface ImageProviderOptions {
+        openai?: OpenAIImageProviderOptions;
+    }
+}
+declare const openaiResponsesProviderOptionsSchema: z.ZodObject<{
+    store: z.ZodOptional<z.ZodBoolean>;
+    serviceTier: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        default: "default";
+        flex: "flex";
+        scale: "scale";
+        priority: "priority";
+    }>>;
+    include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    parallelToolCalls: z.ZodOptional<z.ZodBoolean>;
+    user: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type OpenAIResponsesProviderOptions = OpenAIResponsesGenerateProviderOptions;
+declare const openaiCompatProviderOptionsSchema: z.ZodObject<{
+    store: z.ZodOptional<z.ZodBoolean>;
+    serviceTier: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        default: "default";
+        flex: "flex";
+        scale: "scale";
+        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 OpenAICompatRequestOptions = OpenAICompatGenerateProviderOptions;
+
+export { type OpenAICompatGenerateProviderOptions as O, type OpenAICompatRequestOptions as a, openaiCompatProviderOptionsSchema as b, type OpenAIEmbedProviderOptions as c, type OpenAIImageProviderOptions as d, type OpenAIResponsesGenerateProviderOptions as e, type OpenAIResponsesProviderOptions as f, openaiEmbedProviderOptionsSchema as g, openaiImageProviderOptionsSchema as h, openaiResponsesGenerateProviderOptionsSchema as i, openaiResponsesProviderOptionsSchema as j, openaiCompatGenerateProviderOptionsSchema as o };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/openai",
-    "version": "0.6.0",
+    "version": "0.7.0",
     "description": "OpenAI provider package for @core-ai/core-ai",
     "license": "MIT",
     "author": "Omnifact (https://omnifact.ai)",
@@ -46,12 +46,11 @@
         "test:watch": "vitest"
     },
     "dependencies": {
-        "@core-ai/core-ai": "^0.6.0",
-        "openai": "^6.1.0",
-        "zod-to-json-schema": "^3.25.1"
+        "@core-ai/core-ai": "^0.7.0",
+        "openai": "^6.1.0"
     },
     "peerDependencies": {
-        "zod": "^3.25.0 || ^4.0.0"
+        "zod": "^4.0.0"
     },
     "devDependencies": {
         "@core-ai/eslint-config": "*",

package/dist/provider-options-DK-Tz0pz.d.ts

@@ -1,157 +0,0 @@
-import { z } from 'zod';
-
-declare const openaiResponsesGenerateProviderOptionsSchema: z.ZodObject<{
-    store: z.ZodOptional<z.ZodBoolean>;
-    serviceTier: z.ZodOptional<z.ZodEnum<["auto", "default", "flex", "scale", "priority"]>>;
-    include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    parallelToolCalls: z.ZodOptional<z.ZodBoolean>;
-    user: z.ZodOptional<z.ZodString>;
-}, "strict", z.ZodTypeAny, {
-    store?: boolean | undefined;
-    serviceTier?: "auto" | "default" | "flex" | "scale" | "priority" | undefined;
-    include?: string[] | undefined;
-    parallelToolCalls?: boolean | undefined;
-    user?: string | undefined;
-}, {
-    store?: boolean | undefined;
-    serviceTier?: "auto" | "default" | "flex" | "scale" | "priority" | undefined;
-    include?: string[] | undefined;
-    parallelToolCalls?: boolean | undefined;
-    user?: string | undefined;
-}>;
-type OpenAIResponsesGenerateProviderOptions = z.infer<typeof openaiResponsesGenerateProviderOptionsSchema>;
-declare const openaiCompatGenerateProviderOptionsSchema: z.ZodObject<Omit<{
-    store: z.ZodOptional<z.ZodBoolean>;
-    serviceTier: z.ZodOptional<z.ZodEnum<["auto", "default", "flex", "scale", "priority"]>>;
-    include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    parallelToolCalls: z.ZodOptional<z.ZodBoolean>;
-    user: z.ZodOptional<z.ZodString>;
-}, "include"> & {
-    stopSequences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    frequencyPenalty: z.ZodOptional<z.ZodNumber>;
-    presencePenalty: z.ZodOptional<z.ZodNumber>;
-    seed: z.ZodOptional<z.ZodNumber>;
-}, "strict", z.ZodTypeAny, {
-    store?: boolean | undefined;
-    serviceTier?: "auto" | "default" | "flex" | "scale" | "priority" | undefined;
-    parallelToolCalls?: boolean | undefined;
-    user?: string | undefined;
-    stopSequences?: string[] | undefined;
-    frequencyPenalty?: number | undefined;
-    presencePenalty?: number | undefined;
-    seed?: number | undefined;
-}, {
-    store?: boolean | undefined;
-    serviceTier?: "auto" | "default" | "flex" | "scale" | "priority" | undefined;
-    parallelToolCalls?: boolean | undefined;
-    user?: string | undefined;
-    stopSequences?: string[] | undefined;
-    frequencyPenalty?: number | undefined;
-    presencePenalty?: number | undefined;
-    seed?: number | undefined;
-}>;
-type OpenAICompatGenerateProviderOptions = z.infer<typeof openaiCompatGenerateProviderOptionsSchema>;
-declare const openaiEmbedProviderOptionsSchema: z.ZodObject<{
-    encodingFormat: z.ZodOptional<z.ZodEnum<["float", "base64"]>>;
-    user: z.ZodOptional<z.ZodString>;
-}, "strict", z.ZodTypeAny, {
-    user?: string | undefined;
-    encodingFormat?: "float" | "base64" | undefined;
-}, {
-    user?: string | undefined;
-    encodingFormat?: "float" | "base64" | undefined;
-}>;
-type OpenAIEmbedProviderOptions = z.infer<typeof openaiEmbedProviderOptionsSchema>;
-declare const openaiImageProviderOptionsSchema: z.ZodObject<{
-    background: z.ZodOptional<z.ZodEnum<["transparent", "opaque", "auto"]>>;
-    moderation: z.ZodOptional<z.ZodEnum<["low", "auto"]>>;
-    outputCompression: z.ZodOptional<z.ZodNumber>;
-    outputFormat: z.ZodOptional<z.ZodEnum<["png", "jpeg", "webp"]>>;
-    quality: z.ZodOptional<z.ZodEnum<["standard", "hd", "low", "medium", "high", "auto"]>>;
-    responseFormat: z.ZodOptional<z.ZodEnum<["url", "b64_json"]>>;
-    style: z.ZodOptional<z.ZodEnum<["vivid", "natural"]>>;
-    user: z.ZodOptional<z.ZodString>;
-}, "strict", z.ZodTypeAny, {
-    user?: string | undefined;
-    background?: "auto" | "transparent" | "opaque" | undefined;
-    moderation?: "low" | "auto" | undefined;
-    outputCompression?: number | undefined;
-    outputFormat?: "png" | "jpeg" | "webp" | undefined;
-    quality?: "low" | "medium" | "high" | "auto" | "standard" | "hd" | undefined;
-    responseFormat?: "url" | "b64_json" | undefined;
-    style?: "vivid" | "natural" | undefined;
-}, {
-    user?: string | undefined;
-    background?: "auto" | "transparent" | "opaque" | undefined;
-    moderation?: "low" | "auto" | undefined;
-    outputCompression?: number | undefined;
-    outputFormat?: "png" | "jpeg" | "webp" | undefined;
-    quality?: "low" | "medium" | "high" | "auto" | "standard" | "hd" | undefined;
-    responseFormat?: "url" | "b64_json" | undefined;
-    style?: "vivid" | "natural" | undefined;
-}>;
-type OpenAIImageProviderOptions = z.infer<typeof openaiImageProviderOptionsSchema>;
-declare module '@core-ai/core-ai' {
-    interface GenerateProviderOptions {
-        openai?: OpenAIResponsesGenerateProviderOptions | OpenAICompatGenerateProviderOptions;
-    }
-    interface EmbedProviderOptions {
-        openai?: OpenAIEmbedProviderOptions;
-    }
-    interface ImageProviderOptions {
-        openai?: OpenAIImageProviderOptions;
-    }
-}
-declare const openaiResponsesProviderOptionsSchema: z.ZodObject<{
-    store: z.ZodOptional<z.ZodBoolean>;
-    serviceTier: z.ZodOptional<z.ZodEnum<["auto", "default", "flex", "scale", "priority"]>>;
-    include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    parallelToolCalls: z.ZodOptional<z.ZodBoolean>;
-    user: z.ZodOptional<z.ZodString>;
-}, "strict", z.ZodTypeAny, {
-    store?: boolean | undefined;
-    serviceTier?: "auto" | "default" | "flex" | "scale" | "priority" | undefined;
-    include?: string[] | undefined;
-    parallelToolCalls?: boolean | undefined;
-    user?: string | undefined;
-}, {
-    store?: boolean | undefined;
-    serviceTier?: "auto" | "default" | "flex" | "scale" | "priority" | undefined;
-    include?: string[] | undefined;
-    parallelToolCalls?: boolean | undefined;
-    user?: string | undefined;
-}>;
-type OpenAIResponsesProviderOptions = OpenAIResponsesGenerateProviderOptions;
-declare const openaiCompatProviderOptionsSchema: z.ZodObject<Omit<{
-    store: z.ZodOptional<z.ZodBoolean>;
-    serviceTier: z.ZodOptional<z.ZodEnum<["auto", "default", "flex", "scale", "priority"]>>;
-    include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    parallelToolCalls: z.ZodOptional<z.ZodBoolean>;
-    user: z.ZodOptional<z.ZodString>;
-}, "include"> & {
-    stopSequences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    frequencyPenalty: z.ZodOptional<z.ZodNumber>;
-    presencePenalty: z.ZodOptional<z.ZodNumber>;
-    seed: z.ZodOptional<z.ZodNumber>;
-}, "strict", z.ZodTypeAny, {
-    store?: boolean | undefined;
-    serviceTier?: "auto" | "default" | "flex" | "scale" | "priority" | undefined;
-    parallelToolCalls?: boolean | undefined;
-    user?: string | undefined;
-    stopSequences?: string[] | undefined;
-    frequencyPenalty?: number | undefined;
-    presencePenalty?: number | undefined;
-    seed?: number | undefined;
-}, {
-    store?: boolean | undefined;
-    serviceTier?: "auto" | "default" | "flex" | "scale" | "priority" | undefined;
-    parallelToolCalls?: boolean | undefined;
-    user?: string | undefined;
-    stopSequences?: string[] | undefined;
-    frequencyPenalty?: number | undefined;
-    presencePenalty?: number | undefined;
-    seed?: number | undefined;
-}>;
-type OpenAICompatRequestOptions = OpenAICompatGenerateProviderOptions;
-
-export { type OpenAICompatGenerateProviderOptions as O, type OpenAICompatRequestOptions as a, openaiCompatProviderOptionsSchema as b, type OpenAIEmbedProviderOptions as c, type OpenAIImageProviderOptions as d, type OpenAIResponsesGenerateProviderOptions as e, type OpenAIResponsesProviderOptions as f, openaiEmbedProviderOptionsSchema as g, openaiImageProviderOptionsSchema as h, openaiResponsesGenerateProviderOptionsSchema as i, openaiResponsesProviderOptionsSchema as j, openaiCompatGenerateProviderOptionsSchema as o };