@core-ai/openai 0.6.0 → 0.6.1

package/dist/{chunk-7CU5JW63.js → chunk-ZHHJ76M7.js}

@@ -221,6 +221,20 @@ var DEFAULT_CAPABILITIES = {
   }
 };
 var MODEL_CAPABILITIES = {
+  "gpt-5.4": {
+    reasoning: {
+      supportsEffort: true,
+      supportedRange: ["low", "medium", "high", "max"],
+      restrictsSamplingParams: true
+    }
+  },
+  "gpt-5.4-pro": {
+    reasoning: {
+      supportsEffort: true,
+      supportedRange: ["low", "medium", "high", "max"],
+      restrictsSamplingParams: true
+    }
+  },
   "gpt-5.2": {
     reasoning: {
       supportsEffort: true,

package/dist/compat.js

@@ -14,7 +14,7 @@ import {
   toOpenAIReasoningEffort,
   validateOpenAIReasoningConfig,
   wrapOpenAIError
-} from "./chunk-7CU5JW63.js";
+} from "./chunk-ZHHJ76M7.js";
 
 // src/compat/provider.ts
 import OpenAI from "openai";

package/dist/index.js

@@ -18,7 +18,7 @@ import {
   toOpenAIReasoningEffort,
   validateOpenAIReasoningConfig,
   wrapOpenAIError
-} from "./chunk-7CU5JW63.js";
+} from "./chunk-ZHHJ76M7.js";
 
 // src/provider.ts
 import OpenAI from "openai";
@@ -242,9 +242,7 @@ function mapGenerateResponse(response) {
       continue;
     }
     if (isOutputMessage(item)) {
-      for (const part of mapMessageTextParts(item)) {
-        parts.push(part);
-      }
+      parts.push(...mapMessageTextParts(item));
       continue;
     }
     if (isFunctionToolCall(item)) {
@@ -293,12 +291,16 @@ function mapMessageTextParts(message) {
   );
 }
 function getTextContent(parts) {
-  const text = parts.flatMap((part) => part.type === "text" ? [part.text] : []).join("");
-  return text.length > 0 ? text : null;
+  return getJoinedPartText(parts, "text");
 }
 function getReasoningText(parts) {
-  const reasoning = parts.flatMap((part) => part.type === "reasoning" ? [part.text] : []).join("");
-  return reasoning.length > 0 ? reasoning : null;
+  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(
@@ -335,6 +337,33 @@ function mapUsage(usage) {
     }
   };
 }
+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();
@@ -343,13 +372,19 @@ async function* transformStream(stream) {
   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);
-      if (!reasoningStarted) {
-        reasoningStarted = true;
-        yield { type: "reasoning-start" };
+      const reasoningStartTransition = getReasoningStartTransition(reasoningStarted);
+      reasoningStarted = reasoningStartTransition.nextReasoningStarted;
+      if (reasoningStartTransition.event) {
+        yield reasoningStartTransition.event;
       }
       yield {
         type: "reasoning-delta",
@@ -361,9 +396,10 @@ async function* transformStream(stream) {
       const key = `${event.item_id}:${event.summary_index}`;
       if (!seenSummaryDeltas.has(key) && event.text.length > 0) {
         emittedReasoningItems.add(event.item_id);
-        if (!reasoningStarted) {
-          reasoningStarted = true;
-          yield { type: "reasoning-start" };
+        const reasoningStartTransition = getReasoningStartTransition(reasoningStarted);
+        reasoningStarted = reasoningStartTransition.nextReasoningStarted;
+        if (reasoningStartTransition.event) {
+          yield reasoningStartTransition.event;
         }
         yield {
           type: "reasoning-delta",
@@ -384,32 +420,38 @@ async function* transformStream(stream) {
         continue;
       }
       const toolCallId = event.item.call_id;
-      bufferedToolCalls.set(event.output_index, {
-        id: toolCallId,
-        name: event.item.name,
-        arguments: event.item.arguments
-      });
-      if (!startedToolCalls.has(toolCallId)) {
+      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: event.item.name
+          toolName: toolCallName
         };
       }
       continue;
     }
     if (event.type === "response.function_call_arguments.delta") {
-      const currentToolCall = bufferedToolCalls.get(
-        event.output_index
-      ) ?? {
-        id: event.item_id,
-        name: "",
-        arguments: ""
-      };
-      currentToolCall.arguments += event.delta;
-      bufferedToolCalls.set(event.output_index, currentToolCall);
-      if (!startedToolCalls.has(currentToolCall.id)) {
+      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",
@@ -431,9 +473,10 @@ async function* transformStream(stream) {
             event.item.summary
           );
           if (summaryText.length > 0) {
-            if (!reasoningStarted) {
-              reasoningStarted = true;
-              yield { type: "reasoning-start" };
+            const reasoningStartTransition = getReasoningStartTransition(reasoningStarted);
+            reasoningStarted = reasoningStartTransition.nextReasoningStarted;
+            if (reasoningStartTransition.event) {
+              yield reasoningStartTransition.event;
             }
             yield {
               type: "reasoning-delta",
@@ -442,36 +485,41 @@ async function* transformStream(stream) {
           }
         }
         const encryptedContent = typeof event.item.encrypted_content === "string" && event.item.encrypted_content.length > 0 ? event.item.encrypted_content : void 0;
-        if (!reasoningStarted && encryptedContent) {
-          reasoningStarted = true;
-          yield { type: "reasoning-start" };
+        if (encryptedContent) {
+          const reasoningStartTransition = getReasoningStartTransition(reasoningStarted);
+          reasoningStarted = reasoningStartTransition.nextReasoningStarted;
+          if (reasoningStartTransition.event) {
+            yield reasoningStartTransition.event;
+          }
         }
-        if (reasoningStarted) {
-          reasoningStarted = false;
-          yield {
-            type: "reasoning-end",
-            providerMetadata: {
-              openai: {
-                ...encryptedContent ? { encryptedContent } : {}
-              }
+        const reasoningEndTransition2 = getReasoningEndTransition(
+          reasoningStarted,
+          {
+            openai: {
+              ...encryptedContent ? { encryptedContent } : {}
             }
-          };
+          }
+        );
+        reasoningStarted = reasoningEndTransition2.nextReasoningStarted;
+        if (reasoningEndTransition2.event) {
+          yield reasoningEndTransition2.event;
         }
         continue;
       }
       if (!isFunctionToolCall(event.item)) {
         continue;
       }
-      const currentToolCall = bufferedToolCalls.get(
-        event.output_index
-      ) ?? {
-        id: event.item.call_id,
-        name: event.item.name,
-        arguments: ""
-      };
-      currentToolCall.id = event.item.call_id;
-      currentToolCall.name = event.item.name;
-      currentToolCall.arguments = event.item.arguments || currentToolCall.arguments;
+      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 {
@@ -489,12 +537,13 @@ async function* transformStream(stream) {
     }
     if (event.type === "response.completed") {
       latestResponse = event.response;
-      if (reasoningStarted) {
-        reasoningStarted = false;
-        yield {
-          type: "reasoning-end",
-          providerMetadata: { openai: {} }
-        };
+      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)) {
@@ -521,8 +570,12 @@ async function* transformStream(stream) {
       return;
     }
   }
-  if (reasoningStarted) {
-    yield { type: "reasoning-end", providerMetadata: { openai: {} } };
+  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);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/openai",
-    "version": "0.6.0",
+    "version": "0.6.1",
     "description": "OpenAI provider package for @core-ai/core-ai",
     "license": "MIT",
     "author": "Omnifact (https://omnifact.ai)",
@@ -46,7 +46,7 @@
         "test:watch": "vitest"
     },
     "dependencies": {
-        "@core-ai/core-ai": "^0.6.0",
+        "@core-ai/core-ai": "^0.6.1",
         "openai": "^6.1.0",
         "zod-to-json-schema": "^3.25.1"
     },