@core-ai/openai 0.14.0 → 0.16.0

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

@@ -1,7 +1,32 @@
 import OpenAI from 'openai';
-import { ChatModel, EmbeddingModel, ImageModel } from '@core-ai/core-ai';
+import { ModelCapabilities, ChatModel, EmbeddingModel, ImageModel } from '@core-ai/core-ai';
 import { z } from 'zod';
 
+type OpenAIChatCompletionsCapabilities = {
+    maxTokensParameter: 'max_tokens' | 'max_completion_tokens';
+};
+type OpenAIModelCapabilities = ModelCapabilities & {
+    chatCompletions: OpenAIChatCompletionsCapabilities;
+};
+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 OpenAIProviderBaseOptions = {
     apiKey?: string;
     baseURL?: string;
@@ -9,9 +34,25 @@ type OpenAIProviderBaseOptions = {
 };
 type OpenAIProvider = {
     chatModel(modelId: string): ChatModel;
+    chat: OpenAIChatProvider;
     embeddingModel(modelId: string): EmbeddingModel;
     imageModel(modelId: string): ImageModel;
 };
+type OpenAIChatProvider = {
+    chatModel(modelId: string): ChatModel;
+};
+type OpenAICompatibilityOptions = {
+    reasoning?: boolean;
+    structuredOutputMode?: OpenAIChatCompletionsModelOptions['structuredOutputMode'];
+    maxTokensParameter?: OpenAIChatCompletionsModelOptions['maxTokensParameter'];
+};
+type OpenAICompatibility = boolean | OpenAICompatibilityOptions;
+type OpenAIProviderFactoryOptions = {
+    providerId?: string;
+    defaultApi?: 'responses' | 'chat-completions';
+    compatibility?: OpenAICompatibility;
+};
+declare function createOpenAIProvider(options: OpenAIProviderBaseOptions, factoryOptions?: OpenAIProviderFactoryOptions): OpenAIProvider;
 
 declare const openaiResponsesGenerateProviderOptionsSchema: z.ZodObject<{
     store: z.ZodOptional<z.ZodBoolean>;
@@ -27,7 +68,7 @@ declare const openaiResponsesGenerateProviderOptionsSchema: z.ZodObject<{
     user: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 type OpenAIResponsesGenerateProviderOptions = z.infer<typeof openaiResponsesGenerateProviderOptionsSchema>;
-declare const openaiCompatGenerateProviderOptionsSchema: z.ZodObject<{
+declare const openaiChatGenerateProviderOptionsSchema: z.ZodObject<{
     store: z.ZodOptional<z.ZodBoolean>;
     serviceTier: z.ZodOptional<z.ZodEnum<{
         auto: "auto";
@@ -43,7 +84,7 @@ declare const openaiCompatGenerateProviderOptionsSchema: z.ZodObject<{
     presencePenalty: z.ZodOptional<z.ZodNumber>;
     seed: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
-type OpenAICompatGenerateProviderOptions = z.infer<typeof openaiCompatGenerateProviderOptionsSchema>;
+type OpenAIChatGenerateProviderOptions = z.infer<typeof openaiChatGenerateProviderOptionsSchema>;
 declare const openaiEmbedProviderOptionsSchema: z.ZodObject<{
     encodingFormat: z.ZodOptional<z.ZodEnum<{
         float: "float";
@@ -89,7 +130,7 @@ declare const openaiImageProviderOptionsSchema: z.ZodObject<{
 type OpenAIImageProviderOptions = z.infer<typeof openaiImageProviderOptionsSchema>;
 declare module '@core-ai/core-ai' {
     interface GenerateProviderOptions {
-        openai?: OpenAIResponsesGenerateProviderOptions | OpenAICompatGenerateProviderOptions;
+        openai?: OpenAIResponsesGenerateProviderOptions | OpenAIChatGenerateProviderOptions;
     }
     interface EmbedProviderOptions {
         openai?: OpenAIEmbedProviderOptions;
@@ -128,6 +169,23 @@ declare const openaiCompatProviderOptionsSchema: z.ZodObject<{
     presencePenalty: z.ZodOptional<z.ZodNumber>;
     seed: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
-type OpenAICompatRequestOptions = OpenAICompatGenerateProviderOptions;
+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 = OpenAIChatGenerateProviderOptions;
+type OpenAICompatRequestOptions = OpenAIChatGenerateProviderOptions;
 
-export { type OpenAIProvider as O, type OpenAIProviderBaseOptions as a, type OpenAICompatGenerateProviderOptions as b, type OpenAICompatRequestOptions as c, openaiCompatProviderOptionsSchema as d, type OpenAIEmbedProviderOptions as e, type OpenAIImageProviderOptions as f, type OpenAIResponsesGenerateProviderOptions as g, type OpenAIResponsesProviderOptions as h, openaiEmbedProviderOptionsSchema as i, openaiImageProviderOptionsSchema as j, openaiResponsesGenerateProviderOptionsSchema as k, openaiResponsesProviderOptionsSchema as l, openaiCompatGenerateProviderOptionsSchema as o };
+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.14.0",
+    "version": "0.16.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.14.0",
+        "@core-ai/core-ai": "^0.16.0",
         "openai": "^6.46.0"
     },
     "peerDependencies": {

package/dist/chunk-7MAEB5C7.js

@@ -1,568 +0,0 @@
-// src/model-capabilities.ts
-import {
-  stripModelDateSuffix
-} from "@core-ai/core-ai";
-var STANDARD_EFFORTS = [
-  "low",
-  "medium",
-  "high"
-];
-var MAX_EFFORTS = [
-  "low",
-  "medium",
-  "high",
-  "max"
-];
-var MINIMAL_EFFORTS = [
-  "minimal",
-  "low",
-  "medium",
-  "high"
-];
-var PRO_EFFORTS = [
-  "medium",
-  "high",
-  "max"
-];
-var HIGH_EFFORT = ["high"];
-function createCapabilities(supportedEfforts, restrictsSamplingParams) {
-  return {
-    reasoning: {
-      supported: true,
-      supportedEfforts,
-      restrictsSamplingParams
-    }
-  };
-}
-var DEFAULT_CAPABILITIES = createCapabilities(STANDARD_EFFORTS, false);
-var SAMPLING_RESTRICTED_STANDARD_CAPABILITIES = createCapabilities(
-  STANDARD_EFFORTS,
-  true
-);
-var GPT_5_MAX_REASONING_CAPABILITIES = createCapabilities(MAX_EFFORTS, true);
-var GPT_5_MINIMAL_REASONING_CAPABILITIES = createCapabilities(
-  MINIMAL_EFFORTS,
-  true
-);
-var GPT_5_PRO_REASONING_CAPABILITIES = createCapabilities(PRO_EFFORTS, true);
-var GPT_5_HIGH_REASONING_CAPABILITIES = createCapabilities(HIGH_EFFORT, true);
-var NO_REASONING_EFFORT_CAPABILITIES = {
-  reasoning: {
-    supported: false,
-    supportedEfforts: [],
-    restrictsSamplingParams: false
-  }
-};
-var O_SERIES_MAX_REASONING_CAPABILITIES = createCapabilities(
-  MAX_EFFORTS,
-  false
-);
-var 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,
-  "gpt-5.5": GPT_5_MAX_REASONING_CAPABILITIES,
-  "gpt-5.5-pro": GPT_5_PRO_REASONING_CAPABILITIES,
-  "gpt-5.4": GPT_5_MAX_REASONING_CAPABILITIES,
-  "gpt-5.4-pro": GPT_5_PRO_REASONING_CAPABILITIES,
-  "gpt-5.4-mini": GPT_5_MAX_REASONING_CAPABILITIES,
-  "gpt-5.4-nano": GPT_5_MAX_REASONING_CAPABILITIES,
-  "gpt-5.3-codex": GPT_5_MAX_REASONING_CAPABILITIES,
-  "gpt-5.2": GPT_5_MAX_REASONING_CAPABILITIES,
-  "gpt-5.2-codex": GPT_5_MAX_REASONING_CAPABILITIES,
-  "gpt-5.2-pro": GPT_5_MAX_REASONING_CAPABILITIES,
-  "gpt-5.1-codex": GPT_5_MAX_REASONING_CAPABILITIES,
-  "gpt-5.1-codex-max": GPT_5_MAX_REASONING_CAPABILITIES,
-  "gpt-5.1-codex-mini": GPT_5_MAX_REASONING_CAPABILITIES,
-  "gpt-5.1": SAMPLING_RESTRICTED_STANDARD_CAPABILITIES,
-  "gpt-5": GPT_5_MINIMAL_REASONING_CAPABILITIES,
-  "gpt-5-mini": GPT_5_MINIMAL_REASONING_CAPABILITIES,
-  "gpt-5-nano": GPT_5_MINIMAL_REASONING_CAPABILITIES,
-  "gpt-5-pro": GPT_5_HIGH_REASONING_CAPABILITIES,
-  "gpt-5-codex": GPT_5_MAX_REASONING_CAPABILITIES,
-  "o3-pro": O_SERIES_MAX_REASONING_CAPABILITIES,
-  o3: DEFAULT_CAPABILITIES,
-  "o3-mini": DEFAULT_CAPABILITIES,
-  "o4-mini": DEFAULT_CAPABILITIES,
-  o1: DEFAULT_CAPABILITIES,
-  "o1-mini": NO_REASONING_EFFORT_CAPABILITIES
-};
-var OPENAI_REASONING_EFFORT_MAP = {
-  minimal: "minimal",
-  low: "low",
-  medium: "medium",
-  high: "high",
-  max: "xhigh"
-};
-function getOpenAIModelCapabilities(modelId) {
-  const normalizedModelId = normalizeModelId(modelId);
-  return MODEL_CAPABILITIES[normalizedModelId] ?? DEFAULT_CAPABILITIES;
-}
-function normalizeModelId(modelId) {
-  return stripModelDateSuffix(modelId);
-}
-function toOpenAIReasoningEffort(effort) {
-  return OPENAI_REASONING_EFFORT_MAP[effort];
-}
-
-// src/provider-options.ts
-import { z } from "zod";
-var openaiResponsesGenerateProviderOptionsSchema = z.object({
-  store: z.boolean().optional(),
-  serviceTier: z.enum(["auto", "default", "flex", "scale", "priority"]).optional(),
-  include: z.array(z.string()).optional(),
-  parallelToolCalls: z.boolean().optional(),
-  user: z.string().optional()
-}).strict();
-var openaiCompatGenerateProviderOptionsSchema = openaiResponsesGenerateProviderOptionsSchema.omit({
-  include: true
-}).extend({
-  stopSequences: z.array(z.string()).optional(),
-  frequencyPenalty: z.number().optional(),
-  presencePenalty: z.number().optional(),
-  seed: z.number().int().optional()
-}).strict();
-var openaiEmbedProviderOptionsSchema = z.object({
-  encodingFormat: z.enum(["float", "base64"]).optional(),
-  user: z.string().optional()
-}).strict();
-var openaiImageProviderOptionsSchema = z.object({
-  background: z.enum(["transparent", "opaque", "auto"]).optional(),
-  moderation: z.enum(["low", "auto"]).optional(),
-  outputCompression: z.number().int().min(0).max(100).optional(),
-  outputFormat: z.enum(["png", "jpeg", "webp"]).optional(),
-  quality: z.enum(["standard", "hd", "low", "medium", "high", "auto"]).optional(),
-  responseFormat: z.enum(["url", "b64_json"]).optional(),
-  style: z.enum(["vivid", "natural"]).optional(),
-  user: z.string().optional()
-}).strict();
-function parseOpenAIProviderOptions(providerOptions, schema) {
-  const rawOptions = providerOptions?.openai;
-  if (rawOptions === void 0) {
-    return void 0;
-  }
-  return schema.parse(rawOptions);
-}
-function parseOpenAIResponsesGenerateProviderOptions(providerOptions) {
-  return parseOpenAIProviderOptions(
-    providerOptions,
-    openaiResponsesGenerateProviderOptionsSchema
-  );
-}
-function parseOpenAICompatGenerateProviderOptions(providerOptions) {
-  return parseOpenAIProviderOptions(
-    providerOptions,
-    openaiCompatGenerateProviderOptionsSchema
-  );
-}
-function parseOpenAIEmbedProviderOptions(providerOptions) {
-  return parseOpenAIProviderOptions(
-    providerOptions,
-    openaiEmbedProviderOptionsSchema
-  );
-}
-function parseOpenAIImageProviderOptions(providerOptions) {
-  return parseOpenAIProviderOptions(
-    providerOptions,
-    openaiImageProviderOptionsSchema
-  );
-}
-var openaiResponsesProviderOptionsSchema = openaiResponsesGenerateProviderOptionsSchema;
-var openaiCompatProviderOptionsSchema = openaiCompatGenerateProviderOptionsSchema;
-
-// src/shared/tools.ts
-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) {
-  return Object.values(tools).map((tool) => ({
-    type: "function",
-    function: {
-      name: tool.name,
-      description: tool.description,
-      parameters: zodSchemaToJsonSchema(tool.parameters)
-    }
-  }));
-}
-function convertToolChoice(choice) {
-  if (typeof choice === "string") {
-    return choice;
-  }
-  return {
-    type: "function",
-    function: {
-      name: choice.toolName
-    }
-  };
-}
-function getStructuredOutputToolName(options) {
-  return options.schemaName?.trim() || DEFAULT_STRUCTURED_OUTPUT_TOOL_NAME;
-}
-function createStructuredOutputOptions(options) {
-  const toolName = getStructuredOutputToolName(options);
-  return {
-    messages: options.messages,
-    tools: {
-      structured_output: {
-        name: toolName,
-        description: options.schemaDescription ?? DEFAULT_STRUCTURED_OUTPUT_TOOL_DESCRIPTION,
-        parameters: options.schema
-      }
-    },
-    toolChoice: {
-      type: "tool",
-      toolName
-    },
-    reasoning: options.reasoning,
-    temperature: options.temperature,
-    maxTokens: options.maxTokens,
-    topP: options.topP,
-    providerOptions: options.providerOptions,
-    signal: options.signal
-  };
-}
-
-// 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";
-}
-function wrapOpenAIError(error, provider = "openai") {
-  if (isOpenAIAbortError(error)) {
-    return new AbortedError(error, provider);
-  }
-  if (error instanceof APIError) {
-    return new ProviderError(
-      error.message,
-      provider,
-      error.status,
-      error
-    );
-  }
-  return new ProviderError(
-    error instanceof Error ? error.message : String(error),
-    provider,
-    void 0,
-    error
-  );
-}
-
-// src/shared/structured-output.ts
-import {
-  StructuredOutputNoObjectGeneratedError,
-  StructuredOutputParseError,
-  StructuredOutputValidationError
-} from "@core-ai/core-ai";
-function extractStructuredObject(result, schema, provider, toolName) {
-  const structuredToolCall = result.toolCalls.find(
-    (toolCall) => toolCall.name === toolName
-  );
-  if (structuredToolCall) {
-    return validateStructuredToolArguments(
-      schema,
-      structuredToolCall.arguments,
-      provider
-    );
-  }
-  const rawOutput = result.content?.trim();
-  if (rawOutput && rawOutput.length > 0) {
-    return parseAndValidateStructuredPayload(schema, rawOutput, provider);
-  }
-  throw new StructuredOutputNoObjectGeneratedError(
-    "model did not emit a structured object payload",
-    provider
-  );
-}
-async function* transformStructuredOutputStream(stream, schema, provider, toolName) {
-  let validatedObject;
-  let contentBuffer = "";
-  const toolArgumentDeltas = /* @__PURE__ */ new Map();
-  for await (const event of stream) {
-    if (event.type === "text-delta") {
-      contentBuffer += event.text;
-      yield {
-        type: "object-delta",
-        text: event.text
-      };
-      continue;
-    }
-    if (event.type === "tool-call-delta") {
-      const previous = toolArgumentDeltas.get(event.toolCallId) ?? "";
-      toolArgumentDeltas.set(
-        event.toolCallId,
-        `${previous}${event.argumentsDelta}`
-      );
-      yield {
-        type: "object-delta",
-        text: event.argumentsDelta
-      };
-      continue;
-    }
-    if (event.type === "tool-call-end" && event.toolCall.name === toolName) {
-      validatedObject = validateStructuredToolArguments(
-        schema,
-        event.toolCall.arguments,
-        provider
-      );
-      yield {
-        type: "object",
-        object: validatedObject
-      };
-      continue;
-    }
-    if (event.type === "finish") {
-      if (validatedObject === void 0) {
-        const fallbackPayload = getFallbackStructuredPayload(
-          contentBuffer,
-          toolArgumentDeltas
-        );
-        if (!fallbackPayload) {
-          throw new StructuredOutputNoObjectGeneratedError(
-            "structured output stream ended without an object payload",
-            provider
-          );
-        }
-        validatedObject = parseAndValidateStructuredPayload(
-          schema,
-          fallbackPayload,
-          provider
-        );
-        yield {
-          type: "object",
-          object: validatedObject
-        };
-      }
-      yield {
-        type: "finish",
-        finishReason: event.finishReason,
-        usage: event.usage
-      };
-    }
-  }
-}
-function getFallbackStructuredPayload(contentBuffer, toolArgumentDeltas) {
-  for (const delta of toolArgumentDeltas.values()) {
-    const trimmed = delta.trim();
-    if (trimmed.length > 0) {
-      return trimmed;
-    }
-  }
-  const trimmedContent = contentBuffer.trim();
-  if (trimmedContent.length > 0) {
-    return trimmedContent;
-  }
-  return void 0;
-}
-function validateStructuredToolArguments(schema, toolArguments, provider) {
-  return validateStructuredObject(
-    schema,
-    toolArguments,
-    provider,
-    JSON.stringify(toolArguments)
-  );
-}
-function parseAndValidateStructuredPayload(schema, rawPayload, provider) {
-  const parsedPayload = parseJson(rawPayload, provider);
-  return validateStructuredObject(
-    schema,
-    parsedPayload,
-    provider,
-    rawPayload
-  );
-}
-function parseJson(rawOutput, provider) {
-  try {
-    return JSON.parse(rawOutput);
-  } catch (error) {
-    throw new StructuredOutputParseError(
-      "failed to parse structured output as JSON",
-      provider,
-      {
-        rawOutput,
-        cause: error
-      }
-    );
-  }
-}
-function validateStructuredObject(schema, value, provider, rawOutput) {
-  const parsed = schema.safeParse(value);
-  if (parsed.success) {
-    return parsed.data;
-  }
-  throw new StructuredOutputValidationError(
-    "structured output does not match schema",
-    provider,
-    formatZodIssues(parsed.error.issues),
-    {
-      rawOutput
-    }
-  );
-}
-function formatZodIssues(issues) {
-  return issues.map((issue) => {
-    const path = issue.path.length > 0 ? issue.path.map((segment) => String(segment)).join(".") : "<root>";
-    return `${path}: ${issue.message}`;
-  });
-}
-
-// src/shared/provider-factory.ts
-import OpenAI from "openai";
-
-// src/embedding-model.ts
-function createOpenAIEmbeddingModel(client, modelId) {
-  return {
-    provider: "openai",
-    modelId,
-    async embed(options) {
-      try {
-        const openaiOptions = parseOpenAIEmbedProviderOptions(
-          options.providerOptions
-        );
-        const response = await client.embeddings.create({
-          model: modelId,
-          input: options.input,
-          ...options.dimensions !== void 0 ? { dimensions: options.dimensions } : {},
-          ...mapOpenAIEmbedProviderOptionsToRequestFields(
-            openaiOptions
-          )
-        });
-        return {
-          embeddings: response.data.slice().sort((a, b) => a.index - b.index).map((item) => item.embedding),
-          usage: {
-            inputTokens: response.usage.prompt_tokens
-          }
-        };
-      } catch (error) {
-        throw wrapOpenAIError(error);
-      }
-    }
-  };
-}
-function mapOpenAIEmbedProviderOptionsToRequestFields(options) {
-  return {
-    ...options?.encodingFormat !== void 0 ? { encoding_format: options.encodingFormat } : {},
-    ...options?.user !== void 0 ? { user: options.user } : {}
-  };
-}
-
-// src/image-model.ts
-function createOpenAIImageModel(client, modelId) {
-  return {
-    provider: "openai",
-    modelId,
-    async generate(options) {
-      try {
-        const openaiOptions = parseOpenAIImageProviderOptions(
-          options.providerOptions
-        );
-        const request = {
-          model: modelId,
-          prompt: options.prompt,
-          ...options.n !== void 0 ? { n: options.n } : {},
-          ...options.size !== void 0 ? { size: options.size } : {},
-          ...mapOpenAIImageProviderOptionsToRequestFields(
-            openaiOptions
-          )
-        };
-        const response = await client.images.generate(
-          request
-        );
-        return {
-          images: (response.data ?? []).map((image) => ({
-            base64: image.b64_json ?? void 0,
-            url: image.url ?? void 0,
-            revisedPrompt: image.revised_prompt ?? void 0
-          }))
-        };
-      } catch (error) {
-        throw wrapOpenAIError(error);
-      }
-    }
-  };
-}
-function mapOpenAIImageProviderOptionsToRequestFields(options) {
-  return {
-    ...options?.background !== void 0 ? { background: options.background } : {},
-    ...options?.moderation !== void 0 ? { moderation: options.moderation } : {},
-    ...options?.outputCompression !== void 0 ? { output_compression: options.outputCompression } : {},
-    ...options?.outputFormat !== void 0 ? { output_format: options.outputFormat } : {},
-    ...options?.quality !== void 0 ? { quality: options.quality } : {},
-    ...options?.responseFormat !== void 0 ? { response_format: options.responseFormat } : {},
-    ...options?.style !== void 0 ? { style: options.style } : {},
-    ...options?.user !== void 0 ? { user: options.user } : {}
-  };
-}
-
-// src/shared/provider-factory.ts
-function createOpenAIProvider(options, createChatModel) {
-  const client = options.client ?? new OpenAI({
-    apiKey: options.apiKey,
-    baseURL: options.baseURL
-  });
-  return {
-    chatModel: (modelId) => createChatModel(client, modelId),
-    embeddingModel: (modelId) => createOpenAIEmbeddingModel(client, modelId),
-    imageModel: (modelId) => createOpenAIImageModel(client, modelId)
-  };
-}
-
-// src/shared/utils.ts
-import { ValidationError } from "@core-ai/core-ai";
-function safeParseJsonObject(json) {
-  try {
-    const parsed = JSON.parse(json);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      return parsed;
-    }
-    return {};
-  } catch {
-    return {};
-  }
-}
-function validateOpenAIReasoningConfig(modelId, options) {
-  if (!options.reasoning) {
-    return;
-  }
-  const capabilities = getOpenAIModelCapabilities(modelId);
-  if (!capabilities.reasoning.restrictsSamplingParams) {
-    return;
-  }
-  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(
-      `OpenAI model "${modelId}" does not support ${name} when reasoning is enabled`,
-      void 0,
-      "openai"
-    );
-  }
-}
-
-export {
-  getOpenAIModelCapabilities,
-  toOpenAIReasoningEffort,
-  convertTools,
-  convertToolChoice,
-  getStructuredOutputToolName,
-  createStructuredOutputOptions,
-  safeParseJsonObject,
-  validateOpenAIReasoningConfig,
-  openaiResponsesGenerateProviderOptionsSchema,
-  openaiCompatGenerateProviderOptionsSchema,
-  openaiEmbedProviderOptionsSchema,
-  openaiImageProviderOptionsSchema,
-  parseOpenAIResponsesGenerateProviderOptions,
-  parseOpenAICompatGenerateProviderOptions,
-  openaiResponsesProviderOptionsSchema,
-  openaiCompatProviderOptionsSchema,
-  wrapOpenAIError,
-  extractStructuredObject,
-  transformStructuredOutputStream,
-  createOpenAIProvider
-};