ai 7.0.69 → 7.0.70

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # ai
 
+## 7.0.70
+
+### Patch Changes
+
+- 9566914: Stop multi-step text generation for client tool approval even when a provider-executed tool has a deferred result.
+- b181020: fix: reject `streamObject` result promises and report failed completion when the provider stream errors
+- 7054073: Filter preliminary tool outputs when `ignoreIncompleteToolCalls` is enabled.
+- a828527: Prevent automatic tool execution when a model call ends with an unsafe finish reason.
+- d3cc3fe: Clear partial UI message parts when a WorkflowAgent model-call step is retried.
+- Updated dependencies [e6087c9]
+  - @ai-sdk/provider-utils@5.0.28
+  - @ai-sdk/gateway@4.0.56
+
 ## 7.0.69
 
 ### Patch Changes

package/dist/index.d.ts

@@ -2403,6 +2403,11 @@ type UIMessageChunk<METADATA = unknown, DATA_TYPES extends UIDataTypes = UIDataT
     type: 'start-step';
 } | {
     type: 'finish-step';
+} | {
+    /**
+     * Removes all message parts added during the current step.
+     */
+    type: 'reset-step';
 } | {
     type: 'start';
     messageId?: string;

package/dist/index.js

@@ -1143,7 +1143,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "7.0.69" : "0.0.0-test";
+var VERSION = true ? "7.0.70" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({
@@ -3139,6 +3139,11 @@ var DefaultGeneratedFileWithType = class extends DefaultGeneratedFile {
   }
 };
 
+// src/generate-text/is-tool-execution-allowed-finish-reason.ts
+function isToolExecutionAllowedFinishReason(finishReason) {
+  return finishReason === "stop" || finishReason === "tool-calls";
+}
+
 // src/generate-text/output.ts
 var output_exports = {};
 __export(output_exports, {
@@ -5838,7 +5843,9 @@ async function generateText({
                 (toolApprovalResponse) => toolApprovalResponse.approved === false
               );
               const toolExecutionMs = {};
-              if (stepExecutionTools != null) {
+              if (stepExecutionTools != null && isToolExecutionAllowedFinishReason(
+                currentModelResponse.finishReason.unified
+              )) {
                 const toolExecutionResults = await executeTools({
                   toolCalls: clientToolCalls.filter(
                     (toolCall) => !toolCall.invalid && !blockedToolCallIds.has(toolCall.toolCallId)
@@ -5974,10 +5981,9 @@ async function generateText({
           }
         }
       } while (
-        // Continue if:
-        // 1. There are client tool calls that have all been executed or denied, OR
-        // 2. There are pending deferred results from provider-executed tools
-        (clientToolCalls.length > 0 && clientToolOutputs.length + deniedToolApprovalResponses.length === clientToolCalls.length || pendingDeferredToolCalls.size > 0) && // continue until a stop condition is met:
+        // Continue only after all client tool calls have been executed or denied,
+        // and if there are client results or pending deferred provider results.
+        clientToolOutputs.length + deniedToolApprovalResponses.length === clientToolCalls.length && (clientToolCalls.length > 0 || pendingDeferredToolCalls.size > 0) && // continue until a stop condition is met:
         !await isStopConditionMet({ stopConditions, steps })
       );
       const lastStep = steps[steps.length - 1];
@@ -6711,6 +6717,9 @@ var uiMessageChunkSchema = lazySchema(
       z.looseObject({
         type: z.literal("finish-step")
       }),
+      z.looseObject({
+        type: z.literal("reset-step")
+      }),
       z.looseObject({
         type: z.literal("start"),
         messageId: z.string().optional(),
@@ -7364,6 +7373,20 @@ function processUIMessageStream({
               state.activeReasoningParts = createIdMap();
               break;
             }
+            case "reset-step": {
+              const currentStepParts = getCurrentStepParts();
+              state.activeTextParts = createIdMap();
+              state.activeReasoningParts = createIdMap();
+              state.partialToolCalls = createIdMap();
+              if (currentStepParts.length > 0) {
+                state.message.parts.splice(
+                  state.message.parts.length - currentStepParts.length,
+                  currentStepParts.length
+                );
+                write();
+              }
+              break;
+            }
             case "start": {
               if (chunk.messageId != null) {
                 state.message.id = chunk.messageId;
@@ -8169,6 +8192,9 @@ function executeToolsFromStream({
             return;
           }
           case "model-call-end": {
+            if (!isToolExecutionAllowedFinishReason(chunk.finishReason)) {
+              return;
+            }
             await Promise.all(
               toolCallsToExecute.map(async (toolCall) => {
                 try {
@@ -10043,10 +10069,9 @@ var DefaultStreamTextResult = class {
                   }
                   cleanupStepTimeouts();
                   if (
-                    // Continue if:
-                    // 1. There are client tool calls that have all been executed or denied, OR
-                    // 2. There are pending deferred results from provider-executed tools, OR
-                    (clientToolCalls.length > 0 && clientToolCalls.length === clientToolOutputs.length + deniedToolApprovalResponses.length || pendingDeferredToolCalls.size > 0) && // continue until a stop condition is met:
+                    // Continue only after all client tool calls have been executed or denied,
+                    // and if there are client results or pending deferred provider results.
+                    clientToolCalls.length === clientToolOutputs.length + deniedToolApprovalResponses.length && (clientToolCalls.length > 0 || pendingDeferredToolCalls.size > 0) && // continue until a stop condition is met:
                     !await isStopConditionMet({
                       stopConditions,
                       steps: recordedSteps
@@ -10789,7 +10814,7 @@ async function convertToModelMessages(messages, options) {
     messages = messages.map((message) => ({
       ...message,
       parts: message.parts.filter(
-        (part) => !isToolUIPart(part) || part.state === "approval-responded" || part.state === "output-available" || part.state === "output-error" || part.state === "output-denied"
+        (part) => !isToolUIPart(part) || part.state === "approval-responded" || part.state === "output-available" && part.preliminary !== true || part.state === "output-error" || part.state === "output-denied"
       )
     }));
   }
@@ -13366,6 +13391,12 @@ function simulateReadableStream({
 
 // src/generate-object/stream-object.ts
 var originalGenerateId5 = createIdGenerator7({ prefix: "aiobj", size: 24 });
+async function markPromiseAsHandled2(promise) {
+  try {
+    await promise;
+  } catch (e) {
+  }
+}
 function streamObject(options) {
   const {
     model,
@@ -13595,6 +13626,7 @@ var DefaultStreamObjectResult = class {
       let providerMetadata;
       let object3;
       let error;
+      let terminalError;
       let msToFirstChunk = void 0;
       let accumulatedText = "";
       let textDelta = "";
@@ -13660,16 +13692,27 @@ var DefaultStreamObjectResult = class {
                 };
                 break;
               }
+              case "error": {
+                if (terminalError === void 0) {
+                  const wrappedError = wrapGatewayError(chunk.error);
+                  terminalError = { error: wrappedError };
+                  error = wrappedError;
+                  finishReason = "error";
+                  self.rejectResultPromises(wrappedError);
+                }
+                controller.enqueue(chunk);
+                break;
+              }
               case "finish": {
                 if (textDelta !== "") {
                   controller.enqueue({ type: "text-delta", textDelta });
                 }
-                finishReason = chunk.finishReason.unified;
+                finishReason = terminalError === void 0 ? chunk.finishReason.unified : "error";
                 usage = asLanguageModelUsage(chunk.usage);
                 providerMetadata = chunk.providerMetadata;
                 controller.enqueue({
                   ...chunk,
-                  finishReason: chunk.finishReason.unified,
+                  finishReason,
                   usage,
                   response: fullResponse
                 });
@@ -13678,6 +13721,9 @@ var DefaultStreamObjectResult = class {
                   provider: model.provider,
                   model: model.modelId
                 });
+                if (terminalError !== void 0) {
+                  break;
+                }
                 self._usage.resolve(usage);
                 self._providerMetadata.resolve(providerMetadata);
                 self._warnings.resolve(warnings);
@@ -13765,9 +13811,19 @@ var DefaultStreamObjectResult = class {
           }
         })
       );
-      stitchableStream.addStream(transformedStream);
+      stitchableStream.addStream(transformedStream, {
+        onError(error2) {
+          const wrappedError = wrapGatewayError(error2);
+          self.rejectResultPromises(wrappedError);
+          void notify({
+            event: { error: wrappedError },
+            callbacks: onError
+          });
+        }
+      });
     })().catch(async (error) => {
       var _a23;
+      self.rejectResultPromises(error);
       await ((_a23 = telemetryDispatcher.onError) == null ? void 0 : _a23.call(telemetryDispatcher, { callId, error }));
       stitchableStream.addStream(
         new ReadableStream({
@@ -13782,6 +13838,24 @@ var DefaultStreamObjectResult = class {
     });
     this.outputStrategy = outputStrategy;
   }
+  rejectResultPromises(error) {
+    this.rejectResultPromise({ delayedPromise: this._object, error });
+    this.rejectResultPromise({ delayedPromise: this._usage, error });
+    this.rejectResultPromise({ delayedPromise: this._providerMetadata, error });
+    this.rejectResultPromise({ delayedPromise: this._warnings, error });
+    this.rejectResultPromise({ delayedPromise: this._request, error });
+    this.rejectResultPromise({ delayedPromise: this._response, error });
+    this.rejectResultPromise({ delayedPromise: this._finishReason, error });
+  }
+  rejectResultPromise({
+    delayedPromise,
+    error
+  }) {
+    if (delayedPromise.isPending()) {
+      delayedPromise.reject(error);
+      markPromiseAsHandled2(delayedPromise.promise);
+    }
+  }
   get object() {
     return this._object.promise;
   }