ai 5.0.278 → 5.0.280

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # ai
 
+## 5.0.280
+
+### Patch Changes
+
+- 1e4ab85: fix(ai): remove orphaned reasoning, including consecutive summary parts, when pruning tool calls
+- Updated dependencies [bd02a79]
+  - @ai-sdk/gateway@2.0.171
+
+## 5.0.279
+
+### Patch Changes
+
+- 11b886a: Stop forwarding buffered source stream parts after a transform calls `stopStream()`. This prevents text and errors from appearing after the transform emits its finish events.
+- Updated dependencies [d7b0ffa]
+- Updated dependencies [5a96038]
+- Updated dependencies [fd50c4d]
+- Updated dependencies [4146790]
+  - @ai-sdk/provider-utils@3.0.42
+  - @ai-sdk/gateway@2.0.170
+
 ## 5.0.278
 
 ### Patch Changes

package/dist/index.js

@@ -817,7 +817,7 @@ function detectMediaType({
 var import_provider_utils2 = require("@ai-sdk/provider-utils");
 
 // src/version.ts
-var VERSION = true ? "5.0.278" : "0.0.0-test";
+var VERSION = true ? "5.0.280" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({
@@ -5415,12 +5415,23 @@ var DefaultStreamTextResult = class {
         return stitchableStream.stream.cancel(reason);
       }
     });
+    let isRunning = true;
+    stream = stream.pipeThrough(
+      new TransformStream({
+        async transform(chunk, controller) {
+          if (isRunning) {
+            controller.enqueue(chunk);
+          }
+        }
+      })
+    );
     for (const transform of transforms) {
       stream = stream.pipeThrough(
         transform({
           tools,
           stopStream() {
             stitchableStream.terminate();
+            isRunning = false;
           }
         })
       );
@@ -8913,21 +8924,52 @@ function pruneMessages({
       if (message.role !== "assistant" && message.role !== "tool" || typeof message.content === "string" || keepLastMessagesCount && messageIndex >= messages.length - keepLastMessagesCount) {
         return message;
       }
-      const toolCallIdToToolName = {};
-      return {
-        ...message,
-        content: message.content.filter((part) => {
-          if (part.type !== "tool-call" && part.type !== "tool-result") {
-            return true;
+      const keepParts = message.content.map((part) => {
+        if (part.type !== "tool-call" && part.type !== "tool-result") {
+          return true;
+        }
+        if ((part.type === "tool-call" || part.type === "tool-result") && keptToolCallIds.has(part.toolCallId)) {
+          return true;
+        }
+        return toolCall.tools != null && !toolCall.tools.includes(part.toolName);
+      });
+      if (message.role === "assistant") {
+        for (let reasoningIndex = 0; reasoningIndex < message.content.length; reasoningIndex++) {
+          const part = message.content[reasoningIndex];
+          if (part.type !== "reasoning") {
+            continue;
           }
-          if (part.type === "tool-call") {
-            toolCallIdToToolName[part.toolCallId] = part.toolName;
+          let reasoningEndIndex = reasoningIndex + 1;
+          while (reasoningEndIndex < message.content.length) {
+            const nextPart = message.content[reasoningEndIndex];
+            if (nextPart.type !== "reasoning") {
+              break;
+            }
+            reasoningEndIndex++;
           }
-          if ((part.type === "tool-call" || part.type === "tool-result") && keptToolCallIds.has(part.toolCallId)) {
-            return true;
+          let followingPartIndex = reasoningEndIndex;
+          let hasFollowingPart = false;
+          let hasKeptFollowingPart = false;
+          while (followingPartIndex < message.content.length) {
+            const followingPart = message.content[followingPartIndex];
+            if (followingPart.type === "reasoning") {
+              break;
+            }
+            hasFollowingPart = true;
+            hasKeptFollowingPart || (hasKeptFollowingPart = keepParts[followingPartIndex]);
+            followingPartIndex++;
           }
-          return toolCall.tools != null && !toolCall.tools.includes(part.toolName);
-        })
+          if (hasFollowingPart && !hasKeptFollowingPart) {
+            for (let index = reasoningIndex; index < reasoningEndIndex; index++) {
+              keepParts[index] = false;
+            }
+          }
+          reasoningIndex = followingPartIndex - 1;
+        }
+      }
+      return {
+        ...message,
+        content: message.content.filter((_, index) => keepParts[index])
       };
     });
   }