@core-ai/openai 0.5.1 → 0.6.1

package/dist/index.js

@@ -1,3 +1,25 @@
+import {
+  clampReasoningEffort,
+  convertToolChoice,
+  convertTools,
+  createOpenAIEmbeddingModel,
+  createOpenAIImageModel,
+  createStructuredOutputOptions,
+  getOpenAIModelCapabilities,
+  getStructuredOutputToolName,
+  openaiCompatGenerateProviderOptionsSchema,
+  openaiCompatProviderOptionsSchema,
+  openaiEmbedProviderOptionsSchema,
+  openaiImageProviderOptionsSchema,
+  openaiResponsesGenerateProviderOptionsSchema,
+  openaiResponsesProviderOptionsSchema,
+  parseOpenAIResponsesGenerateProviderOptions,
+  safeParseJsonObject,
+  toOpenAIReasoningEffort,
+  validateOpenAIReasoningConfig,
+  wrapOpenAIError
+} from "./chunk-ZHHJ76M7.js";
+
 // src/provider.ts
 import OpenAI from "openai";
 
@@ -6,592 +28,620 @@ import {
   StructuredOutputNoObjectGeneratedError,
   StructuredOutputParseError,
   StructuredOutputValidationError,
-  createObjectStreamResult,
-  createStreamResult
+  createObjectStream,
+  createChatStream
 } from "@core-ai/core-ai";
 
 // src/chat-adapter.ts
-import { zodToJsonSchema } from "zod-to-json-schema";
-import { ProviderError } from "@core-ai/core-ai";
-
-// src/model-capabilities.ts
-var DEFAULT_CAPABILITIES = {
-  reasoning: {
-    supportsEffort: true,
-    supportedRange: ["low", "medium", "high"],
-    restrictsSamplingParams: false
-  }
-};
-var MODEL_CAPABILITIES = {
-  "gpt-5.2": {
-    reasoning: {
-      supportsEffort: true,
-      supportedRange: ["low", "medium", "high", "max"],
-      restrictsSamplingParams: true
-    }
-  },
-  "gpt-5.2-codex": {
-    reasoning: {
-      supportsEffort: true,
-      supportedRange: ["low", "medium", "high", "max"],
-      restrictsSamplingParams: true
-    }
-  },
-  "gpt-5.2-pro": {
-    reasoning: {
-      supportsEffort: true,
-      supportedRange: ["low", "medium", "high", "max"],
-      restrictsSamplingParams: true
-    }
-  },
-  "gpt-5.1": {
-    reasoning: {
-      supportsEffort: true,
-      supportedRange: ["low", "medium", "high"],
-      restrictsSamplingParams: true
-    }
-  },
-  "gpt-5": {
-    reasoning: {
-      supportsEffort: true,
-      supportedRange: ["minimal", "low", "medium", "high"],
-      restrictsSamplingParams: true
-    }
-  },
-  "gpt-5-mini": {
-    reasoning: {
-      supportsEffort: true,
-      supportedRange: ["minimal", "low", "medium", "high"],
-      restrictsSamplingParams: true
-    }
-  },
-  "gpt-5-nano": {
-    reasoning: {
-      supportsEffort: true,
-      supportedRange: ["minimal", "low", "medium", "high"],
-      restrictsSamplingParams: true
-    }
-  },
-  o3: {
-    reasoning: {
-      supportsEffort: true,
-      supportedRange: ["low", "medium", "high"],
-      restrictsSamplingParams: false
-    }
-  },
-  "o3-mini": {
-    reasoning: {
-      supportsEffort: true,
-      supportedRange: ["low", "medium", "high"],
-      restrictsSamplingParams: false
-    }
-  },
-  "o4-mini": {
-    reasoning: {
-      supportsEffort: true,
-      supportedRange: ["low", "medium", "high"],
-      restrictsSamplingParams: false
-    }
-  },
-  o1: {
-    reasoning: {
-      supportsEffort: true,
-      supportedRange: ["low", "medium", "high"],
-      restrictsSamplingParams: false
-    }
-  },
-  "o1-mini": {
-    reasoning: {
-      supportsEffort: false,
-      supportedRange: [],
-      restrictsSamplingParams: false
-    }
-  }
-};
-var EFFORT_RANK = {
-  minimal: 0,
-  low: 1,
-  medium: 2,
-  high: 3,
-  max: 4
-};
-function getOpenAIModelCapabilities(modelId) {
-  const normalizedModelId = normalizeModelId(modelId);
-  return MODEL_CAPABILITIES[normalizedModelId] ?? DEFAULT_CAPABILITIES;
-}
-function normalizeModelId(modelId) {
-  return modelId.replace(/-\d{8}$/, "");
-}
-function clampReasoningEffort(effort, supportedRange) {
-  if (supportedRange.length === 0 || supportedRange.includes(effort)) {
-    return effort;
-  }
-  const targetRank = EFFORT_RANK[effort];
-  let best = supportedRange[0] ?? effort;
-  let bestDistance = Math.abs(EFFORT_RANK[best] - targetRank);
-  for (const candidate of supportedRange) {
-    const distance = Math.abs(EFFORT_RANK[candidate] - targetRank);
-    if (distance < bestDistance) {
-      best = candidate;
-      bestDistance = distance;
-    }
-  }
-  return best;
-}
-function toOpenAIReasoningEffort(effort) {
-  if (effort === "max") {
-    return "xhigh";
-  }
-  return effort;
-}
-
-// src/chat-adapter.ts
-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.";
+import { getProviderMetadata } from "@core-ai/core-ai";
+var ENCRYPTED_REASONING_INCLUDE = "reasoning.encrypted_content";
 function convertMessages(messages) {
-  return messages.map(convertMessage);
+  return messages.flatMap(convertMessage);
 }
 function convertMessage(message) {
   if (message.role === "system") {
-    return {
-      role: "system",
-      content: message.content
-    };
+    return [
+      {
+        role: "developer",
+        content: message.content
+      }
+    ];
   }
   if (message.role === "user") {
-    return {
-      role: "user",
-      content: typeof message.content === "string" ? message.content : message.content.map(convertUserContentPart)
-    };
+    return [
+      {
+        role: "user",
+        content: typeof message.content === "string" ? message.content : message.content.map(convertUserContentPart)
+      }
+    ];
   }
   if (message.role === "assistant") {
-    const text = message.parts.flatMap((part) => part.type === "text" ? [part.text] : []).join("");
-    const toolCalls = message.parts.flatMap(
-      (part) => part.type === "tool-call" ? [part.toolCall] : []
-    );
-    return {
+    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: 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)
+      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)
+    });
   }
-  return {
-    role: "tool",
-    tool_call_id: message.toolCallId,
-    content: message.content
-  };
+  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: "text",
+      type: "input_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}`;
+    const imageUrl = part.source.type === "url" ? part.source.url : `data:${part.source.mediaType};base64,${part.source.data}`;
     return {
-      type: "image_url",
-      image_url: {
-        url
-      }
+      type: "input_image",
+      image_url: imageUrl
     };
   }
   return {
-    type: "file",
-    file: {
-      file_data: part.data,
-      ...part.filename ? { filename: part.filename } : {}
-    }
+    type: "input_file",
+    file_data: part.data,
+    ...part.filename ? { filename: part.filename } : {}
   };
 }
-function convertTools(tools) {
-  return Object.values(tools).map((tool) => ({
-    type: "function",
-    function: {
-      name: tool.name,
-      description: tool.description,
-      parameters: zodToJsonSchema(tool.parameters)
-    }
-  }));
+function createGenerateRequest(modelId, options) {
+  return createRequest(
+    modelId,
+    options,
+    false
+  );
 }
-function convertToolChoice(choice) {
-  if (typeof choice === "string") {
-    return choice;
-  }
-  return {
-    type: "function",
-    function: {
-      name: choice.toolName
-    }
-  };
+function createStreamRequest(modelId, options) {
+  return createRequest(
+    modelId,
+    options,
+    true
+  );
 }
-function getStructuredOutputToolName(options) {
-  const trimmedName = options.schemaName?.trim();
-  if (trimmedName && trimmedName.length > 0) {
-    return trimmedName;
+function createRequest(modelId, options, stream) {
+  const openaiOptions = parseOpenAIResponsesGenerateProviderOptions(
+    options.providerOptions
+  );
+  const request = {
+    ...createRequestBase(modelId, options),
+    ...stream ? { stream: true } : {},
+    ...mapOpenAIProviderOptionsToRequestFields(openaiOptions)
+  };
+  if (options.reasoning) {
+    request.include = mergeInclude(request.include, [
+      ENCRYPTED_REASONING_INCLUDE
+    ]);
   }
-  return DEFAULT_STRUCTURED_OUTPUT_TOOL_NAME;
+  return request;
 }
-function createStructuredOutputOptions(options) {
-  const toolName = getStructuredOutputToolName(options);
+function createRequestBase(modelId, options) {
+  validateOpenAIReasoningConfig(modelId, 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,
-    config: options.config,
-    providerOptions: options.providerOptions,
-    signal: options.signal
+    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 createGenerateRequest(modelId, options) {
-  return {
-    ...createRequestBase(modelId, options),
-    ...options.providerOptions
-  };
+function convertResponseTools(tools) {
+  return convertTools(tools).map((tool) => ({
+    type: "function",
+    name: tool.function.name,
+    description: tool.function.description,
+    parameters: tool.function.parameters
+  }));
 }
-function createStreamRequest(modelId, options) {
+function convertResponseToolChoice(choice) {
+  const converted = convertToolChoice(choice);
+  if (typeof converted === "string") {
+    return converted;
+  }
   return {
-    ...createRequestBase(modelId, options),
-    stream: true,
-    stream_options: {
-      include_usage: true
-    },
-    ...options.providerOptions
+    type: "function",
+    name: converted.function.name
   };
 }
-function createRequestBase(modelId, options) {
-  validateOpenAIReasoningConfig(modelId, options);
-  const reasoningFields = mapReasoningToRequestFields(modelId, options);
+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 {
-    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,
-    ...mapConfigToRequestFields(options.config)
+    ...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 mapConfigToRequestFields(config) {
+function mapOpenAIProviderOptionsToRequestFields(options) {
   return {
-    ...config?.temperature !== void 0 ? { temperature: config.temperature } : {},
-    ...config?.maxTokens !== void 0 ? { max_tokens: config.maxTokens } : {},
-    ...config?.topP !== void 0 ? { top_p: config.topP } : {},
-    ...config?.stopSequences ? { stop: config.stopSequences } : {},
-    ...config?.frequencyPenalty !== void 0 ? { frequency_penalty: config.frequencyPenalty } : {},
-    ...config?.presencePenalty !== void 0 ? { presence_penalty: config.presencePenalty } : {}
+    ...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 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 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 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);
+  const content = getTextContent(parts);
+  const reasoning = getReasoningText(parts);
+  const toolCalls = getToolCalls(parts);
   return {
     parts,
     content,
-    reasoning: null,
+    reasoning,
     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 } : {}
-      }
-    }
+    finishReason: mapFinishReason(response, toolCalls.length > 0),
+    usage: mapUsage(response.usage)
   };
 }
-function parseToolCalls(calls) {
-  if (!calls) {
-    return [];
+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 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)
+    type: "reasoning",
+    text,
+    providerMetadata: {
+      openai: { ...encryptedContent ? { encryptedContent } : {} }
+    }
   };
 }
-function mapFinishReason(reason) {
-  if (reason === "stop") {
-    return "stop";
-  }
-  if (reason === "length") {
+function getReasoningSummaryText(summary) {
+  return summary.map((item) => item.text).join("");
+}
+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");
+}
+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(
+    (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 (reason === "tool_calls" || reason === "function_call") {
+  if (incompleteReason === "content_filter") {
+    return "content-filter";
+  }
+  if (hasToolCalls) {
     return "tool-calls";
   }
-  if (reason === "content_filter") {
-    return "content-filter";
+  if (response.status === "completed") {
+    return "stop";
   }
   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,
+function mapUsage(usage) {
+  const reasoningTokens = usage?.output_tokens_details?.reasoning_tokens;
+  return {
+    inputTokens: usage?.input_tokens ?? 0,
+    outputTokens: usage?.output_tokens ?? 0,
     inputTokenDetails: {
-      cacheReadTokens: 0,
+      cacheReadTokens: usage?.input_tokens_details?.cached_tokens ?? 0,
       cacheWriteTokens: 0
     },
-    outputTokenDetails: {}
+    outputTokenDetails: {
+      ...reasoningTokens !== void 0 ? { reasoningTokens } : {}
+    }
   };
-  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 } : {}
-        }
+}
+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 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);
+      const reasoningStartTransition = getReasoningStartTransition(reasoningStarted);
+      reasoningStarted = reasoningStartTransition.nextReasoningStarted;
+      if (reasoningStartTransition.event) {
+        yield reasoningStartTransition.event;
+      }
+      yield {
+        type: "reasoning-delta",
+        text: event.delta
       };
+      continue;
     }
-    const choice = chunk.choices[0];
-    if (!choice) {
+    if (event.type === "response.reasoning_summary_text.done") {
+      const key = `${event.item_id}:${event.summary_index}`;
+      if (!seenSummaryDeltas.has(key) && event.text.length > 0) {
+        emittedReasoningItems.add(event.item_id);
+        const reasoningStartTransition = getReasoningStartTransition(reasoningStarted);
+        reasoningStarted = reasoningStartTransition.nextReasoningStarted;
+        if (reasoningStartTransition.event) {
+          yield reasoningStartTransition.event;
+        }
+        yield {
+          type: "reasoning-delta",
+          text: event.text
+        };
+      }
       continue;
     }
-    if (choice.delta.content) {
+    if (event.type === "response.output_text.delta") {
       yield {
         type: "text-delta",
-        text: choice.delta.content
+        text: event.delta
       };
+      continue;
     }
-    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: ""
+    if (event.type === "response.output_item.added") {
+      if (!isFunctionToolCall(event.item)) {
+        continue;
+      }
+      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
         };
-        const wasNew = !bufferedToolCalls.has(partialToolCall.index);
-        if (partialToolCall.id) {
-          current.id = partialToolCall.id;
-        }
-        if (partialToolCall.function?.name) {
-          current.name = partialToolCall.function.name;
+      }
+      continue;
+    }
+    if (event.type === "response.function_call_arguments.delta") {
+      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 reasoningStartTransition = getReasoningStartTransition(reasoningStarted);
+            reasoningStarted = reasoningStartTransition.nextReasoningStarted;
+            if (reasoningStartTransition.event) {
+              yield reasoningStartTransition.event;
+            }
+            yield {
+              type: "reasoning-delta",
+              text: summaryText
+            };
+          }
         }
-        if (partialToolCall.function?.arguments) {
-          current.arguments += partialToolCall.function.arguments;
-          yield {
-            type: "tool-call-delta",
-            toolCallId: current.id,
-            argumentsDelta: partialToolCall.function.arguments
-          };
+        const encryptedContent = typeof event.item.encrypted_content === "string" && event.item.encrypted_content.length > 0 ? event.item.encrypted_content : void 0;
+        if (encryptedContent) {
+          const reasoningStartTransition = getReasoningStartTransition(reasoningStarted);
+          reasoningStarted = reasoningStartTransition.nextReasoningStarted;
+          if (reasoningStartTransition.event) {
+            yield reasoningStartTransition.event;
+          }
         }
-        bufferedToolCalls.set(partialToolCall.index, current);
-        if (wasNew) {
-          yield {
-            type: "tool-call-start",
-            toolCallId: current.id,
-            toolName: current.name
-          };
+        const reasoningEndTransition2 = getReasoningEndTransition(
+          reasoningStarted,
+          {
+            openai: {
+              ...encryptedContent ? { encryptedContent } : {}
+            }
+          }
+        );
+        reasoningStarted = reasoningEndTransition2.nextReasoningStarted;
+        if (reasoningEndTransition2.event) {
+          yield reasoningEndTransition2.event;
         }
+        continue;
       }
+      if (!isFunctionToolCall(event.item)) {
+        continue;
+      }
+      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 (choice.finish_reason) {
-      finishReason = mapFinishReason(choice.finish_reason);
-    }
-    if (finishReason === "tool-calls") {
-      for (const toolCall of bufferedToolCalls.values()) {
-        if (emittedToolCalls.has(toolCall.id)) {
+    if (event.type === "response.completed") {
+      latestResponse = event.response;
+      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)) {
           continue;
         }
-        emittedToolCalls.add(toolCall.id);
+        emittedToolCalls.add(bufferedToolCall.id);
         yield {
           type: "tool-call-end",
           toolCall: {
-            id: toolCall.id,
-            name: toolCall.name,
-            arguments: safeParseJsonObject(toolCall.arguments)
+            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 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);
+  const finishReason = latestResponse ? mapFinishReason(latestResponse, hasToolCalls) : "unknown";
   yield {
     type: "finish",
     finishReason,
     usage
   };
 }
-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;
-  }
-  if (options.config?.temperature !== void 0) {
-    throw new ProviderError(
-      `OpenAI model "${modelId}" does not support temperature when reasoning is enabled`,
-      "openai"
-    );
-  }
-  if (options.config?.topP !== void 0) {
-    throw new ProviderError(
-      `OpenAI model "${modelId}" does not support topP when reasoning is enabled`,
-      "openai"
-    );
-  }
-}
 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
-  );
+  const effort = capabilities.reasoning.supportsEffort ? toOpenAIReasoningEffort(
+    clampReasoningEffort(
+      options.reasoning.effort,
+      capabilities.reasoning.supportedRange
+    )
+  ) : void 0;
   return {
-    reasoning_effort: toOpenAIReasoningEffort(clampedEffort)
+    reasoning: {
+      ...effort ? { effort } : {},
+      summary: "auto"
+    }
   };
 }
-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 isFunctionToolCall(item) {
+  return item.type === "function_call";
 }
-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;
+function isOutputMessage(item) {
+  return item.type === "message";
 }
-
-// src/openai-error.ts
-import { APIError } from "openai";
-import { ProviderError as ProviderError2 } from "@core-ai/core-ai";
-function wrapOpenAIError(error) {
-  if (error instanceof APIError) {
-    return new ProviderError2(error.message, "openai", error.status, error);
-  }
-  return new ProviderError2(
-    error instanceof Error ? error.message : String(error),
-    "openai",
-    void 0,
-    error
-  );
+function isReasoningItem(item) {
+  return item.type === "reasoning";
 }
 
 // src/chat-model.ts
 function createOpenAIChatModel(client, modelId) {
   const provider = "openai";
-  async function callOpenAIChatCompletionsApi(request) {
+  async function callOpenAIResponsesApi(request, signal) {
     try {
-      return await client.chat.completions.create(
-        request
-      );
+      return await client.responses.create(request, {
+        signal
+      });
     } catch (error) {
       throw wrapOpenAIError(error);
     }
   }
   async function generateChat(options) {
     const request = createGenerateRequest(modelId, options);
-    const response = await callOpenAIChatCompletionsApi(request);
+    const response = await callOpenAIResponsesApi(
+      request,
+      options.signal
+    );
     return mapGenerateResponse(response);
   }
   async function streamChat(options) {
     const request = createStreamRequest(modelId, options);
-    const stream = await callOpenAIChatCompletionsApi(request);
-    return createStreamResult(transformStream(stream));
+    return createChatStream(
+      async () => transformStream(
+        await callOpenAIResponsesApi(request, options.signal)
+      ),
+      { signal: options.signal }
+    );
   }
   return {
     provider,
@@ -618,13 +668,16 @@ function createOpenAIChatModel(client, modelId) {
       const structuredOptions = createStructuredOutputOptions(options);
       const stream = await streamChat(structuredOptions);
       const toolName = getStructuredOutputToolName(options);
-      return createObjectStreamResult(
+      return createObjectStream(
         transformStructuredOutputStream(
           stream,
           options.schema,
           provider,
           toolName
-        )
+        ),
+        {
+          signal: options.signal
+        }
       );
     }
   };
@@ -739,7 +792,12 @@ function validateStructuredToolArguments(schema, toolArguments, provider) {
 }
 function parseAndValidateStructuredPayload(schema, rawPayload, provider) {
   const parsedPayload = parseJson(rawPayload, provider);
-  return validateStructuredObject(schema, parsedPayload, provider, rawPayload);
+  return validateStructuredObject(
+    schema,
+    parsedPayload,
+    provider,
+    rawPayload
+  );
 }
 function parseJson(rawOutput, provider) {
   try {
@@ -776,63 +834,6 @@ function formatZodIssues(issues) {
   });
 }
 
-// src/embedding-model.ts
-function createOpenAIEmbeddingModel(client, modelId) {
-  return {
-    provider: "openai",
-    modelId,
-    async embed(options) {
-      try {
-        const response = await client.embeddings.create({
-          model: modelId,
-          input: options.input,
-          ...options.dimensions !== void 0 ? { dimensions: options.dimensions } : {},
-          ...options.providerOptions
-        });
-        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);
-      }
-    }
-  };
-}
-
-// src/image-model.ts
-function createOpenAIImageModel(client, modelId) {
-  return {
-    provider: "openai",
-    modelId,
-    async generate(options) {
-      try {
-        const request = {
-          model: modelId,
-          prompt: options.prompt,
-          ...options.n !== void 0 ? { n: options.n } : {},
-          ...options.size !== void 0 ? { size: options.size } : {},
-          ...options.providerOptions
-        };
-        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);
-      }
-    }
-  };
-}
-
 // src/provider.ts
 function createOpenAI(options = {}) {
   const client = options.client ?? new OpenAI({
@@ -846,5 +847,11 @@ function createOpenAI(options = {}) {
   };
 }
 export {
-  createOpenAI
+  createOpenAI,
+  openaiCompatGenerateProviderOptionsSchema,
+  openaiCompatProviderOptionsSchema,
+  openaiEmbedProviderOptionsSchema,
+  openaiImageProviderOptionsSchema,
+  openaiResponsesGenerateProviderOptionsSchema,
+  openaiResponsesProviderOptionsSchema
 };