ai 4.0.17 → 4.0.19

package/dist/index.mjs

@@ -837,13 +837,39 @@ var DefaultGenerateImageResult = class {
 // core/generate-object/generate-object.ts
 import { createIdGenerator, safeParseJSON } from "@ai-sdk/provider-utils";
 
-// util/download-error.ts
+// errors/no-object-generated-error.ts
 import { AISDKError as AISDKError3 } from "@ai-sdk/provider";
-var name3 = "AI_DownloadError";
+var name3 = "AI_NoObjectGeneratedError";
 var marker3 = `vercel.ai.error.${name3}`;
 var symbol3 = Symbol.for(marker3);
 var _a3;
-var DownloadError = class extends AISDKError3 {
+var NoObjectGeneratedError = class extends AISDKError3 {
+  constructor({
+    message = "No object generated.",
+    cause,
+    text: text2,
+    response,
+    usage
+  }) {
+    super({ name: name3, message, cause });
+    this[_a3] = true;
+    this.text = text2;
+    this.response = response;
+    this.usage = usage;
+  }
+  static isInstance(error) {
+    return AISDKError3.hasMarker(error, marker3);
+  }
+};
+_a3 = symbol3;
+
+// util/download-error.ts
+import { AISDKError as AISDKError4 } from "@ai-sdk/provider";
+var name4 = "AI_DownloadError";
+var marker4 = `vercel.ai.error.${name4}`;
+var symbol4 = Symbol.for(marker4);
+var _a4;
+var DownloadError = class extends AISDKError4 {
   constructor({
     url,
     statusCode,
@@ -851,17 +877,17 @@ var DownloadError = class extends AISDKError3 {
     cause,
     message = cause == null ? `Failed to download ${url}: ${statusCode} ${statusText}` : `Failed to download ${url}: ${cause}`
   }) {
-    super({ name: name3, message, cause });
-    this[_a3] = true;
+    super({ name: name4, message, cause });
+    this[_a4] = true;
     this.url = url;
     this.statusCode = statusCode;
     this.statusText = statusText;
   }
   static isInstance(error) {
-    return AISDKError3.hasMarker(error, marker3);
+    return AISDKError4.hasMarker(error, marker4);
   }
 };
-_a3 = symbol3;
+_a4 = symbol4;
 
 // util/download.ts
 async function download({
@@ -914,26 +940,26 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // core/prompt/invalid-data-content-error.ts
-import { AISDKError as AISDKError4 } from "@ai-sdk/provider";
-var name4 = "AI_InvalidDataContentError";
-var marker4 = `vercel.ai.error.${name4}`;
-var symbol4 = Symbol.for(marker4);
-var _a4;
-var InvalidDataContentError = class extends AISDKError4 {
+import { AISDKError as AISDKError5 } from "@ai-sdk/provider";
+var name5 = "AI_InvalidDataContentError";
+var marker5 = `vercel.ai.error.${name5}`;
+var symbol5 = Symbol.for(marker5);
+var _a5;
+var InvalidDataContentError = class extends AISDKError5 {
   constructor({
     content,
     cause,
     message = `Invalid data content. Expected a base64 string, Uint8Array, ArrayBuffer, or Buffer, but got ${typeof content}.`
   }) {
-    super({ name: name4, message, cause });
-    this[_a4] = true;
+    super({ name: name5, message, cause });
+    this[_a5] = true;
     this.content = content;
   }
   static isInstance(error) {
-    return AISDKError4.hasMarker(error, marker4);
+    return AISDKError5.hasMarker(error, marker5);
   }
 };
-_a4 = symbol4;
+_a5 = symbol5;
 
 // core/prompt/data-content.ts
 import { z } from "zod";
@@ -988,25 +1014,25 @@ function convertUint8ArrayToText(uint8Array) {
 }
 
 // core/prompt/invalid-message-role-error.ts
-import { AISDKError as AISDKError5 } from "@ai-sdk/provider";
-var name5 = "AI_InvalidMessageRoleError";
-var marker5 = `vercel.ai.error.${name5}`;
-var symbol5 = Symbol.for(marker5);
-var _a5;
-var InvalidMessageRoleError = class extends AISDKError5 {
+import { AISDKError as AISDKError6 } from "@ai-sdk/provider";
+var name6 = "AI_InvalidMessageRoleError";
+var marker6 = `vercel.ai.error.${name6}`;
+var symbol6 = Symbol.for(marker6);
+var _a6;
+var InvalidMessageRoleError = class extends AISDKError6 {
   constructor({
     role,
     message = `Invalid message role: '${role}'. Must be one of: "system", "user", "assistant", "tool".`
   }) {
-    super({ name: name5, message });
-    this[_a5] = true;
+    super({ name: name6, message });
+    this[_a6] = true;
     this.role = role;
   }
   static isInstance(error) {
-    return AISDKError5.hasMarker(error, marker5);
+    return AISDKError6.hasMarker(error, marker6);
   }
 };
-_a5 = symbol5;
+_a6 = symbol6;
 
 // core/prompt/split-data-url.ts
 function splitDataUrl(dataUrl) {
@@ -1529,25 +1555,25 @@ function attachmentsToParts(attachments) {
 }
 
 // core/prompt/message-conversion-error.ts
-import { AISDKError as AISDKError6 } from "@ai-sdk/provider";
-var name6 = "AI_MessageConversionError";
-var marker6 = `vercel.ai.error.${name6}`;
-var symbol6 = Symbol.for(marker6);
-var _a6;
-var MessageConversionError = class extends AISDKError6 {
+import { AISDKError as AISDKError7 } from "@ai-sdk/provider";
+var name7 = "AI_MessageConversionError";
+var marker7 = `vercel.ai.error.${name7}`;
+var symbol7 = Symbol.for(marker7);
+var _a7;
+var MessageConversionError = class extends AISDKError7 {
   constructor({
     originalMessage,
     message
   }) {
-    super({ name: name6, message });
-    this[_a6] = true;
+    super({ name: name7, message });
+    this[_a7] = true;
     this.originalMessage = originalMessage;
   }
   static isInstance(error) {
-    return AISDKError6.hasMarker(error, marker6);
+    return AISDKError7.hasMarker(error, marker7);
   }
 };
-_a6 = symbol6;
+_a7 = symbol7;
 
 // core/prompt/convert-to-core-messages.ts
 function convertToCoreMessages(messages, options) {
@@ -1718,6 +1744,13 @@ function calculateLanguageModelUsage({
     totalTokens: promptTokens + completionTokens
   };
 }
+function addLanguageModelUsage(usage1, usage2) {
+  return {
+    promptTokens: usage1.promptTokens + usage2.promptTokens,
+    completionTokens: usage1.completionTokens + usage2.completionTokens,
+    totalTokens: usage1.totalTokens + usage2.totalTokens
+  };
+}
 
 // core/generate-object/inject-json-instruction.ts
 var DEFAULT_SCHEMA_PREFIX = "JSON schema:";
@@ -1739,24 +1772,6 @@ function injectJsonInstruction({
   ].filter((line) => line != null).join("\n");
 }
 
-// core/generate-object/no-object-generated-error.ts
-import { AISDKError as AISDKError7 } from "@ai-sdk/provider";
-var name7 = "AI_NoObjectGeneratedError";
-var marker7 = `vercel.ai.error.${name7}`;
-var symbol7 = Symbol.for(marker7);
-var _a7;
-var NoObjectGeneratedError = class extends AISDKError7 {
-  // used in isInstance
-  constructor({ message = "No object generated." } = {}) {
-    super({ name: name7, message });
-    this[_a7] = true;
-  }
-  static isInstance(error) {
-    return AISDKError7.hasMarker(error, marker7);
-  }
-};
-_a7 = symbol7;
-
 // core/generate-object/output-strategy.ts
 import {
   isJSONArray,
@@ -1791,8 +1806,16 @@ var noSchemaOutputStrategy = {
   validatePartialResult({ value, textDelta }) {
     return { success: true, value: { partial: value, textDelta } };
   },
-  validateFinalResult(value) {
-    return value === void 0 ? { success: false, error: new NoObjectGeneratedError() } : { success: true, value };
+  validateFinalResult(value, context) {
+    return value === void 0 ? {
+      success: false,
+      error: new NoObjectGeneratedError({
+        message: "No object generated: response did not match schema.",
+        text: context.text,
+        response: context.response,
+        usage: context.usage
+      })
+    } : { success: true, value };
   },
   createElementStream() {
     throw new UnsupportedFunctionalityError({
@@ -2271,14 +2294,18 @@ async function generateObject({
                   abortSignal,
                   headers
                 });
-                if (result2.text === void 0) {
-                  throw new NoObjectGeneratedError();
-                }
                 const responseData = {
                   id: (_b2 = (_a14 = result2.response) == null ? void 0 : _a14.id) != null ? _b2 : generateId3(),
                   timestamp: (_d = (_c = result2.response) == null ? void 0 : _c.timestamp) != null ? _d : currentDate(),
                   modelId: (_f = (_e = result2.response) == null ? void 0 : _e.modelId) != null ? _f : model.modelId
                 };
+                if (result2.text === void 0) {
+                  throw new NoObjectGeneratedError({
+                    message: "No object generated: the model did not return a response.",
+                    response: responseData,
+                    usage: calculateLanguageModelUsage(result2.usage)
+                  });
+                }
                 span2.setAttributes(
                   selectTelemetryAttributes({
                     telemetry,
@@ -2375,14 +2402,18 @@ async function generateObject({
                   headers
                 });
                 const objectText = (_b2 = (_a14 = result2.toolCalls) == null ? void 0 : _a14[0]) == null ? void 0 : _b2.args;
-                if (objectText === void 0) {
-                  throw new NoObjectGeneratedError();
-                }
                 const responseData = {
                   id: (_d = (_c = result2.response) == null ? void 0 : _c.id) != null ? _d : generateId3(),
                   timestamp: (_f = (_e = result2.response) == null ? void 0 : _e.timestamp) != null ? _f : currentDate(),
                   modelId: (_h = (_g = result2.response) == null ? void 0 : _g.modelId) != null ? _h : model.modelId
                 };
+                if (objectText === void 0) {
+                  throw new NoObjectGeneratedError({
+                    message: "No object generated: the tool was not called.",
+                    response: responseData,
+                    usage: calculateLanguageModelUsage(result2.usage)
+                  });
+                }
                 span2.setAttributes(
                   selectTelemetryAttributes({
                     telemetry,
@@ -2430,13 +2461,30 @@ async function generateObject({
       }
       const parseResult = safeParseJSON({ text: result });
       if (!parseResult.success) {
-        throw parseResult.error;
+        throw new NoObjectGeneratedError({
+          message: "No object generated: could not parse the response.",
+          cause: parseResult.error,
+          text: result,
+          response,
+          usage: calculateLanguageModelUsage(usage)
+        });
       }
       const validationResult = outputStrategy.validateFinalResult(
-        parseResult.value
+        parseResult.value,
+        {
+          text: result,
+          response,
+          usage: calculateLanguageModelUsage(usage)
+        }
       );
       if (!validationResult.success) {
-        throw validationResult.error;
+        throw new NoObjectGeneratedError({
+          message: "No object generated: response did not match schema.",
+          cause: validationResult.error,
+          text: result,
+          response,
+          usage: calculateLanguageModelUsage(usage)
+        });
       }
       span.setAttributes(
         selectTelemetryAttributes({
@@ -2974,12 +3022,25 @@ var DefaultStreamObjectResult = class {
                     ...response,
                     headers: rawResponse == null ? void 0 : rawResponse.headers
                   });
-                  const validationResult = outputStrategy.validateFinalResult(latestObjectJson);
+                  const validationResult = outputStrategy.validateFinalResult(
+                    latestObjectJson,
+                    {
+                      text: accumulatedText,
+                      response,
+                      usage
+                    }
+                  );
                   if (validationResult.success) {
                     object2 = validationResult.value;
                     self.objectPromise.resolve(object2);
                   } else {
-                    error = validationResult.error;
+                    error = new NoObjectGeneratedError({
+                      message: "No object generated: response did not match schema.",
+                      cause: validationResult.error,
+                      text: accumulatedText,
+                      response,
+                      usage
+                    });
                     self.objectPromise.reject(error);
                   }
                   break;
@@ -3528,7 +3589,7 @@ async function generateText({
       const responseMessages = [];
       let text2 = "";
       const steps = [];
-      const usage = {
+      let usage = {
         completionTokens: 0,
         promptTokens: 0,
         totalTokens: 0
@@ -3655,9 +3716,7 @@ async function generateText({
         const currentUsage = calculateLanguageModelUsage(
           currentModelResponse.usage
         );
-        usage.completionTokens += currentUsage.completionTokens;
-        usage.promptTokens += currentUsage.promptTokens;
-        usage.totalTokens += currentUsage.totalTokens;
+        usage = addLanguageModelUsage(usage, currentUsage);
         let nextStepType = "done";
         if (++stepCount < maxSteps) {
           if (continueSteps && currentModelResponse.finishReason === "length" && // only use continue when there are no tool calls:
@@ -3737,7 +3796,13 @@ async function generateText({
       );
       return new DefaultGenerateTextResult({
         text: text2,
-        output: output == null ? void 0 : output.parseOutput({ text: text2 }),
+        output: output == null ? void 0 : output.parseOutput(
+          { text: text2 },
+          {
+            response: currentModelResponse.response,
+            usage
+          }
+        ),
         toolCalls: currentToolCalls,
         toolResults: currentToolResults,
         finishReason: currentModelResponse.finishReason,
@@ -3852,7 +3917,7 @@ __export(output_exports, {
   object: () => object,
   text: () => text
 });
-import { parseJSON } from "@ai-sdk/provider-utils";
+import { safeParseJSON as safeParseJSON3, safeValidateTypes as safeValidateTypes4 } from "@ai-sdk/provider-utils";
 import { asSchema as asSchema4 } from "@ai-sdk/ui-utils";
 var text = () => ({
   type: "text",
@@ -3880,8 +3945,31 @@ var object = ({
         schema: schema.jsonSchema
       });
     },
-    parseOutput({ text: text2 }) {
-      return parseJSON({ text: text2, schema });
+    parseOutput({ text: text2 }, context) {
+      const parseResult = safeParseJSON3({ text: text2 });
+      if (!parseResult.success) {
+        throw new NoObjectGeneratedError({
+          message: "No object generated: could not parse the response.",
+          cause: parseResult.error,
+          text: text2,
+          response: context.response,
+          usage: context.usage
+        });
+      }
+      const validationResult = safeValidateTypes4({
+        value: parseResult.value,
+        schema
+      });
+      if (!validationResult.success) {
+        throw new NoObjectGeneratedError({
+          message: "No object generated: response did not match schema.",
+          cause: validationResult.error,
+          text: text2,
+          response: context.response,
+          usage: context.usage
+        });
+      }
+      return validationResult.value;
     }
   };
 };
@@ -4286,10 +4374,168 @@ var DefaultStreamTextResult = class {
         message: "maxSteps must be at least 1"
       });
     }
+    let recordedStepText = "";
+    let recordedContinuationText = "";
+    let recordedFullText = "";
+    let recordedRequest = void 0;
+    const recordedResponse = {
+      id: generateId3(),
+      timestamp: currentDate(),
+      modelId: model.modelId,
+      messages: []
+    };
+    let recordedToolCalls = [];
+    let recordedToolResults = [];
+    let recordedFinishReason = void 0;
+    let recordedUsage = void 0;
+    let recordedProviderMetadata = void 0;
+    let stepType = "initial";
+    const recordedSteps = [];
+    let rootSpan;
+    const eventProcessor = new TransformStream({
+      async transform(chunk, controller) {
+        controller.enqueue(chunk);
+        if (chunk.type === "text-delta" || chunk.type === "tool-call" || chunk.type === "tool-result" || chunk.type === "tool-call-streaming-start" || chunk.type === "tool-call-delta") {
+          await (onChunk == null ? void 0 : onChunk({ chunk }));
+        }
+        if (chunk.type === "text-delta") {
+          recordedStepText += chunk.textDelta;
+          recordedContinuationText += chunk.textDelta;
+          recordedFullText += chunk.textDelta;
+        }
+        if (chunk.type === "tool-call") {
+          recordedToolCalls.push(chunk);
+        }
+        if (chunk.type === "tool-result") {
+          recordedToolResults.push(chunk);
+        }
+        if (chunk.type === "step-finish") {
+          const stepMessages = toResponseMessages({
+            text: recordedContinuationText,
+            tools: tools != null ? tools : {},
+            toolCalls: recordedToolCalls,
+            toolResults: recordedToolResults
+          });
+          const currentStep = recordedSteps.length;
+          let nextStepType = "done";
+          if (currentStep + 1 < maxSteps) {
+            if (continueSteps && chunk.finishReason === "length" && // only use continue when there are no tool calls:
+            recordedToolCalls.length === 0) {
+              nextStepType = "continue";
+            } else if (
+              // there are tool calls:
+              recordedToolCalls.length > 0 && // all current tool calls have results:
+              recordedToolResults.length === recordedToolCalls.length
+            ) {
+              nextStepType = "tool-result";
+            }
+          }
+          const currentStepResult = {
+            stepType,
+            text: recordedStepText,
+            toolCalls: recordedToolCalls,
+            toolResults: recordedToolResults,
+            finishReason: chunk.finishReason,
+            usage: chunk.usage,
+            warnings: chunk.warnings,
+            logprobs: chunk.logprobs,
+            request: chunk.request,
+            response: {
+              ...chunk.response,
+              messages: [...recordedResponse.messages, ...stepMessages]
+            },
+            experimental_providerMetadata: chunk.experimental_providerMetadata,
+            isContinued: chunk.isContinued
+          };
+          await (onStepFinish == null ? void 0 : onStepFinish(currentStepResult));
+          recordedSteps.push(currentStepResult);
+          recordedToolCalls = [];
+          recordedToolResults = [];
+          recordedStepText = "";
+          recordedRequest = chunk.request;
+          if (nextStepType !== "done") {
+            stepType = nextStepType;
+          }
+          if (nextStepType !== "continue") {
+            recordedResponse.messages.push(...stepMessages);
+            recordedContinuationText = "";
+          }
+        }
+        if (chunk.type === "finish") {
+          recordedResponse.id = chunk.response.id;
+          recordedResponse.timestamp = chunk.response.timestamp;
+          recordedResponse.modelId = chunk.response.modelId;
+          recordedResponse.headers = chunk.response.headers;
+          recordedUsage = chunk.usage;
+          recordedFinishReason = chunk.finishReason;
+          recordedProviderMetadata = chunk.experimental_providerMetadata;
+        }
+      },
+      async flush(controller) {
+        var _a13;
+        try {
+          const lastStep = recordedSteps[recordedSteps.length - 1];
+          if (lastStep) {
+            self.warningsPromise.resolve(lastStep.warnings);
+            self.requestPromise.resolve(lastStep.request);
+            self.responsePromise.resolve(lastStep.response);
+            self.toolCallsPromise.resolve(lastStep.toolCalls);
+            self.toolResultsPromise.resolve(lastStep.toolResults);
+            self.providerMetadataPromise.resolve(
+              lastStep.experimental_providerMetadata
+            );
+          }
+          const finishReason = recordedFinishReason != null ? recordedFinishReason : "unknown";
+          const usage = recordedUsage != null ? recordedUsage : {
+            completionTokens: NaN,
+            promptTokens: NaN,
+            totalTokens: NaN
+          };
+          self.finishReasonPromise.resolve(finishReason);
+          self.usagePromise.resolve(usage);
+          self.textPromise.resolve(recordedFullText);
+          self.stepsPromise.resolve(recordedSteps);
+          await (onFinish == null ? void 0 : onFinish({
+            finishReason,
+            logprobs: void 0,
+            usage,
+            text: recordedFullText,
+            toolCalls: lastStep.toolCalls,
+            toolResults: lastStep.toolResults,
+            request: (_a13 = lastStep.request) != null ? _a13 : {},
+            response: lastStep.response,
+            warnings: lastStep.warnings,
+            experimental_providerMetadata: lastStep.experimental_providerMetadata,
+            steps: recordedSteps
+          }));
+          rootSpan.setAttributes(
+            selectTelemetryAttributes({
+              telemetry,
+              attributes: {
+                "ai.response.finishReason": finishReason,
+                "ai.response.text": { output: () => recordedFullText },
+                "ai.response.toolCalls": {
+                  output: () => {
+                    var _a14;
+                    return ((_a14 = lastStep.toolCalls) == null ? void 0 : _a14.length) ? JSON.stringify(lastStep.toolCalls) : void 0;
+                  }
+                },
+                "ai.usage.promptTokens": usage.promptTokens,
+                "ai.usage.completionTokens": usage.completionTokens
+              }
+            })
+          );
+        } catch (error) {
+          controller.error(error);
+        } finally {
+          rootSpan.end();
+        }
+      }
+    });
     const stitchableStream = createStitchableStream();
     this.addStream = stitchableStream.addStream;
     this.closeStream = stitchableStream.close;
-    this.baseStream = transform ? stitchableStream.stream.pipeThrough(transform) : stitchableStream.stream;
+    this.baseStream = (transform ? stitchableStream.stream.pipeThrough(transform) : stitchableStream.stream).pipeThrough(eventProcessor);
     const { maxRetries, retry } = prepareRetries({
       maxRetries: maxRetriesArg
     });
@@ -4321,13 +4567,13 @@ var DefaultStreamTextResult = class {
       }),
       tracer,
       endWhenDone: false,
-      fn: async (rootSpan) => {
-        const stepResults = [];
+      fn: async (rootSpanArg) => {
+        rootSpan = rootSpanArg;
         async function streamStep({
           currentStep,
           responseMessages,
           usage,
-          stepType,
+          stepType: stepType2,
           previousStepText,
           hasLeadingWhitespace
         }) {
@@ -4433,7 +4679,7 @@ var DefaultStreamTextResult = class {
           let stepProviderMetadata;
           let stepFirstChunk = true;
           let stepText = "";
-          let fullStepText = stepType === "continue" ? previousStepText : "";
+          let fullStepText = stepType2 === "continue" ? previousStepText : "";
           let stepLogProbs;
           let stepResponse = {
             id: generateId3(),
@@ -4453,7 +4699,6 @@ var DefaultStreamTextResult = class {
             fullStepText += chunk.textDelta;
             chunkTextPublished = true;
             hasWhitespaceSuffix = chunk.textDelta.trimEnd() !== chunk.textDelta;
-            await (onChunk == null ? void 0 : onChunk({ chunk }));
           }
           self.addStream(
             transformedStream.pipeThrough(
@@ -4502,13 +4747,11 @@ var DefaultStreamTextResult = class {
                     case "tool-call": {
                       controller.enqueue(chunk);
                       stepToolCalls.push(chunk);
-                      await (onChunk == null ? void 0 : onChunk({ chunk }));
                       break;
                     }
                     case "tool-result": {
                       controller.enqueue(chunk);
                       stepToolResults.push(chunk);
-                      await (onChunk == null ? void 0 : onChunk({ chunk }));
                       break;
                     }
                     case "response-metadata": {
@@ -4535,7 +4778,6 @@ var DefaultStreamTextResult = class {
                     case "tool-call-streaming-start":
                     case "tool-call-delta": {
                       controller.enqueue(chunk);
-                      await (onChunk == null ? void 0 : onChunk({ chunk }));
                       break;
                     }
                     case "error": {
@@ -4566,7 +4808,7 @@ var DefaultStreamTextResult = class {
                     }
                   }
                   if (continueSteps && chunkBuffer.length > 0 && (nextStepType !== "continue" || // when the next step is a regular step, publish the buffer
-                  stepType === "continue" && !chunkTextPublished)) {
+                  stepType2 === "continue" && !chunkTextPublished)) {
                     await publishTextChunk({
                       controller,
                       chunk: {
@@ -4610,69 +4852,16 @@ var DefaultStreamTextResult = class {
                     usage: stepUsage,
                     experimental_providerMetadata: stepProviderMetadata,
                     logprobs: stepLogProbs,
-                    response: {
-                      ...stepResponse
-                    },
-                    isContinued: nextStepType === "continue"
-                  });
-                  if (stepType === "continue") {
-                    const lastMessage = responseMessages[responseMessages.length - 1];
-                    if (typeof lastMessage.content === "string") {
-                      lastMessage.content += stepText;
-                    } else {
-                      lastMessage.content.push({
-                        text: stepText,
-                        type: "text"
-                      });
-                    }
-                  } else {
-                    responseMessages.push(
-                      ...toResponseMessages({
-                        text: stepText,
-                        tools: tools != null ? tools : {},
-                        toolCalls: stepToolCalls,
-                        toolResults: stepToolResults
-                      })
-                    );
-                  }
-                  const currentStepResult = {
-                    stepType,
-                    text: stepText,
-                    toolCalls: stepToolCalls,
-                    toolResults: stepToolResults,
-                    finishReason: stepFinishReason,
-                    usage: stepUsage,
-                    warnings,
-                    logprobs: stepLogProbs,
                     request: stepRequest,
                     response: {
                       ...stepResponse,
-                      headers: rawResponse == null ? void 0 : rawResponse.headers,
-                      // deep clone msgs to avoid mutating past messages in multi-step:
-                      messages: JSON.parse(JSON.stringify(responseMessages))
+                      headers: rawResponse == null ? void 0 : rawResponse.headers
                     },
-                    experimental_providerMetadata: stepProviderMetadata,
+                    warnings,
                     isContinued: nextStepType === "continue"
-                  };
-                  stepResults.push(currentStepResult);
-                  await (onStepFinish == null ? void 0 : onStepFinish(currentStepResult));
-                  const combinedUsage = {
-                    promptTokens: usage.promptTokens + stepUsage.promptTokens,
-                    completionTokens: usage.completionTokens + stepUsage.completionTokens,
-                    totalTokens: usage.totalTokens + stepUsage.totalTokens
-                  };
-                  if (nextStepType !== "done") {
-                    await streamStep({
-                      currentStep: currentStep + 1,
-                      responseMessages,
-                      usage: combinedUsage,
-                      stepType: nextStepType,
-                      previousStepText: fullStepText,
-                      hasLeadingWhitespace: hasWhitespaceSuffix
-                    });
-                    return;
-                  }
-                  try {
+                  });
+                  const combinedUsage = addLanguageModelUsage(usage, stepUsage);
+                  if (nextStepType === "done") {
                     controller.enqueue({
                       type: "finish",
                       finishReason: stepFinishReason,
@@ -4680,63 +4869,40 @@ var DefaultStreamTextResult = class {
                       experimental_providerMetadata: stepProviderMetadata,
                       logprobs: stepLogProbs,
                       response: {
-                        ...stepResponse
+                        ...stepResponse,
+                        headers: rawResponse == null ? void 0 : rawResponse.headers
                       }
                     });
                     self.closeStream();
-                    rootSpan.setAttributes(
-                      selectTelemetryAttributes({
-                        telemetry,
-                        attributes: {
-                          "ai.response.finishReason": stepFinishReason,
-                          "ai.response.text": { output: () => fullStepText },
-                          "ai.response.toolCalls": {
-                            output: () => stepToolCallsJson
-                          },
-                          "ai.usage.promptTokens": combinedUsage.promptTokens,
-                          "ai.usage.completionTokens": combinedUsage.completionTokens
-                        }
-                      })
-                    );
-                    self.usagePromise.resolve(combinedUsage);
-                    self.finishReasonPromise.resolve(stepFinishReason);
-                    self.textPromise.resolve(fullStepText);
-                    self.toolCallsPromise.resolve(stepToolCalls);
-                    self.providerMetadataPromise.resolve(stepProviderMetadata);
-                    self.toolResultsPromise.resolve(stepToolResults);
-                    self.requestPromise.resolve(stepRequest);
-                    self.responsePromise.resolve({
-                      ...stepResponse,
-                      headers: rawResponse == null ? void 0 : rawResponse.headers,
-                      messages: responseMessages
-                    });
-                    self.stepsPromise.resolve(stepResults);
-                    self.warningsPromise.resolve(warnings != null ? warnings : []);
-                    await (onFinish == null ? void 0 : onFinish({
-                      finishReason: stepFinishReason,
-                      logprobs: stepLogProbs,
+                  } else {
+                    if (stepType2 === "continue") {
+                      const lastMessage = responseMessages[responseMessages.length - 1];
+                      if (typeof lastMessage.content === "string") {
+                        lastMessage.content += stepText;
+                      } else {
+                        lastMessage.content.push({
+                          text: stepText,
+                          type: "text"
+                        });
+                      }
+                    } else {
+                      responseMessages.push(
+                        ...toResponseMessages({
+                          text: stepText,
+                          tools: tools != null ? tools : {},
+                          toolCalls: stepToolCalls,
+                          toolResults: stepToolResults
+                        })
+                      );
+                    }
+                    await streamStep({
+                      currentStep: currentStep + 1,
+                      responseMessages,
                       usage: combinedUsage,
-                      text: fullStepText,
-                      toolCalls: stepToolCalls,
-                      // The tool results are inferred as a never[] type, because they are
-                      // optional and the execute method with an inferred result type is
-                      // optional as well. Therefore we need to cast the toolResults to any.
-                      // The type exposed to the users will be correctly inferred.
-                      toolResults: stepToolResults,
-                      request: stepRequest,
-                      response: {
-                        ...stepResponse,
-                        headers: rawResponse == null ? void 0 : rawResponse.headers,
-                        messages: responseMessages
-                      },
-                      warnings,
-                      experimental_providerMetadata: stepProviderMetadata,
-                      steps: stepResults
-                    }));
-                  } catch (error) {
-                    controller.error(error);
-                  } finally {
-                    rootSpan.end();
+                      stepType: nextStepType,
+                      previousStepText: fullStepText,
+                      hasLeadingWhitespace: hasWhitespaceSuffix
+                    });
                   }
                 }
               })