ai 7.0.148 → 7.0.149

package/src/generate-text/stream-text.ts

@@ -2465,7 +2465,7 @@ class DefaultStreamTextResult<
             activeTools: prepareStepResult?.activeTools ?? activeTools,
           });
           const {
-            executionTools: stepExecutionTools,
+            executionTools,
             modelTools: stepModelTools,
             toolCallerMessages,
           } = prepareToolsForToolCallers({
@@ -2495,6 +2495,8 @@ class DefaultStreamTextResult<
           const stepToolChoice = prepareToolChoice({
             toolChoice: prepareStepResult?.toolChoice ?? toolChoice,
           });
+          const stepExecutionTools =
+            stepToolChoice.type === 'none' ? undefined : executionTools;
 
           const stepMessages = appendToolCallerMessages({
             messages: prepareStepResult?.messages ?? stepInputMessages,
@@ -3215,6 +3217,7 @@ class DefaultStreamTextResult<
                   cleanupStepTimeouts();
 
                   if (
+                    stepFinishReason !== 'interrupted' &&
                     // 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 ===

package/src/types/language-model.ts

@@ -70,6 +70,7 @@ export type LanguageModel =
  * - `content-filter`: content filter violation stopped the model
  * - `tool-calls`: model triggered tool calls
  * - `error`: model stopped because of an error
+ * - `interrupted`: provider stream ended without a completion signal; output may be incomplete
  * - `other`: model stopped for other reasons
  */
 export type FinishReason =
@@ -78,6 +79,7 @@ export type FinishReason =
   | 'content-filter'
   | 'tool-calls'
   | 'error'
+  | 'interrupted'
   | 'other';
 
 /**

package/src/ui/chat.ts

@@ -274,6 +274,9 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
 
   private pendingMessagePreparations = new Set<AbortController>();
   private pendingApprovalMessageId: string | undefined;
+  // Keep interruption state after activeResponse is cleared so late tool updates
+  // cannot automatically continue an interrupted message.
+  private interruptedMessageIds = new Set<string>();
   private activeResponse: ActiveResponse<UI_MESSAGE> | undefined = undefined;
   private activeResumeRequest: ActiveResumeRequest | undefined = undefined;
   private resumableStreamState:
@@ -638,7 +641,9 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
         this.status !== 'submitted' &&
         this.sendAutomaticallyWhen
       ) {
-        const shouldSend = await this.shouldSendAutomatically();
+        const shouldSend = await this.shouldSendAutomatically(
+          messages[messageIndex].id,
+        );
 
         if (shouldSend) {
           // no await to avoid deadlocking
@@ -735,7 +740,9 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
         this.status !== 'submitted' &&
         this.sendAutomaticallyWhen
       ) {
-        const shouldSend = await this.shouldSendAutomatically();
+        const shouldSend = await this.shouldSendAutomatically(
+          messages[messageIndex].id,
+        );
 
         if (shouldSend) {
           // no await to avoid deadlocking
@@ -794,19 +801,29 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
     this.transport.close?.();
   };
 
-  private async shouldSendAutomatically(): Promise<boolean> {
-    if (!this.sendAutomaticallyWhen) return false;
+  private async shouldSendAutomatically(
+    messageId = this.lastMessage?.id,
+  ): Promise<boolean> {
+    const isInterrupted = (id: string | undefined) =>
+      id != null && this.interruptedMessageIds.has(id);
 
-    const result = this.sendAutomaticallyWhen({
+    if (
+      !this.sendAutomaticallyWhen ||
+      isInterrupted(messageId) ||
+      isInterrupted(this.lastMessage?.id)
+    ) {
+      return false;
+    }
+
+    const result = await this.sendAutomaticallyWhen({
       messages: this.state.messages,
     });
 
-    // Check if result is a promise
-    if (result && typeof result === 'object' && 'then' in result) {
-      return await result;
-    }
-
-    return result as boolean;
+    return (
+      result &&
+      !isInterrupted(messageId) &&
+      !isInterrupted(this.lastMessage?.id)
+    );
   }
 
   private async runAutomaticRequest(
@@ -1182,6 +1199,13 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
     } finally {
       try {
         if (activeResponse) {
+          const { message, finishReason } = activeResponse.state;
+          if (finishReason === 'interrupted') {
+            this.interruptedMessageIds.add(message.id);
+          } else if (!isAbort && !isError) {
+            this.interruptedMessageIds.delete(message.id);
+          }
+
           this.onFinish?.({
             message: activeResponse.state.message,
             messages: this.state.messages,
@@ -1201,7 +1225,11 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
     }
 
     // automatically send the message if the sendAutomaticallyWhen function returns true
-    if (!isAbort && !isError) {
+    if (
+      !isAbort &&
+      !isError &&
+      activeResponse?.state.finishReason !== 'interrupted'
+    ) {
       await this.runAutomaticRequest(() =>
         this.makeRequest({
           trigger: 'submit-message',

package/src/ui-message-stream/ui-message-chunks.ts

@@ -206,6 +206,7 @@ export const uiMessageChunkSchema = lazySchema(() =>
             'content-filter',
             'tool-calls',
             'error',
+            'interrupted',
             'other',
           ] as const satisfies readonly FinishReason[])
           .optional(),