ai 7.0.147 → 7.0.149

package/src/generate-text/stream-language-model-call.ts

@@ -448,6 +448,12 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
   let previousOutputChunkTimestampMs: number | undefined;
   const timeBetweenOutputChunksMs: number[] = [];
 
+  // Tool choice none rejects tool calls when the model call finishes.
+  // Withhold tool parts so that consumers (e.g. client-side tools) cannot
+  // act on them before the rejection, and skip user callbacks that would
+  // repair or refine them.
+  const withholdToolParts = toolChoice.type === 'none';
+
   return new TransformStream<
     LanguageModelV4StreamPart,
     LanguageModelStreamPart<TOOLS>
@@ -467,6 +473,15 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
         previousOutputChunkTimestampMs = outputChunkTimestampMs;
       }
 
+      if (
+        withholdToolParts &&
+        (chunk.type === 'tool-input-start' ||
+          chunk.type === 'tool-input-delta' ||
+          chunk.type === 'tool-input-end')
+      ) {
+        return;
+      }
+
       switch (chunk.type) {
         case 'error':
           controller.enqueue({
@@ -655,17 +670,18 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
           });
 
           const enforcedToolChoice =
-            toolChoice.type === 'required' || toolChoice.type === 'tool'
-              ? toolChoice
-              : undefined;
+            toolChoice.type === 'auto' ? undefined : toolChoice;
 
           const toolChoiceViolationError =
             enforcedToolChoice != null &&
-            ![...toolCallsByToolCallId.values()].some(
-              toolCall =>
-                enforcedToolChoice.type === 'required' ||
-                toolCall.toolName === enforcedToolChoice.toolName,
-            )
+            (enforcedToolChoice.type === 'none'
+              ? toolCallsByToolCallId.size > 0
+              : chunk.finishReason.unified !== 'interrupted' &&
+                ![...toolCallsByToolCallId.values()].some(
+                  toolCall =>
+                    enforcedToolChoice.type === 'required' ||
+                    toolCall.toolName === enforcedToolChoice.toolName,
+                ))
               ? new ToolChoiceViolationError({
                   toolChoice: enforcedToolChoice,
                   finishReason: chunk.finishReason.unified,
@@ -708,17 +724,22 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
             const toolCall = await parseToolCall({
               toolCall: chunk,
               tools,
-              repairToolCall,
-              refineToolInput,
+              repairToolCall: withholdToolParts ? undefined : repairToolCall,
+              refineToolInput: withholdToolParts ? undefined : refineToolInput,
               instructions,
               messages,
               abortSignal,
             });
 
             toolCallsByToolCallId.set(toolCall.toolCallId, toolCall);
-            controller.enqueue(toolCall);
             if (collectContent) modelCallContent.push(toolCall);
 
+            if (withholdToolParts) {
+              break;
+            }
+
+            controller.enqueue(toolCall);
+
             if (toolCall.invalid) {
               if (!toolCall.providerExecuted) {
                 controller.enqueue({
@@ -746,6 +767,10 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
         case 'tool-approval-request': {
           if (collectContent) rawModelCallContent.push(chunk);
 
+          if (withholdToolParts) {
+            break;
+          }
+
           const toolCall = toolCallsByToolCallId.get(chunk.toolCallId);
 
           if (toolCall == null) {
@@ -808,7 +833,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
                   : {}),
               } as TypedToolResult<TOOLS>);
 
-          controller.enqueue(toolResultPart);
+          if (!withholdToolParts) controller.enqueue(toolResultPart);
           if (collectContent) modelCallContent.push(toolResultPart);
 
           break;

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(),