@core-ai/openai 0.5.1 → 0.6.1

package/dist/compat.js

@@ -0,0 +1,612 @@
+import {
+  clampReasoningEffort,
+  convertToolChoice,
+  convertTools,
+  createOpenAIEmbeddingModel,
+  createOpenAIImageModel,
+  createStructuredOutputOptions,
+  getOpenAIModelCapabilities,
+  getStructuredOutputToolName,
+  openaiCompatGenerateProviderOptionsSchema,
+  openaiCompatProviderOptionsSchema,
+  parseOpenAICompatGenerateProviderOptions,
+  safeParseJsonObject,
+  toOpenAIReasoningEffort,
+  validateOpenAIReasoningConfig,
+  wrapOpenAIError
+} from "./chunk-ZHHJ76M7.js";
+
+// src/compat/provider.ts
+import OpenAI from "openai";
+
+// src/compat/chat-model.ts
+import {
+  StructuredOutputNoObjectGeneratedError,
+  StructuredOutputParseError,
+  StructuredOutputValidationError,
+  createObjectStream,
+  createChatStream
+} from "@core-ai/core-ai";
+
+// src/compat/chat-adapter.ts
+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 usage = {
+    inputTokens: 0,
+    outputTokens: 0,
+    inputTokenDetails: {
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0
+    },
+    outputTokenDetails: {}
+  };
+  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 {
+        type: "text-delta",
+        text: choice.delta.content
+      };
+    }
+    if (choice.delta.tool_calls) {
+      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") {
+      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 {
+    type: "finish",
+    finishReason,
+    usage
+  };
+}
+function mapReasoningToRequestFields(modelId, options) {
+  if (!options.reasoning) {
+    return {};
+  }
+  const capabilities = getOpenAIModelCapabilities(modelId);
+  if (!capabilities.reasoning.supportsEffort) {
+    return {};
+  }
+  const clampedEffort = clampReasoningEffort(
+    options.reasoning.effort,
+    capabilities.reasoning.supportedRange
+  );
+  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) {
+  const provider = "openai";
+  async function callOpenAIChatCompletionsApi(request, signal) {
+    try {
+      return await client.chat.completions.create(request, {
+        signal
+      });
+    } catch (error) {
+      throw wrapOpenAIError(error);
+    }
+  }
+  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,
+    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
+        }
+      );
+    }
+  };
+}
+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/compat/provider.ts
+function createOpenAICompat(options = {}) {
+  const client = options.client ?? new OpenAI({
+    apiKey: options.apiKey,
+    baseURL: options.baseURL
+  });
+  return {
+    chatModel: (modelId) => createOpenAICompatChatModel(client, modelId),
+    embeddingModel: (modelId) => createOpenAIEmbeddingModel(client, modelId),
+    imageModel: (modelId) => createOpenAIImageModel(client, modelId)
+  };
+}
+export {
+  createOpenAICompat,
+  openaiCompatGenerateProviderOptionsSchema,
+  openaiCompatProviderOptionsSchema
+};

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 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';
+import 'zod';
 
 type OpenAIProviderOptions = {
     apiKey?: string;
@@ -13,4 +15,8 @@ type OpenAIProvider = {
 };
 declare function createOpenAI(options?: OpenAIProviderOptions): OpenAIProvider;
 
-export { type OpenAIProvider, type OpenAIProviderOptions, createOpenAI };
+type OpenAIReasoningMetadata = {
+    encryptedContent?: string;
+};
+
+export { type OpenAIProvider, type OpenAIProviderOptions, type OpenAIReasoningMetadata, createOpenAI };