@core-ai/openai 0.14.0 → 0.16.0

package/dist/compat.d.ts

@@ -1,16 +1,13 @@
+import * as _core_ai_core_ai from '@core-ai/core-ai';
 import { ChatModel } from '@core-ai/core-ai';
-import OpenAI from 'openai';
-import { O as OpenAIProvider, a as OpenAIProviderBaseOptions } from './provider-options-DzqvHoId.js';
-export { b as OpenAICompatGenerateProviderOptions, c as OpenAICompatRequestOptions, o as openaiCompatGenerateProviderOptionsSchema, d as openaiCompatProviderOptionsSchema } from './provider-options-DzqvHoId.js';
+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 'openai';
 import 'zod';
 
-type OpenAIChatClient = {
-    chat: OpenAI['chat'];
-};
-declare function createOpenAICompatChatModel(client: OpenAIChatClient, modelId: string, providerId?: string): ChatModel;
-
 type OpenAICompatProviderOptions = OpenAIProviderBaseOptions;
 type OpenAICompatProvider = OpenAIProvider;
+/** @deprecated Use `createOpenAI().chat` or `@core-ai/openai-compat`. */
 declare function createOpenAICompat(options?: OpenAICompatProviderOptions): OpenAICompatProvider;
 type OpenAICompatChatProviderOptions = {
     apiKey?: string;
@@ -23,7 +20,12 @@ type OpenAICompatChatProvider = {
 /**
  * Creates a chat-only OpenAI-compatible provider. Handles client construction
  * internally so consumers do not need a direct dependency on the `openai` package.
+ *
+ * @deprecated Use the provider composition exports from `@core-ai/openai`.
  */
 declare function createOpenAICompatChatProvider(options?: OpenAICompatChatProviderOptions, providerId?: string): OpenAICompatChatProvider;
 
-export { type OpenAIChatClient, type OpenAICompatChatProvider, type OpenAICompatChatProviderOptions, type OpenAICompatProvider, type OpenAICompatProviderOptions, createOpenAICompat, createOpenAICompatChatModel, createOpenAICompatChatProvider };
+/** @deprecated Use `createOpenAI().chat.chatModel()` instead. */
+declare function createOpenAICompatChatModel(client: OpenAIChatClient, modelId: string, providerId?: string): _core_ai_core_ai.ChatModel;
+
+export { OpenAIChatClient, type OpenAICompatChatProvider, type OpenAICompatChatProviderOptions, type OpenAICompatProvider, type OpenAICompatProviderOptions, createOpenAICompat, createOpenAICompatChatModel, createOpenAICompatChatProvider };

package/dist/compat.js

@@ -1,465 +1,17 @@
 import {
-  convertToolChoice,
-  convertTools,
+  createOpenAIChatCompletionsModel,
   createOpenAIProvider,
-  createStructuredOutputOptions,
-  extractStructuredObject,
-  getOpenAIModelCapabilities,
-  getStructuredOutputToolName,
   openaiCompatGenerateProviderOptionsSchema,
-  openaiCompatProviderOptionsSchema,
-  parseOpenAICompatGenerateProviderOptions,
-  safeParseJsonObject,
-  toOpenAIReasoningEffort,
-  transformStructuredOutputStream,
-  validateOpenAIReasoningConfig,
-  wrapOpenAIError
-} from "./chunk-7MAEB5C7.js";
+  openaiCompatProviderOptionsSchema
+} from "./chunk-YORO2XQ3.js";
 
 // src/compat/provider.ts
 import OpenAI from "openai";
-
-// src/compat/chat-model.ts
-import { createObjectStream, createChatStream } from "@core-ai/core-ai";
-
-// src/compat/chat-adapter.ts
-import { clampReasoningEffort } from "@core-ai/core-ai";
-function convertMessages(messages) {
-  return messages.map(convertMessage);
-}
-function convertMessage(message) {
-  if (message.role === "system") {
-    return {
-      role: "system",
-      content: message.content
-    };
-  }
-  if (message.role === "user") {
-    return {
-      role: "user",
-      content: typeof message.content === "string" ? message.content : message.content.map(convertUserContentPart)
-    };
-  }
-  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>`];
-      }
-      return [];
-    }).join("\n\n");
-    const toolCalls = message.parts.flatMap(
-      (part) => part.type === "tool-call" ? [part.toolCall] : []
-    );
-    return {
-      role: "assistant",
-      content: text.length > 0 ? text : null,
-      ...toolCalls.length > 0 ? {
-        tool_calls: toolCalls.map((toolCall) => ({
-          id: toolCall.id,
-          type: "function",
-          function: {
-            name: toolCall.name,
-            arguments: JSON.stringify(toolCall.arguments)
-          }
-        }))
-      } : {}
-    };
-  }
-  return {
-    role: "tool",
-    tool_call_id: message.toolCallId,
-    content: message.content
-  };
-}
-function convertUserContentPart(part) {
-  if (part.type === "text") {
-    return {
-      type: "text",
-      text: part.text
-    };
-  }
-  if (part.type === "image") {
-    const url = part.source.type === "url" ? part.source.url : `data:${part.source.mediaType};base64,${part.source.data}`;
-    return {
-      type: "image_url",
-      image_url: {
-        url
-      }
-    };
-  }
-  return {
-    type: "file",
-    file: {
-      file_data: part.data,
-      ...part.filename ? { filename: part.filename } : {}
-    }
-  };
-}
-function createGenerateRequest(modelId, options) {
-  return createRequest(modelId, options, false);
-}
-function createStreamRequest(modelId, options) {
-  return createRequest(modelId, options, true);
-}
-function createRequest(modelId, options, stream) {
-  const openaiOptions = parseOpenAICompatGenerateProviderOptions(
-    options.providerOptions
-  );
-  return {
-    ...createRequestBase(modelId, options),
-    ...stream ? {
-      stream: true,
-      stream_options: {
-        include_usage: true
-      }
-    } : {},
-    ...mapOpenAIProviderOptionsToRequestFields(openaiOptions)
-  };
-}
-function createRequestBase(modelId, options) {
-  validateOpenAIReasoningConfig(modelId, options);
-  const reasoningFields = mapReasoningToRequestFields(modelId, options);
-  return {
-    model: modelId,
-    messages: convertMessages(options.messages),
-    ...options.tools && Object.keys(options.tools).length > 0 ? { tools: convertTools(options.tools) } : {},
-    ...options.toolChoice ? { tool_choice: convertToolChoice(options.toolChoice) } : {},
-    ...reasoningFields,
-    ...mapSamplingToRequestFields(options)
-  };
-}
-function mapSamplingToRequestFields(options) {
-  return {
-    ...options.temperature !== void 0 ? { temperature: options.temperature } : {},
-    ...options.maxTokens !== void 0 ? { max_tokens: options.maxTokens } : {},
-    ...options.topP !== void 0 ? { top_p: options.topP } : {}
-  };
-}
-function mapOpenAIProviderOptionsToRequestFields(options) {
-  return {
-    ...options?.store !== void 0 ? { store: options.store } : {},
-    ...options?.serviceTier !== void 0 ? { service_tier: options.serviceTier } : {},
-    ...options?.parallelToolCalls !== void 0 ? { parallel_tool_calls: options.parallelToolCalls } : {},
-    ...options?.user !== void 0 ? { user: options.user } : {},
-    ...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 } : {}
-  };
-}
-function mapGenerateResponse(response) {
-  const firstChoice = response.choices[0];
-  if (!firstChoice) {
-    return {
-      parts: [],
-      content: null,
-      reasoning: null,
-      toolCalls: [],
-      finishReason: "unknown",
-      usage: {
-        inputTokens: 0,
-        outputTokens: 0,
-        inputTokenDetails: {
-          cacheReadTokens: 0,
-          cacheWriteTokens: 0
-        },
-        outputTokenDetails: {}
-      }
-    };
-  }
-  const reasoningTokens = response.usage?.completion_tokens_details?.reasoning_tokens;
-  const content = extractTextContent(firstChoice.message.content);
-  const toolCalls = parseToolCalls(firstChoice.message.tool_calls);
-  const parts = createAssistantParts(content, toolCalls);
-  return {
-    parts,
-    content,
-    reasoning: null,
-    toolCalls,
-    finishReason: mapFinishReason(firstChoice.finish_reason),
-    usage: {
-      inputTokens: response.usage?.prompt_tokens ?? 0,
-      outputTokens: response.usage?.completion_tokens ?? 0,
-      inputTokenDetails: {
-        cacheReadTokens: response.usage?.prompt_tokens_details?.cached_tokens ?? 0,
-        cacheWriteTokens: 0
-      },
-      outputTokenDetails: {
-        ...reasoningTokens !== void 0 ? { reasoningTokens } : {}
-      }
-    }
-  };
-}
-function parseToolCalls(calls) {
-  if (!calls) {
-    return [];
-  }
-  return calls.flatMap((toolCall) => {
-    if (toolCall.type !== "function") {
-      return [];
-    }
-    return [mapFunctionToolCall(toolCall)];
-  });
-}
-function mapFunctionToolCall(toolCall) {
-  return {
-    id: toolCall.id,
-    name: toolCall.function.name,
-    arguments: safeParseJsonObject(toolCall.function.arguments)
-  };
-}
-function mapFinishReason(reason) {
-  if (reason === "stop") {
-    return "stop";
-  }
-  if (reason === "length") {
-    return "length";
-  }
-  if (reason === "tool_calls" || reason === "function_call") {
-    return "tool-calls";
-  }
-  if (reason === "content_filter") {
-    return "content-filter";
-  }
-  return "unknown";
-}
-async function* transformStream(stream) {
-  const bufferedToolCalls = /* @__PURE__ */ new Map();
-  const emittedToolCalls = /* @__PURE__ */ new Set();
-  let finishReason = "unknown";
-  let textOpen = false;
-  let usage = {
-    inputTokens: 0,
-    outputTokens: 0,
-    inputTokenDetails: {
-      cacheReadTokens: 0,
-      cacheWriteTokens: 0
-    },
-    outputTokenDetails: {}
-  };
-  const startText = function* () {
-    if (textOpen) {
-      return;
-    }
-    textOpen = true;
-    yield { type: "text-start" };
-  };
-  const closeText = function* () {
-    if (!textOpen) {
-      return;
-    }
-    textOpen = false;
-    yield { type: "text-end" };
-  };
-  for await (const chunk of stream) {
-    if (chunk.usage) {
-      const reasoningTokens = chunk.usage.completion_tokens_details?.reasoning_tokens;
-      usage = {
-        inputTokens: chunk.usage.prompt_tokens ?? 0,
-        outputTokens: chunk.usage.completion_tokens ?? 0,
-        inputTokenDetails: {
-          cacheReadTokens: chunk.usage.prompt_tokens_details?.cached_tokens ?? 0,
-          cacheWriteTokens: 0
-        },
-        outputTokenDetails: {
-          ...reasoningTokens !== void 0 ? { reasoningTokens } : {}
-        }
-      };
-    }
-    const choice = chunk.choices[0];
-    if (!choice) {
-      continue;
-    }
-    if (choice.delta.content) {
-      yield* startText();
-      yield {
-        type: "text-delta",
-        text: choice.delta.content
-      };
-    }
-    if (choice.delta.tool_calls) {
-      yield* closeText();
-      for (const partialToolCall of choice.delta.tool_calls) {
-        const current = bufferedToolCalls.get(
-          partialToolCall.index
-        ) ?? {
-          id: partialToolCall.id ?? `tool-${partialToolCall.index}`,
-          name: partialToolCall.function?.name ?? "",
-          arguments: ""
-        };
-        const wasNew = !bufferedToolCalls.has(partialToolCall.index);
-        if (partialToolCall.id) {
-          current.id = partialToolCall.id;
-        }
-        if (partialToolCall.function?.name) {
-          current.name = partialToolCall.function.name;
-        }
-        if (partialToolCall.function?.arguments) {
-          current.arguments += partialToolCall.function.arguments;
-          yield {
-            type: "tool-call-delta",
-            toolCallId: current.id,
-            argumentsDelta: partialToolCall.function.arguments
-          };
-        }
-        bufferedToolCalls.set(partialToolCall.index, current);
-        if (wasNew) {
-          yield {
-            type: "tool-call-start",
-            toolCallId: current.id,
-            toolName: current.name
-          };
-        }
-      }
-    }
-    if (choice.finish_reason) {
-      finishReason = mapFinishReason(choice.finish_reason);
-    }
-    if (finishReason === "tool-calls") {
-      yield* closeText();
-      for (const toolCall of bufferedToolCalls.values()) {
-        if (emittedToolCalls.has(toolCall.id)) {
-          continue;
-        }
-        emittedToolCalls.add(toolCall.id);
-        yield {
-          type: "tool-call-end",
-          toolCall: {
-            id: toolCall.id,
-            name: toolCall.name,
-            arguments: safeParseJsonObject(toolCall.arguments)
-          }
-        };
-      }
-    }
-  }
-  yield* closeText();
-  yield {
-    type: "finish",
-    finishReason,
-    usage
-  };
-}
-function mapReasoningToRequestFields(modelId, options) {
-  if (!options.reasoning) {
-    return {};
-  }
-  const capabilities = getOpenAIModelCapabilities(modelId);
-  if (!capabilities.reasoning.supported) {
-    return {};
-  }
-  const clampedEffort = clampReasoningEffort(
-    options.reasoning.effort,
-    capabilities.reasoning.supportedEfforts
-  );
-  return {
-    reasoning_effort: toOpenAIReasoningEffort(clampedEffort)
-  };
-}
-function createAssistantParts(content, toolCalls) {
-  const parts = [];
-  if (content) {
-    parts.push({
-      type: "text",
-      text: content
-    });
-  }
-  for (const toolCall of toolCalls) {
-    parts.push({
-      type: "tool-call",
-      toolCall
-    });
-  }
-  return parts;
-}
-function extractTextContent(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  if (!Array.isArray(content)) {
-    return null;
-  }
-  const text = content.flatMap((item) => {
-    if (!item || typeof item !== "object") {
-      return [];
-    }
-    const textValue = item.text;
-    return typeof textValue === "string" ? [textValue] : [];
-  }).join("");
-  return text.length > 0 ? text : null;
-}
-
-// src/compat/chat-model.ts
-function createOpenAICompatChatModel(client, modelId, providerId = "openai") {
-  const provider = providerId;
-  async function callOpenAIChatCompletionsApi(request, signal) {
-    try {
-      return await client.chat.completions.create(request, {
-        signal
-      });
-    } catch (error) {
-      throw wrapOpenAIError(error, provider);
-    }
-  }
-  async function generateChat(options) {
-    const request = createGenerateRequest(modelId, options);
-    const response = await callOpenAIChatCompletionsApi(request, options.signal);
-    return mapGenerateResponse(response);
-  }
-  async function streamChat(options) {
-    const request = createStreamRequest(modelId, options);
-    return createChatStream(
-      async () => transformStream(
-        await callOpenAIChatCompletionsApi(request, options.signal)
-      ),
-      { signal: options.signal }
-    );
-  }
-  return {
-    provider,
-    modelId,
-    capabilities: getOpenAIModelCapabilities(modelId),
-    generate: generateChat,
-    stream: streamChat,
-    async generateObject(options) {
-      const structuredOptions = createStructuredOutputOptions(options);
-      const result = await generateChat(structuredOptions);
-      const toolName = getStructuredOutputToolName(options);
-      const object = extractStructuredObject(
-        result,
-        options.schema,
-        provider,
-        toolName
-      );
-      return {
-        object,
-        finishReason: result.finishReason,
-        usage: result.usage
-      };
-    },
-    async streamObject(options) {
-      const structuredOptions = createStructuredOutputOptions(options);
-      const stream = await streamChat(structuredOptions);
-      const toolName = getStructuredOutputToolName(options);
-      return createObjectStream(
-        transformStructuredOutputStream(
-          stream,
-          options.schema,
-          provider,
-          toolName
-        ),
-        {
-          signal: options.signal
-        }
-      );
-    }
-  };
-}
-
-// src/compat/provider.ts
 function createOpenAICompat(options = {}) {
-  return createOpenAIProvider(options, createOpenAICompatChatModel);
+  return createOpenAIProvider(options, {
+    defaultApi: "chat-completions",
+    compatibility: true
+  });
 }
 function createOpenAICompatChatProvider(options = {}, providerId = "openai") {
   const client = options.client ?? new OpenAI({
@@ -467,9 +19,20 @@ function createOpenAICompatChatProvider(options = {}, providerId = "openai") {
     baseURL: options.baseURL
   });
   return {
-    chatModel: (modelId) => createOpenAICompatChatModel(client, modelId, providerId)
+    chatModel: (modelId) => createOpenAIChatCompletionsModel(client, modelId, {
+      providerId,
+      compatibility: true
+    })
   };
 }
+
+// src/compat/chat-model.ts
+function createOpenAICompatChatModel(client, modelId, providerId = "openai") {
+  return createOpenAIChatCompletionsModel(client, modelId, {
+    providerId,
+    compatibility: true
+  });
+}
 export {
   createOpenAICompat,
   createOpenAICompatChatModel,

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { O as OpenAIProvider$1, a as OpenAIProviderBaseOptions } from './provider-options-DzqvHoId.js';
-export { b as OpenAICompatGenerateProviderOptions, c as OpenAICompatRequestOptions, e as OpenAIEmbedProviderOptions, f as OpenAIImageProviderOptions, g as OpenAIResponsesGenerateProviderOptions, h as OpenAIResponsesProviderOptions, o as openaiCompatGenerateProviderOptionsSchema, d as openaiCompatProviderOptionsSchema, i as openaiEmbedProviderOptionsSchema, j as openaiImageProviderOptionsSchema, k as openaiResponsesGenerateProviderOptionsSchema, l as openaiResponsesProviderOptionsSchema } from './provider-options-DzqvHoId.js';
-import { ModelCapabilities } from '@core-ai/core-ai';
+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 'openai';
+import '@core-ai/core-ai';
 import 'zod';
 
 type OpenAIProviderOptions = OpenAIProviderBaseOptions;
@@ -12,7 +12,4 @@ type OpenAIReasoningMetadata = {
     encryptedContent?: string;
 };
 
-type OpenAIModelCapabilities = ModelCapabilities;
-declare function getOpenAIModelCapabilities(modelId: string): OpenAIModelCapabilities;
-
-export { type OpenAIModelCapabilities, type OpenAIProvider, type OpenAIProviderOptions, type OpenAIReasoningMetadata, createOpenAI, getOpenAIModelCapabilities };
+export { type OpenAIProvider, OpenAIProviderBaseOptions, type OpenAIProviderOptions, type OpenAIReasoningMetadata, createOpenAI };