@core-ai/openai 0.14.0 → 0.16.0

package/dist/index.js

@@ -1,758 +1,26 @@
 import {
-  convertToolChoice,
-  convertTools,
+  createOpenAIChatCompletionsModel,
   createOpenAIProvider,
-  createStructuredOutputOptions,
-  extractStructuredObject,
   getOpenAIModelCapabilities,
-  getStructuredOutputToolName,
+  openaiChatGenerateProviderOptionsSchema,
   openaiCompatGenerateProviderOptionsSchema,
   openaiCompatProviderOptionsSchema,
   openaiEmbedProviderOptionsSchema,
   openaiImageProviderOptionsSchema,
   openaiResponsesGenerateProviderOptionsSchema,
-  openaiResponsesProviderOptionsSchema,
-  parseOpenAIResponsesGenerateProviderOptions,
-  safeParseJsonObject,
-  toOpenAIReasoningEffort,
-  transformStructuredOutputStream,
-  validateOpenAIReasoningConfig,
-  wrapOpenAIError
-} from "./chunk-7MAEB5C7.js";
-
-// src/chat-model.ts
-import { createObjectStream, createChatStream } from "@core-ai/core-ai";
-
-// src/chat-adapter.ts
-import { getProviderMetadata, clampReasoningEffort } from "@core-ai/core-ai";
-var ENCRYPTED_REASONING_INCLUDE = "reasoning.encrypted_content";
-var REASONING_SUMMARY_SEPARATOR = "\n\n";
-function convertMessages(messages) {
-  return messages.flatMap(convertMessage);
-}
-function convertMessage(message) {
-  if (message.role === "system") {
-    return [
-      {
-        role: "developer",
-        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") {
-    return convertAssistantMessage(message.parts);
-  }
-  return [
-    {
-      type: "function_call_output",
-      call_id: message.toolCallId,
-      output: message.content
-    }
-  ];
-}
-function convertAssistantMessage(parts) {
-  const items = [];
-  const textParts = [];
-  const flushTextBuffer = () => {
-    if (textParts.length === 0) {
-      return;
-    }
-    items.push({
-      role: "assistant",
-      content: textParts.join("\n\n")
-    });
-    textParts.length = 0;
-  };
-  for (const part of parts) {
-    if (part.type === "text") {
-      textParts.push(part.text);
-      continue;
-    }
-    if (part.type === "reasoning") {
-      if (getProviderMetadata(
-        part.providerMetadata,
-        "openai"
-      ) == null) {
-        if (part.text.length > 0) {
-          textParts.push(`<thinking>${part.text}</thinking>`);
-        }
-        continue;
-      }
-      flushTextBuffer();
-      const encryptedContent = getEncryptedReasoningContent(part);
-      items.push({
-        type: "reasoning",
-        summary: [
-          {
-            type: "summary_text",
-            text: part.text
-          }
-        ],
-        ...encryptedContent ? { encrypted_content: encryptedContent } : {}
-      });
-      continue;
-    }
-    flushTextBuffer();
-    items.push({
-      type: "function_call",
-      call_id: part.toolCall.id,
-      name: part.toolCall.name,
-      arguments: JSON.stringify(part.toolCall.arguments)
-    });
-  }
-  flushTextBuffer();
-  return items;
-}
-function getEncryptedReasoningContent(part) {
-  const { encryptedContent } = getProviderMetadata(
-    part.providerMetadata,
-    "openai"
-  ) ?? {};
-  return typeof encryptedContent === "string" && encryptedContent.length > 0 ? encryptedContent : void 0;
-}
-function convertUserContentPart(part) {
-  if (part.type === "text") {
-    return {
-      type: "input_text",
-      text: part.text
-    };
-  }
-  if (part.type === "image") {
-    const imageUrl = part.source.type === "url" ? part.source.url : `data:${part.source.mediaType};base64,${part.source.data}`;
-    return {
-      type: "input_image",
-      image_url: imageUrl
-    };
-  }
-  return {
-    type: "input_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 = parseOpenAIResponsesGenerateProviderOptions(
-    options.providerOptions
-  );
-  const request = {
-    ...createRequestBase(modelId, options),
-    ...stream ? { stream: true } : {},
-    ...mapOpenAIProviderOptionsToRequestFields(openaiOptions)
-  };
-  if (options.reasoning && getOpenAIModelCapabilities(modelId).reasoning.supported) {
-    request.include = mergeInclude(request.include, [
-      ENCRYPTED_REASONING_INCLUDE
-    ]);
-  }
-  return request;
-}
-function createRequestBase(modelId, options) {
-  validateOpenAIReasoningConfig(modelId, options);
-  return {
-    model: modelId,
-    store: false,
-    input: convertMessages(options.messages),
-    ...options.tools && Object.keys(options.tools).length > 0 ? { tools: convertResponseTools(options.tools) } : {},
-    ...options.toolChoice ? { tool_choice: convertResponseToolChoice(options.toolChoice) } : {},
-    ...mapReasoningToRequestFields(modelId, options),
-    ...mapSamplingToRequestFields(options)
-  };
-}
-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") {
-    return converted;
-  }
-  return {
-    type: "function",
-    name: converted.function.name
-  };
-}
-function mergeInclude(value, requiredIncludes) {
-  const include = Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
-  for (const requiredInclude of requiredIncludes) {
-    if (!include.includes(requiredInclude)) {
-      include.push(requiredInclude);
-    }
-  }
-  return include.length > 0 ? include : void 0;
-}
-function mapSamplingToRequestFields(options) {
-  return {
-    ...options.temperature !== void 0 ? { temperature: options.temperature } : {},
-    ...options.maxTokens !== void 0 ? { max_output_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?.include ? { include: options.include } : {},
-    ...options?.parallelToolCalls !== void 0 ? { parallel_tool_calls: options.parallelToolCalls } : {},
-    ...options?.user !== void 0 ? { user: options.user } : {}
-  };
-}
-function mapGenerateResponse(response) {
-  const parts = [];
-  for (const item of response.output) {
-    if (isReasoningItem(item)) {
-      const reasoningPart = mapReasoningPart(item);
-      if (reasoningPart) {
-        parts.push(reasoningPart);
-      }
-      continue;
-    }
-    if (isOutputMessage(item)) {
-      parts.push(...mapMessageTextParts(item));
-      continue;
-    }
-    if (isFunctionToolCall(item)) {
-      parts.push({
-        type: "tool-call",
-        toolCall: {
-          id: item.call_id,
-          name: item.name,
-          arguments: safeParseJsonObject(item.arguments)
-        }
-      });
-    }
-  }
-  const content = getTextContent(parts);
-  const reasoning = getReasoningText(parts);
-  const toolCalls = getToolCalls(parts);
-  return {
-    parts,
-    content,
-    reasoning,
-    toolCalls,
-    finishReason: mapFinishReason(response, toolCalls.length > 0),
-    usage: mapUsage(response.usage)
-  };
-}
-function mapReasoningPart(item) {
-  const text = getReasoningSummaryText(item.summary);
-  const encryptedContent = typeof item.encrypted_content === "string" && item.encrypted_content.length > 0 ? item.encrypted_content : void 0;
-  if (text.length === 0 && !encryptedContent) {
-    return null;
-  }
-  return {
-    type: "reasoning",
-    text,
-    providerMetadata: {
-      openai: { ...encryptedContent ? { encryptedContent } : {} }
-    }
-  };
-}
-function getReasoningSummaryText(summary) {
-  return summary.map((item) => item.text).join(REASONING_SUMMARY_SEPARATOR);
-}
-function mapMessageTextParts(message) {
-  return message.content.flatMap(
-    (contentItem) => contentItem.type === "output_text" && contentItem.text.length > 0 ? [{ type: "text", text: contentItem.text }] : []
-  );
-}
-function getTextContent(parts) {
-  return getJoinedPartText(parts, "text", "");
-}
-function getReasoningText(parts) {
-  return getJoinedPartText(parts, "reasoning", REASONING_SUMMARY_SEPARATOR);
-}
-function getJoinedPartText(parts, type, separator) {
-  const text = parts.flatMap(
-    (part) => part.type === type && "text" in part ? [part.text] : []
-  ).join(separator);
-  return text.length > 0 ? text : null;
-}
-function getToolCalls(parts) {
-  return parts.flatMap(
-    (part) => part.type === "tool-call" ? [part.toolCall] : []
-  );
-}
-function mapFinishReason(response, hasToolCalls) {
-  const incompleteReason = response.incomplete_details?.reason;
-  if (incompleteReason === "max_output_tokens") {
-    return "length";
-  }
-  if (incompleteReason === "content_filter") {
-    return "content-filter";
-  }
-  if (hasToolCalls) {
-    return "tool-calls";
-  }
-  if (response.status === "completed") {
-    return "stop";
-  }
-  return "unknown";
-}
-function mapUsage(usage) {
-  const reasoningTokens = usage?.output_tokens_details?.reasoning_tokens;
-  return {
-    inputTokens: usage?.input_tokens ?? 0,
-    outputTokens: usage?.output_tokens ?? 0,
-    inputTokenDetails: {
-      cacheReadTokens: usage?.input_tokens_details?.cached_tokens ?? 0,
-      cacheWriteTokens: 0
-    },
-    outputTokenDetails: {
-      ...reasoningTokens !== void 0 ? { reasoningTokens } : {}
-    }
-  };
-}
-function getReasoningSummaryKey(part) {
-  return `${part.itemId}:${part.summaryIndex}`;
-}
-function isSameReasoningSummaryPart(left, right) {
-  return left.itemId === right.itemId && left.summaryIndex === right.summaryIndex;
-}
-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();
-  const startedToolCalls = /* @__PURE__ */ new Set();
-  const seenSummaryDeltas = /* @__PURE__ */ new Set();
-  const emittedReasoningItems = /* @__PURE__ */ new Set();
-  let latestResponse;
-  let textOpen = false;
-  let reasoningStarted = false;
-  let latestReasoningSummaryPart;
-  const upsertBufferedToolCall = (outputIndex, getNextToolCall) => {
-    const nextToolCall = getNextToolCall(
-      bufferedToolCalls.get(outputIndex)
-    );
-    bufferedToolCalls.set(outputIndex, nextToolCall);
-    return nextToolCall;
-  };
-  const getNextReasoningStartEvent = () => {
-    const transition = getReasoningStartTransition(reasoningStarted);
-    reasoningStarted = transition.nextReasoningStarted;
-    return transition.event;
-  };
-  const startText = function* () {
-    if (textOpen) {
-      return;
-    }
-    textOpen = true;
-    yield { type: "text-start" };
-  };
-  const closeText = function* () {
-    if (!textOpen) {
-      return;
-    }
-    textOpen = false;
-    yield { type: "text-end" };
-  };
-  const getNextReasoningEndEvent = (providerMetadata) => {
-    const transition = getReasoningEndTransition(
-      reasoningStarted,
-      providerMetadata
-    );
-    reasoningStarted = transition.nextReasoningStarted;
-    if (transition.event) {
-      latestReasoningSummaryPart = void 0;
-    }
-    return transition.event;
-  };
-  const getReasoningSummarySeparatorEvent = (currentPart) => {
-    const previousPart = latestReasoningSummaryPart;
-    latestReasoningSummaryPart = currentPart;
-    if (previousPart === void 0 || isSameReasoningSummaryPart(previousPart, currentPart)) {
-      return null;
-    }
-    return {
-      type: "reasoning-delta",
-      text: REASONING_SUMMARY_SEPARATOR
-    };
-  };
-  for await (const event of stream) {
-    if (event.type === "response.reasoning_summary_text.delta") {
-      const summaryPart = {
-        itemId: event.item_id,
-        summaryIndex: event.summary_index
-      };
-      seenSummaryDeltas.add(getReasoningSummaryKey(summaryPart));
-      emittedReasoningItems.add(event.item_id);
-      const reasoningStartEvent = getNextReasoningStartEvent();
-      if (reasoningStartEvent) {
-        yield* closeText();
-        yield reasoningStartEvent;
-      }
-      const separatorEvent = getReasoningSummarySeparatorEvent(summaryPart);
-      if (separatorEvent) {
-        yield separatorEvent;
-      }
-      yield {
-        type: "reasoning-delta",
-        text: event.delta
-      };
-      continue;
-    }
-    if (event.type === "response.reasoning_summary_text.done") {
-      const summaryPart = {
-        itemId: event.item_id,
-        summaryIndex: event.summary_index
-      };
-      const key = getReasoningSummaryKey(summaryPart);
-      if (!seenSummaryDeltas.has(key) && event.text.length > 0) {
-        emittedReasoningItems.add(event.item_id);
-        const reasoningStartEvent = getNextReasoningStartEvent();
-        if (reasoningStartEvent) {
-          yield* closeText();
-          yield reasoningStartEvent;
-        }
-        const separatorEvent = getReasoningSummarySeparatorEvent(summaryPart);
-        if (separatorEvent) {
-          yield separatorEvent;
-        }
-        yield {
-          type: "reasoning-delta",
-          text: event.text
-        };
-      }
-      continue;
-    }
-    if (event.type === "response.output_text.delta") {
-      const reasoningEndEvent2 = getNextReasoningEndEvent({ openai: {} });
-      if (reasoningEndEvent2) {
-        yield reasoningEndEvent2;
-      }
-      yield* startText();
-      yield {
-        type: "text-delta",
-        text: event.delta
-      };
-      continue;
-    }
-    if (event.type === "response.output_item.added") {
-      if (!isFunctionToolCall(event.item)) {
-        continue;
-      }
-      yield* closeText();
-      const toolCallId = event.item.call_id;
-      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: toolCallName
-        };
-      }
-      continue;
-    }
-    if (event.type === "response.function_call_arguments.delta") {
-      yield* closeText();
-      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",
-          toolCallId: currentToolCall.id,
-          toolName: currentToolCall.name
-        };
-      }
-      yield {
-        type: "tool-call-delta",
-        toolCallId: currentToolCall.id,
-        argumentsDelta: event.delta
-      };
-      continue;
-    }
-    if (event.type === "response.output_item.done") {
-      if (isReasoningItem(event.item)) {
-        if (!emittedReasoningItems.has(event.item.id)) {
-          const summaryText = getReasoningSummaryText(
-            event.item.summary
-          );
-          if (summaryText.length > 0) {
-            const reasoningStartEvent = getNextReasoningStartEvent();
-            if (reasoningStartEvent) {
-              yield* closeText();
-              yield reasoningStartEvent;
-            }
-            yield {
-              type: "reasoning-delta",
-              text: summaryText
-            };
-          }
-        }
-        const encryptedContent = typeof event.item.encrypted_content === "string" && event.item.encrypted_content.length > 0 ? event.item.encrypted_content : void 0;
-        if (encryptedContent) {
-          const reasoningStartEvent = getNextReasoningStartEvent();
-          if (reasoningStartEvent) {
-            yield* closeText();
-            yield reasoningStartEvent;
-          }
-        }
-        const reasoningEndEvent2 = getNextReasoningEndEvent({
-          openai: {
-            ...encryptedContent ? { encryptedContent } : {}
-          }
-        });
-        if (reasoningEndEvent2) {
-          yield reasoningEndEvent2;
-        }
-        continue;
-      }
-      if (!isFunctionToolCall(event.item)) {
-        continue;
-      }
-      yield* closeText();
-      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 {
-          type: "tool-call-end",
-          toolCall: {
-            id: currentToolCall.id,
-            name: currentToolCall.name,
-            arguments: safeParseJsonObject(
-              currentToolCall.arguments
-            )
-          }
-        };
-      }
-      continue;
-    }
-    if (event.type === "response.completed") {
-      latestResponse = event.response;
-      yield* closeText();
-      const reasoningEndEvent2 = getNextReasoningEndEvent({ openai: {} });
-      if (reasoningEndEvent2) {
-        yield reasoningEndEvent2;
-      }
-      for (const bufferedToolCall of bufferedToolCalls.values()) {
-        if (emittedToolCalls.has(bufferedToolCall.id)) {
-          continue;
-        }
-        emittedToolCalls.add(bufferedToolCall.id);
-        yield {
-          type: "tool-call-end",
-          toolCall: {
-            id: bufferedToolCall.id,
-            name: bufferedToolCall.name,
-            arguments: safeParseJsonObject(
-              bufferedToolCall.arguments
-            )
-          }
-        };
-      }
-      const hasToolCalls2 = bufferedToolCalls.size > 0;
-      yield {
-        type: "finish",
-        finishReason: mapFinishReason(latestResponse, hasToolCalls2),
-        usage: mapUsage(latestResponse.usage)
-      };
-      return;
-    }
-  }
-  const reasoningEndEvent = getNextReasoningEndEvent({
-    openai: {}
-  });
-  yield* closeText();
-  if (reasoningEndEvent) {
-    yield reasoningEndEvent;
-  }
-  const hasToolCalls = bufferedToolCalls.size > 0;
-  const usage = latestResponse ? mapUsage(latestResponse.usage) : mapUsage(void 0);
-  const finishReason = latestResponse ? mapFinishReason(latestResponse, hasToolCalls) : "unknown";
-  yield {
-    type: "finish",
-    finishReason,
-    usage
-  };
-}
-function mapReasoningToRequestFields(modelId, options) {
-  if (!options.reasoning) {
-    return {};
-  }
-  const capabilities = getOpenAIModelCapabilities(modelId);
-  if (!capabilities.reasoning.supported) {
-    return {};
-  }
-  const effort = toOpenAIReasoningEffort(
-    clampReasoningEffort(
-      options.reasoning.effort,
-      capabilities.reasoning.supportedEfforts
-    )
-  );
-  return {
-    reasoning: {
-      effort,
-      summary: "auto"
-    }
-  };
-}
-function isFunctionToolCall(item) {
-  return item.type === "function_call";
-}
-function isOutputMessage(item) {
-  return item.type === "message";
-}
-function isReasoningItem(item) {
-  return item.type === "reasoning";
-}
-
-// src/chat-model.ts
-function createOpenAIChatModel(client, modelId) {
-  const provider = "openai";
-  async function callOpenAIResponsesApi(request, signal) {
-    try {
-      return await client.responses.create(request, {
-        signal
-      });
-    } catch (error) {
-      throw wrapOpenAIError(error);
-    }
-  }
-  async function generateChat(options) {
-    const request = createGenerateRequest(modelId, options);
-    const response = await callOpenAIResponsesApi(
-      request,
-      options.signal
-    );
-    return mapGenerateResponse(response);
-  }
-  async function streamChat(options) {
-    const request = createStreamRequest(modelId, options);
-    return createChatStream(
-      async () => transformStream(
-        await callOpenAIResponsesApi(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
-        }
-      );
-    }
-  };
-}
+  openaiResponsesProviderOptionsSchema
+} from "./chunk-YORO2XQ3.js";
 
 // src/provider.ts
 function createOpenAI(options = {}) {
-  return createOpenAIProvider(options, createOpenAIChatModel);
+  return createOpenAIProvider(options);
 }
 export {
   createOpenAI,
+  createOpenAIChatCompletionsModel,
+  createOpenAIProvider,
   getOpenAIModelCapabilities,
+  openaiChatGenerateProviderOptionsSchema,
   openaiCompatGenerateProviderOptionsSchema,
   openaiCompatProviderOptionsSchema,
   openaiEmbedProviderOptionsSchema,