ai 7.0.0-beta.21 → 7.0.0-beta.23

package/src/generate-text/create-stream-text-part-transform.ts

@@ -1,18 +1,44 @@
 import { LanguageModelV4StreamPart } from '@ai-sdk/provider';
 import { ProviderMetadata } from '../types/provider-metadata';
+import { DefaultGeneratedFileWithType, GeneratedFile } from './generated-file';
 
 export type UglyTransformedStreamTextPart =
   | Exclude<
       LanguageModelV4StreamPart,
-      {
-        type: 'text-delta';
-      }
+      | {
+          type: 'text-delta';
+        }
+      | {
+          type: 'reasoning-delta';
+        }
+      | {
+          type: 'file';
+        }
+      | {
+          type: 'reasoning-file';
+        }
     >
   | {
       type: 'text-delta';
       id: string;
       providerMetadata?: ProviderMetadata;
       text: string;
+    }
+  | {
+      type: 'reasoning-delta';
+      id: string;
+      providerMetadata?: ProviderMetadata;
+      text: string;
+    }
+  | {
+      type: 'file';
+      file: GeneratedFile;
+      providerMetadata?: ProviderMetadata;
+    }
+  | {
+      type: 'reasoning-file';
+      file: GeneratedFile;
+      providerMetadata?: ProviderMetadata;
     };
 
 export function createStreamTextPartTransform() {
@@ -21,15 +47,41 @@ export function createStreamTextPartTransform() {
     UglyTransformedStreamTextPart
   >({
     async transform(chunk, controller) {
-      if (chunk.type === 'text-delta') {
-        controller.enqueue({
-          type: 'text-delta',
-          id: chunk.id,
-          text: chunk.delta,
-          providerMetadata: chunk.providerMetadata,
-        });
-      } else {
-        controller.enqueue(chunk);
+      switch (chunk.type) {
+        case 'text-delta':
+          controller.enqueue({
+            type: 'text-delta',
+            id: chunk.id,
+            text: chunk.delta,
+            providerMetadata: chunk.providerMetadata,
+          });
+          break;
+
+        case 'reasoning-delta':
+          controller.enqueue({
+            type: 'reasoning-delta',
+            id: chunk.id,
+            text: chunk.delta,
+            providerMetadata: chunk.providerMetadata,
+          });
+          break;
+
+        case 'file':
+        case 'reasoning-file': {
+          controller.enqueue({
+            type: chunk.type,
+            file: new DefaultGeneratedFileWithType({
+              data: chunk.data,
+              mediaType: chunk.mediaType,
+            }),
+            providerMetadata: chunk.providerMetadata,
+          });
+          break;
+        }
+
+        default:
+          controller.enqueue(chunk);
+          break;
       }
     },
   });

package/src/generate-text/run-tools-transformation.ts

@@ -13,7 +13,7 @@ import { Source } from '../types/language-model';
 import { asLanguageModelUsage } from '../types/usage';
 import { UglyTransformedStreamTextPart } from './create-stream-text-part-transform';
 import { executeToolCall } from './execute-tool-call';
-import { DefaultGeneratedFileWithType, GeneratedFile } from './generated-file';
+import { GeneratedFile } from './generated-file';
 import { isApprovalNeeded } from './is-approval-needed';
 import { parseToolCall } from './parse-tool-call';
 import {
@@ -153,7 +153,8 @@ export function runToolsTransformation<TOOLS extends ToolSet>({
     | Array<StreamTextOnToolCallFinishCallback<TOOLS> | undefined | null>;
   executeToolInTelemetryContext?: TelemetryIntegration['executeTool'];
 }): ReadableStream<SingleRequestTextStreamPart<TOOLS>> {
-  // tool results stream
+  // there is a separate stream for tool results, because
+  // tool results might be emitted after the generator stream has finished
   let toolResultsStreamController: ReadableStreamDefaultController<
     SingleRequestTextStreamPart<TOOLS>
   > | null = null;
@@ -168,10 +169,8 @@ export function runToolsTransformation<TOOLS extends ToolSet>({
   // keep track of outstanding tool results for stream closing:
   const outstandingToolResults = new Set<string>();
 
-  // keep track of tool inputs for provider-side tool results
-  const toolInputs = new Map<string, unknown>();
-
   // keep track of parsed tool calls so provider-emitted approval requests can reference them
+  // keep track of tool inputs for provider-side tool results
   const toolCallsByToolCallId = new Map<string, TypedToolCall<TOOLS>>();
 
   let canClose = false;
@@ -213,10 +212,13 @@ export function runToolsTransformation<TOOLS extends ToolSet>({
         case 'text-delta':
         case 'text-end':
         case 'reasoning-start':
+        case 'reasoning-delta':
         case 'reasoning-end':
         case 'tool-input-start':
         case 'tool-input-delta':
         case 'tool-input-end':
+        case 'file':
+        case 'reasoning-file':
         case 'source':
         case 'response-metadata':
         case 'error':
@@ -225,30 +227,6 @@ export function runToolsTransformation<TOOLS extends ToolSet>({
           break;
         }
 
-        case 'reasoning-delta':
-          controller.enqueue({
-            type: 'reasoning-delta',
-            id: chunk.id,
-            text: chunk.delta,
-            providerMetadata: chunk.providerMetadata,
-          });
-          break;
-
-        case 'file':
-        case 'reasoning-file': {
-          controller.enqueue({
-            type: chunk.type,
-            file: new DefaultGeneratedFileWithType({
-              data: chunk.data,
-              mediaType: chunk.mediaType,
-            }),
-            ...(chunk.providerMetadata != null
-              ? { providerMetadata: chunk.providerMetadata }
-              : {}),
-          });
-          break;
-        }
-
         case 'finish': {
           finishChunk = {
             type: 'finish',
@@ -342,8 +320,6 @@ export function runToolsTransformation<TOOLS extends ToolSet>({
               break;
             }
 
-            toolInputs.set(toolCall.toolCallId, toolCall.input);
-
             // Only execute tools that are not provider-executed:
             if (tool.execute != null && toolCall.providerExecuted !== true) {
               const toolExecutionId = generateId(); // use our own id to guarantee uniqueness
@@ -394,33 +370,34 @@ export function runToolsTransformation<TOOLS extends ToolSet>({
         case 'tool-result': {
           const toolName = chunk.toolName as keyof TOOLS & string;
 
-          if (chunk.isError) {
-            toolResultsStreamController!.enqueue({
-              type: 'tool-error',
-              toolCallId: chunk.toolCallId,
-              toolName,
-              input: toolInputs.get(chunk.toolCallId),
-              providerExecuted: true,
-              error: chunk.result,
-              dynamic: chunk.dynamic,
-              ...(chunk.providerMetadata != null
-                ? { providerMetadata: chunk.providerMetadata }
-                : {}),
-            } as TypedToolError<TOOLS>);
-          } else {
-            controller.enqueue({
-              type: 'tool-result',
-              toolCallId: chunk.toolCallId,
-              toolName,
-              input: toolInputs.get(chunk.toolCallId),
-              output: chunk.result,
-              providerExecuted: true,
-              dynamic: chunk.dynamic,
-              ...(chunk.providerMetadata != null
-                ? { providerMetadata: chunk.providerMetadata }
-                : {}),
-            } as TypedToolResult<TOOLS>);
-          }
+          controller.enqueue(
+            chunk.isError
+              ? ({
+                  type: 'tool-error',
+                  toolCallId: chunk.toolCallId,
+                  toolName,
+                  input: toolCallsByToolCallId.get(chunk.toolCallId)?.input,
+                  providerExecuted: true,
+                  error: chunk.result,
+                  dynamic: chunk.dynamic,
+                  ...(chunk.providerMetadata != null
+                    ? { providerMetadata: chunk.providerMetadata }
+                    : {}),
+                } as TypedToolError<TOOLS>)
+              : ({
+                  type: 'tool-result',
+                  toolCallId: chunk.toolCallId,
+                  toolName,
+                  input: toolCallsByToolCallId.get(chunk.toolCallId)?.input,
+                  output: chunk.result,
+                  providerExecuted: true,
+                  dynamic: chunk.dynamic,
+                  ...(chunk.providerMetadata != null
+                    ? { providerMetadata: chunk.providerMetadata }
+                    : {}),
+                } as TypedToolResult<TOOLS>),
+          );
+
           break;
         }
 

package/src/telemetry/open-telemetry-integration.ts

@@ -1,4 +1,4 @@
-import { LanguageModelV3Prompt } from '@ai-sdk/provider';
+import { LanguageModelV4Prompt } from '@ai-sdk/provider';
 import {
   context,
   trace,
@@ -99,7 +99,7 @@ interface OtelStepStartEvent<
   TOOLS extends ToolSet = ToolSet,
   OUTPUT extends Output = Output,
 > extends OnStepStartEvent<TOOLS, OUTPUT> {
-  readonly promptMessages?: LanguageModelV3Prompt;
+  readonly promptMessages?: LanguageModelV4Prompt;
   readonly stepTools?: ReadonlyArray<Record<string, unknown>>;
   readonly stepToolChoice?: unknown;
 }