ai 4.0.0-canary.9 → 4.0.1

package/dist/index.mjs

@@ -6,10 +6,12 @@ var __export = (target, all) => {
 
 // streams/index.ts
 import {
-  formatStreamPart as formatStreamPart4,
-  parseStreamPart,
-  readDataStream,
-  processDataProtocolResponse
+  formatAssistantStreamPart as formatAssistantStreamPart2,
+  formatDataStreamPart as formatDataStreamPart3,
+  parseAssistantStreamPart,
+  parseDataStreamPart,
+  processDataStream,
+  processTextStream
 } from "@ai-sdk/ui-utils";
 import { generateId as generateId2 } from "@ai-sdk/provider-utils";
 
@@ -2293,21 +2295,6 @@ import {
   parsePartialJson
 } from "@ai-sdk/ui-utils";
 
-// util/create-resolvable-promise.ts
-function createResolvablePromise() {
-  let resolve;
-  let reject;
-  const promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return {
-    promise,
-    resolve,
-    reject
-  };
-}
-
 // util/delayed-promise.ts
 var DelayedPromise = class {
   constructor() {
@@ -2399,9 +2386,91 @@ function writeToServerResponse({
   read();
 }
 
+// util/create-resolvable-promise.ts
+function createResolvablePromise() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    promise,
+    resolve,
+    reject
+  };
+}
+
+// core/util/create-stitchable-stream.ts
+function createStitchableStream() {
+  let innerStreamReaders = [];
+  let controller = null;
+  let isClosed = false;
+  let waitForNewStream = createResolvablePromise();
+  const processPull = async () => {
+    if (isClosed && innerStreamReaders.length === 0) {
+      controller == null ? void 0 : controller.close();
+      return;
+    }
+    if (innerStreamReaders.length === 0) {
+      waitForNewStream = createResolvablePromise();
+      await waitForNewStream.promise;
+      return processPull();
+    }
+    try {
+      const { value, done } = await innerStreamReaders[0].read();
+      if (done) {
+        innerStreamReaders.shift();
+        if (innerStreamReaders.length > 0) {
+          await processPull();
+        } else if (isClosed) {
+          controller == null ? void 0 : controller.close();
+        }
+      } else {
+        controller == null ? void 0 : controller.enqueue(value);
+      }
+    } catch (error) {
+      controller == null ? void 0 : controller.error(error);
+      innerStreamReaders.shift();
+      if (isClosed && innerStreamReaders.length === 0) {
+        controller == null ? void 0 : controller.close();
+      }
+    }
+  };
+  return {
+    stream: new ReadableStream({
+      start(controllerParam) {
+        controller = controllerParam;
+      },
+      pull: processPull,
+      async cancel() {
+        for (const reader of innerStreamReaders) {
+          await reader.cancel();
+        }
+        innerStreamReaders = [];
+        isClosed = true;
+      }
+    }),
+    addStream: (innerStream) => {
+      if (isClosed) {
+        throw new Error("Cannot add inner stream: outer stream is closed");
+      }
+      innerStreamReaders.push(innerStream.getReader());
+      waitForNewStream.resolve();
+    },
+    close: () => {
+      isClosed = true;
+      waitForNewStream.resolve();
+      if (innerStreamReaders.length === 0) {
+        controller == null ? void 0 : controller.close();
+      }
+    }
+  };
+}
+
 // core/generate-object/stream-object.ts
 var originalGenerateId2 = createIdGenerator2({ prefix: "aiobj", size: 24 });
-async function streamObject({
+function streamObject({
   model,
   schema: inputSchema,
   schemaName,
@@ -2435,400 +2504,433 @@ async function streamObject({
   if (outputStrategy.type === "no-schema" && mode === void 0) {
     mode = "json";
   }
-  const baseTelemetryAttributes = getBaseTelemetryAttributes({
+  return new DefaultStreamObjectResult({
     model,
     telemetry,
     headers,
-    settings: { ...settings, maxRetries }
+    settings,
+    maxRetries,
+    abortSignal,
+    outputStrategy,
+    system,
+    prompt,
+    messages,
+    schemaName,
+    schemaDescription,
+    inputProviderMetadata: providerMetadata,
+    mode,
+    onFinish,
+    generateId: generateId3,
+    currentDate,
+    now: now2
   });
-  const tracer = getTracer(telemetry);
-  const retry = retryWithExponentialBackoff({ maxRetries });
-  return recordSpan({
-    name: "ai.streamObject",
-    attributes: selectTelemetryAttributes({
+}
+var DefaultStreamObjectResult = class {
+  constructor({
+    model,
+    headers,
+    telemetry,
+    settings,
+    maxRetries,
+    abortSignal,
+    outputStrategy,
+    system,
+    prompt,
+    messages,
+    schemaName,
+    schemaDescription,
+    inputProviderMetadata,
+    mode,
+    onFinish,
+    generateId: generateId3,
+    currentDate,
+    now: now2
+  }) {
+    this.objectPromise = new DelayedPromise();
+    this.usagePromise = new DelayedPromise();
+    this.providerMetadataPromise = new DelayedPromise();
+    this.warningsPromise = new DelayedPromise();
+    this.requestPromise = new DelayedPromise();
+    this.responsePromise = new DelayedPromise();
+    this.stitchableStream = createStitchableStream();
+    const baseTelemetryAttributes = getBaseTelemetryAttributes({
+      model,
       telemetry,
-      attributes: {
-        ...assembleOperationName({
-          operationId: "ai.streamObject",
-          telemetry
-        }),
-        ...baseTelemetryAttributes,
-        // specific settings that only make sense on the outer level:
-        "ai.prompt": {
-          input: () => JSON.stringify({ system, prompt, messages })
-        },
-        "ai.schema": outputStrategy.jsonSchema != null ? { input: () => JSON.stringify(outputStrategy.jsonSchema) } : void 0,
-        "ai.schema.name": schemaName,
-        "ai.schema.description": schemaDescription,
-        "ai.settings.output": outputStrategy.type,
-        "ai.settings.mode": mode
-      }
-    }),
-    tracer,
-    endWhenDone: false,
-    fn: async (rootSpan) => {
-      if (mode === "auto" || mode == null) {
-        mode = model.defaultObjectGenerationMode;
-      }
-      let callOptions;
-      let transformer;
-      switch (mode) {
-        case "json": {
-          const standardizedPrompt = standardizePrompt({
-            prompt: {
-              system: outputStrategy.jsonSchema == null ? injectJsonInstruction({ prompt: system }) : model.supportsStructuredOutputs ? system : injectJsonInstruction({
-                prompt: system,
-                schema: outputStrategy.jsonSchema
+      headers,
+      settings: { ...settings, maxRetries }
+    });
+    const tracer = getTracer(telemetry);
+    const retry = retryWithExponentialBackoff({ maxRetries });
+    const self = this;
+    recordSpan({
+      name: "ai.streamObject",
+      attributes: selectTelemetryAttributes({
+        telemetry,
+        attributes: {
+          ...assembleOperationName({
+            operationId: "ai.streamObject",
+            telemetry
+          }),
+          ...baseTelemetryAttributes,
+          // specific settings that only make sense on the outer level:
+          "ai.prompt": {
+            input: () => JSON.stringify({ system, prompt, messages })
+          },
+          "ai.schema": outputStrategy.jsonSchema != null ? { input: () => JSON.stringify(outputStrategy.jsonSchema) } : void 0,
+          "ai.schema.name": schemaName,
+          "ai.schema.description": schemaDescription,
+          "ai.settings.output": outputStrategy.type,
+          "ai.settings.mode": mode
+        }
+      }),
+      tracer,
+      endWhenDone: false,
+      fn: async (rootSpan) => {
+        if (mode === "auto" || mode == null) {
+          mode = model.defaultObjectGenerationMode;
+        }
+        let callOptions;
+        let transformer;
+        switch (mode) {
+          case "json": {
+            const standardizedPrompt = standardizePrompt({
+              prompt: {
+                system: outputStrategy.jsonSchema == null ? injectJsonInstruction({ prompt: system }) : model.supportsStructuredOutputs ? system : injectJsonInstruction({
+                  prompt: system,
+                  schema: outputStrategy.jsonSchema
+                }),
+                prompt,
+                messages
+              },
+              tools: void 0
+            });
+            callOptions = {
+              mode: {
+                type: "object-json",
+                schema: outputStrategy.jsonSchema,
+                name: schemaName,
+                description: schemaDescription
+              },
+              ...prepareCallSettings(settings),
+              inputFormat: standardizedPrompt.type,
+              prompt: await convertToLanguageModelPrompt({
+                prompt: standardizedPrompt,
+                modelSupportsImageUrls: model.supportsImageUrls,
+                modelSupportsUrl: model.supportsUrl
               }),
-              prompt,
-              messages
-            },
-            tools: void 0
-          });
-          callOptions = {
-            mode: {
-              type: "object-json",
-              schema: outputStrategy.jsonSchema,
-              name: schemaName,
-              description: schemaDescription
-            },
-            ...prepareCallSettings(settings),
-            inputFormat: standardizedPrompt.type,
-            prompt: await convertToLanguageModelPrompt({
-              prompt: standardizedPrompt,
-              modelSupportsImageUrls: model.supportsImageUrls,
-              modelSupportsUrl: model.supportsUrl
-            }),
-            providerMetadata,
-            abortSignal,
-            headers
-          };
-          transformer = {
-            transform: (chunk, controller) => {
-              switch (chunk.type) {
-                case "text-delta":
-                  controller.enqueue(chunk.textDelta);
-                  break;
-                case "response-metadata":
-                case "finish":
-                case "error":
-                  controller.enqueue(chunk);
-                  break;
+              providerMetadata: inputProviderMetadata,
+              abortSignal,
+              headers
+            };
+            transformer = {
+              transform: (chunk, controller) => {
+                switch (chunk.type) {
+                  case "text-delta":
+                    controller.enqueue(chunk.textDelta);
+                    break;
+                  case "response-metadata":
+                  case "finish":
+                  case "error":
+                    controller.enqueue(chunk);
+                    break;
+                }
               }
-            }
-          };
-          break;
+            };
+            break;
+          }
+          case "tool": {
+            const standardizedPrompt = standardizePrompt({
+              prompt: { system, prompt, messages },
+              tools: void 0
+            });
+            callOptions = {
+              mode: {
+                type: "object-tool",
+                tool: {
+                  type: "function",
+                  name: schemaName != null ? schemaName : "json",
+                  description: schemaDescription != null ? schemaDescription : "Respond with a JSON object.",
+                  parameters: outputStrategy.jsonSchema
+                }
+              },
+              ...prepareCallSettings(settings),
+              inputFormat: standardizedPrompt.type,
+              prompt: await convertToLanguageModelPrompt({
+                prompt: standardizedPrompt,
+                modelSupportsImageUrls: model.supportsImageUrls,
+                modelSupportsUrl: model.supportsUrl
+              }),
+              providerMetadata: inputProviderMetadata,
+              abortSignal,
+              headers
+            };
+            transformer = {
+              transform(chunk, controller) {
+                switch (chunk.type) {
+                  case "tool-call-delta":
+                    controller.enqueue(chunk.argsTextDelta);
+                    break;
+                  case "response-metadata":
+                  case "finish":
+                  case "error":
+                    controller.enqueue(chunk);
+                    break;
+                }
+              }
+            };
+            break;
+          }
+          case void 0: {
+            throw new Error(
+              "Model does not have a default object generation mode."
+            );
+          }
+          default: {
+            const _exhaustiveCheck = mode;
+            throw new Error(`Unsupported mode: ${_exhaustiveCheck}`);
+          }
         }
-        case "tool": {
-          const standardizedPrompt = standardizePrompt({
-            prompt: { system, prompt, messages },
-            tools: void 0
-          });
-          callOptions = {
-            mode: {
-              type: "object-tool",
-              tool: {
-                type: "function",
-                name: schemaName != null ? schemaName : "json",
-                description: schemaDescription != null ? schemaDescription : "Respond with a JSON object.",
-                parameters: outputStrategy.jsonSchema
+        const {
+          result: { stream, warnings, rawResponse, request },
+          doStreamSpan,
+          startTimestampMs
+        } = await retry(
+          () => recordSpan({
+            name: "ai.streamObject.doStream",
+            attributes: selectTelemetryAttributes({
+              telemetry,
+              attributes: {
+                ...assembleOperationName({
+                  operationId: "ai.streamObject.doStream",
+                  telemetry
+                }),
+                ...baseTelemetryAttributes,
+                "ai.prompt.format": {
+                  input: () => callOptions.inputFormat
+                },
+                "ai.prompt.messages": {
+                  input: () => JSON.stringify(callOptions.prompt)
+                },
+                "ai.settings.mode": mode,
+                // standardized gen-ai llm span attributes:
+                "gen_ai.system": model.provider,
+                "gen_ai.request.model": model.modelId,
+                "gen_ai.request.frequency_penalty": settings.frequencyPenalty,
+                "gen_ai.request.max_tokens": settings.maxTokens,
+                "gen_ai.request.presence_penalty": settings.presencePenalty,
+                "gen_ai.request.temperature": settings.temperature,
+                "gen_ai.request.top_k": settings.topK,
+                "gen_ai.request.top_p": settings.topP
               }
-            },
-            ...prepareCallSettings(settings),
-            inputFormat: standardizedPrompt.type,
-            prompt: await convertToLanguageModelPrompt({
-              prompt: standardizedPrompt,
-              modelSupportsImageUrls: model.supportsImageUrls,
-              modelSupportsUrl: model.supportsUrl
             }),
-            providerMetadata,
-            abortSignal,
-            headers
-          };
-          transformer = {
-            transform(chunk, controller) {
+            tracer,
+            endWhenDone: false,
+            fn: async (doStreamSpan2) => ({
+              startTimestampMs: now2(),
+              doStreamSpan: doStreamSpan2,
+              result: await model.doStream(callOptions)
+            })
+          })
+        );
+        self.requestPromise.resolve(request != null ? request : {});
+        let usage;
+        let finishReason;
+        let providerMetadata;
+        let object;
+        let error;
+        let accumulatedText = "";
+        let textDelta = "";
+        let response = {
+          id: generateId3(),
+          timestamp: currentDate(),
+          modelId: model.modelId
+        };
+        let latestObjectJson = void 0;
+        let latestObject = void 0;
+        let isFirstChunk = true;
+        let isFirstDelta = true;
+        const transformedStream = stream.pipeThrough(new TransformStream(transformer)).pipeThrough(
+          new TransformStream({
+            async transform(chunk, controller) {
+              var _a11, _b, _c;
+              if (isFirstChunk) {
+                const msToFirstChunk = now2() - startTimestampMs;
+                isFirstChunk = false;
+                doStreamSpan.addEvent("ai.stream.firstChunk", {
+                  "ai.stream.msToFirstChunk": msToFirstChunk
+                });
+                doStreamSpan.setAttributes({
+                  "ai.stream.msToFirstChunk": msToFirstChunk
+                });
+              }
+              if (typeof chunk === "string") {
+                accumulatedText += chunk;
+                textDelta += chunk;
+                const { value: currentObjectJson, state: parseState } = parsePartialJson(accumulatedText);
+                if (currentObjectJson !== void 0 && !isDeepEqualData(latestObjectJson, currentObjectJson)) {
+                  const validationResult = outputStrategy.validatePartialResult({
+                    value: currentObjectJson,
+                    textDelta,
+                    latestObject,
+                    isFirstDelta,
+                    isFinalDelta: parseState === "successful-parse"
+                  });
+                  if (validationResult.success && !isDeepEqualData(
+                    latestObject,
+                    validationResult.value.partial
+                  )) {
+                    latestObjectJson = currentObjectJson;
+                    latestObject = validationResult.value.partial;
+                    controller.enqueue({
+                      type: "object",
+                      object: latestObject
+                    });
+                    controller.enqueue({
+                      type: "text-delta",
+                      textDelta: validationResult.value.textDelta
+                    });
+                    textDelta = "";
+                    isFirstDelta = false;
+                  }
+                }
+                return;
+              }
               switch (chunk.type) {
-                case "tool-call-delta":
-                  controller.enqueue(chunk.argsTextDelta);
+                case "response-metadata": {
+                  response = {
+                    id: (_a11 = chunk.id) != null ? _a11 : response.id,
+                    timestamp: (_b = chunk.timestamp) != null ? _b : response.timestamp,
+                    modelId: (_c = chunk.modelId) != null ? _c : response.modelId
+                  };
                   break;
-                case "response-metadata":
-                case "finish":
-                case "error":
+                }
+                case "finish": {
+                  if (textDelta !== "") {
+                    controller.enqueue({ type: "text-delta", textDelta });
+                  }
+                  finishReason = chunk.finishReason;
+                  usage = calculateLanguageModelUsage(chunk.usage);
+                  providerMetadata = chunk.providerMetadata;
+                  controller.enqueue({ ...chunk, usage, response });
+                  self.usagePromise.resolve(usage);
+                  self.providerMetadataPromise.resolve(providerMetadata);
+                  self.responsePromise.resolve({
+                    ...response,
+                    headers: rawResponse == null ? void 0 : rawResponse.headers
+                  });
+                  const validationResult = outputStrategy.validateFinalResult(latestObjectJson);
+                  if (validationResult.success) {
+                    object = validationResult.value;
+                    self.objectPromise.resolve(object);
+                  } else {
+                    error = validationResult.error;
+                    self.objectPromise.reject(error);
+                  }
+                  break;
+                }
+                default: {
                   controller.enqueue(chunk);
                   break;
+                }
+              }
+            },
+            // invoke onFinish callback and resolve toolResults promise when the stream is about to close:
+            async flush(controller) {
+              try {
+                const finalUsage = usage != null ? usage : {
+                  promptTokens: NaN,
+                  completionTokens: NaN,
+                  totalTokens: NaN
+                };
+                doStreamSpan.setAttributes(
+                  selectTelemetryAttributes({
+                    telemetry,
+                    attributes: {
+                      "ai.response.finishReason": finishReason,
+                      "ai.response.object": {
+                        output: () => JSON.stringify(object)
+                      },
+                      "ai.response.id": response.id,
+                      "ai.response.model": response.modelId,
+                      "ai.response.timestamp": response.timestamp.toISOString(),
+                      "ai.usage.promptTokens": finalUsage.promptTokens,
+                      "ai.usage.completionTokens": finalUsage.completionTokens,
+                      // standardized gen-ai llm span attributes:
+                      "gen_ai.response.finish_reasons": [finishReason],
+                      "gen_ai.response.id": response.id,
+                      "gen_ai.response.model": response.modelId,
+                      "gen_ai.usage.input_tokens": finalUsage.promptTokens,
+                      "gen_ai.usage.output_tokens": finalUsage.completionTokens
+                    }
+                  })
+                );
+                doStreamSpan.end();
+                rootSpan.setAttributes(
+                  selectTelemetryAttributes({
+                    telemetry,
+                    attributes: {
+                      "ai.usage.promptTokens": finalUsage.promptTokens,
+                      "ai.usage.completionTokens": finalUsage.completionTokens,
+                      "ai.response.object": {
+                        output: () => JSON.stringify(object)
+                      }
+                    }
+                  })
+                );
+                await (onFinish == null ? void 0 : onFinish({
+                  usage: finalUsage,
+                  object,
+                  error,
+                  response: {
+                    ...response,
+                    headers: rawResponse == null ? void 0 : rawResponse.headers
+                  },
+                  warnings,
+                  experimental_providerMetadata: providerMetadata
+                }));
+              } catch (error2) {
+                controller.error(error2);
+              } finally {
+                rootSpan.end();
               }
             }
-          };
-          break;
-        }
-        case void 0: {
-          throw new Error(
-            "Model does not have a default object generation mode."
-          );
-        }
-        default: {
-          const _exhaustiveCheck = mode;
-          throw new Error(`Unsupported mode: ${_exhaustiveCheck}`);
-        }
-      }
-      const {
-        result: { stream, warnings, rawResponse, request },
-        doStreamSpan,
-        startTimestampMs
-      } = await retry(
-        () => recordSpan({
-          name: "ai.streamObject.doStream",
-          attributes: selectTelemetryAttributes({
-            telemetry,
-            attributes: {
-              ...assembleOperationName({
-                operationId: "ai.streamObject.doStream",
-                telemetry
-              }),
-              ...baseTelemetryAttributes,
-              "ai.prompt.format": {
-                input: () => callOptions.inputFormat
-              },
-              "ai.prompt.messages": {
-                input: () => JSON.stringify(callOptions.prompt)
-              },
-              "ai.settings.mode": mode,
-              // standardized gen-ai llm span attributes:
-              "gen_ai.system": model.provider,
-              "gen_ai.request.model": model.modelId,
-              "gen_ai.request.frequency_penalty": settings.frequencyPenalty,
-              "gen_ai.request.max_tokens": settings.maxTokens,
-              "gen_ai.request.presence_penalty": settings.presencePenalty,
-              "gen_ai.request.temperature": settings.temperature,
-              "gen_ai.request.top_k": settings.topK,
-              "gen_ai.request.top_p": settings.topP
-            }
-          }),
-          tracer,
-          endWhenDone: false,
-          fn: async (doStreamSpan2) => ({
-            startTimestampMs: now2(),
-            doStreamSpan: doStreamSpan2,
-            result: await model.doStream(callOptions)
           })
+        );
+        self.stitchableStream.addStream(transformedStream);
+      }
+    }).catch((error) => {
+      self.stitchableStream.addStream(
+        new ReadableStream({
+          start(controller) {
+            controller.error(error);
+          }
         })
       );
-      return new DefaultStreamObjectResult({
-        outputStrategy,
-        stream: stream.pipeThrough(new TransformStream(transformer)),
-        warnings,
-        rawResponse,
-        request: request != null ? request : {},
-        onFinish,
-        rootSpan,
-        doStreamSpan,
-        telemetry,
-        startTimestampMs,
-        modelId: model.modelId,
-        now: now2,
-        currentDate,
-        generateId: generateId3
-      });
-    }
-  });
-}
-var DefaultStreamObjectResult = class {
-  constructor({
-    stream,
-    warnings,
-    rawResponse,
-    request,
-    outputStrategy,
-    onFinish,
-    rootSpan,
-    doStreamSpan,
-    telemetry,
-    startTimestampMs,
-    modelId,
-    now: now2,
-    currentDate,
-    generateId: generateId3
-  }) {
-    this.warnings = warnings;
+    }).finally(() => {
+      self.stitchableStream.close();
+    });
     this.outputStrategy = outputStrategy;
-    this.request = Promise.resolve(request);
-    this.objectPromise = new DelayedPromise();
-    const { resolve: resolveUsage, promise: usagePromise } = createResolvablePromise();
-    this.usage = usagePromise;
-    const { resolve: resolveResponse, promise: responsePromise } = createResolvablePromise();
-    this.response = responsePromise;
-    const {
-      resolve: resolveProviderMetadata,
-      promise: providerMetadataPromise
-    } = createResolvablePromise();
-    this.experimental_providerMetadata = providerMetadataPromise;
-    let usage;
-    let finishReason;
-    let providerMetadata;
-    let object;
-    let error;
-    let accumulatedText = "";
-    let textDelta = "";
-    let response = {
-      id: generateId3(),
-      timestamp: currentDate(),
-      modelId
-    };
-    let latestObjectJson = void 0;
-    let latestObject = void 0;
-    let isFirstChunk = true;
-    let isFirstDelta = true;
-    const self = this;
-    this.originalStream = stream.pipeThrough(
-      new TransformStream({
-        async transform(chunk, controller) {
-          var _a11, _b, _c;
-          if (isFirstChunk) {
-            const msToFirstChunk = now2() - startTimestampMs;
-            isFirstChunk = false;
-            doStreamSpan.addEvent("ai.stream.firstChunk", {
-              "ai.stream.msToFirstChunk": msToFirstChunk
-            });
-            doStreamSpan.setAttributes({
-              "ai.stream.msToFirstChunk": msToFirstChunk
-            });
-          }
-          if (typeof chunk === "string") {
-            accumulatedText += chunk;
-            textDelta += chunk;
-            const { value: currentObjectJson, state: parseState } = parsePartialJson(accumulatedText);
-            if (currentObjectJson !== void 0 && !isDeepEqualData(latestObjectJson, currentObjectJson)) {
-              const validationResult = outputStrategy.validatePartialResult({
-                value: currentObjectJson,
-                textDelta,
-                latestObject,
-                isFirstDelta,
-                isFinalDelta: parseState === "successful-parse"
-              });
-              if (validationResult.success && !isDeepEqualData(latestObject, validationResult.value.partial)) {
-                latestObjectJson = currentObjectJson;
-                latestObject = validationResult.value.partial;
-                controller.enqueue({
-                  type: "object",
-                  object: latestObject
-                });
-                controller.enqueue({
-                  type: "text-delta",
-                  textDelta: validationResult.value.textDelta
-                });
-                textDelta = "";
-                isFirstDelta = false;
-              }
-            }
-            return;
-          }
-          switch (chunk.type) {
-            case "response-metadata": {
-              response = {
-                id: (_a11 = chunk.id) != null ? _a11 : response.id,
-                timestamp: (_b = chunk.timestamp) != null ? _b : response.timestamp,
-                modelId: (_c = chunk.modelId) != null ? _c : response.modelId
-              };
-              break;
-            }
-            case "finish": {
-              if (textDelta !== "") {
-                controller.enqueue({ type: "text-delta", textDelta });
-              }
-              finishReason = chunk.finishReason;
-              usage = calculateLanguageModelUsage(chunk.usage);
-              providerMetadata = chunk.providerMetadata;
-              controller.enqueue({ ...chunk, usage, response });
-              resolveUsage(usage);
-              resolveProviderMetadata(providerMetadata);
-              resolveResponse({
-                ...response,
-                headers: rawResponse == null ? void 0 : rawResponse.headers
-              });
-              const validationResult = outputStrategy.validateFinalResult(latestObjectJson);
-              if (validationResult.success) {
-                object = validationResult.value;
-                self.objectPromise.resolve(object);
-              } else {
-                error = validationResult.error;
-                self.objectPromise.reject(error);
-              }
-              break;
-            }
-            default: {
-              controller.enqueue(chunk);
-              break;
-            }
-          }
-        },
-        // invoke onFinish callback and resolve toolResults promise when the stream is about to close:
-        async flush(controller) {
-          try {
-            const finalUsage = usage != null ? usage : {
-              promptTokens: NaN,
-              completionTokens: NaN,
-              totalTokens: NaN
-            };
-            doStreamSpan.setAttributes(
-              selectTelemetryAttributes({
-                telemetry,
-                attributes: {
-                  "ai.response.finishReason": finishReason,
-                  "ai.response.object": {
-                    output: () => JSON.stringify(object)
-                  },
-                  "ai.response.id": response.id,
-                  "ai.response.model": response.modelId,
-                  "ai.response.timestamp": response.timestamp.toISOString(),
-                  "ai.usage.promptTokens": finalUsage.promptTokens,
-                  "ai.usage.completionTokens": finalUsage.completionTokens,
-                  // standardized gen-ai llm span attributes:
-                  "gen_ai.response.finish_reasons": [finishReason],
-                  "gen_ai.response.id": response.id,
-                  "gen_ai.response.model": response.modelId,
-                  "gen_ai.usage.input_tokens": finalUsage.promptTokens,
-                  "gen_ai.usage.output_tokens": finalUsage.completionTokens
-                }
-              })
-            );
-            doStreamSpan.end();
-            rootSpan.setAttributes(
-              selectTelemetryAttributes({
-                telemetry,
-                attributes: {
-                  "ai.usage.promptTokens": finalUsage.promptTokens,
-                  "ai.usage.completionTokens": finalUsage.completionTokens,
-                  "ai.response.object": {
-                    output: () => JSON.stringify(object)
-                  }
-                }
-              })
-            );
-            await (onFinish == null ? void 0 : onFinish({
-              usage: finalUsage,
-              object,
-              error,
-              response: {
-                ...response,
-                headers: rawResponse == null ? void 0 : rawResponse.headers
-              },
-              warnings,
-              experimental_providerMetadata: providerMetadata
-            }));
-          } catch (error2) {
-            controller.error(error2);
-          } finally {
-            rootSpan.end();
-          }
-        }
-      })
-    );
   }
   get object() {
     return this.objectPromise.value;
   }
+  get usage() {
+    return this.usagePromise.value;
+  }
+  get experimental_providerMetadata() {
+    return this.providerMetadataPromise.value;
+  }
+  get warnings() {
+    return this.warningsPromise.value;
+  }
+  get request() {
+    return this.requestPromise.value;
+  }
+  get response() {
+    return this.responsePromise.value;
+  }
   get partialObjectStream() {
-    return createAsyncIterableStream(this.originalStream, {
+    return createAsyncIterableStream(this.stitchableStream.stream, {
       transform(chunk, controller) {
         switch (chunk.type) {
           case "object":
@@ -2849,10 +2951,12 @@ var DefaultStreamObjectResult = class {
     });
   }
   get elementStream() {
-    return this.outputStrategy.createElementStream(this.originalStream);
+    return this.outputStrategy.createElementStream(
+      this.stitchableStream.stream
+    );
   }
   get textStream() {
-    return createAsyncIterableStream(this.originalStream, {
+    return createAsyncIterableStream(this.stitchableStream.stream, {
       transform(chunk, controller) {
         switch (chunk.type) {
           case "text-delta":
@@ -2873,7 +2977,7 @@ var DefaultStreamObjectResult = class {
     });
   }
   get fullStream() {
-    return createAsyncIterableStream(this.originalStream, {
+    return createAsyncIterableStream(this.stitchableStream.stream, {
       transform(chunk, controller) {
         controller.enqueue(chunk);
       }
@@ -3187,15 +3291,16 @@ async function generateText({
       };
       let stepType = "initial";
       do {
-        if (stepCount === 1) {
-          initialPrompt.type = "messages";
-        }
         const promptFormat = stepCount === 0 ? initialPrompt.type : "messages";
+        const stepInputMessages = [
+          ...initialPrompt.messages,
+          ...responseMessages
+        ];
         const promptMessages = await convertToLanguageModelPrompt({
           prompt: {
             type: promptFormat,
             system: initialPrompt.system,
-            messages: [...initialPrompt.messages, ...responseMessages]
+            messages: stepInputMessages
           },
           modelSupportsImageUrls: model.supportsImageUrls,
           modelSupportsUrl: model.supportsUrl
@@ -3291,6 +3396,7 @@ async function generateText({
           tools,
           tracer,
           telemetry,
+          messages: stepInputMessages,
           abortSignal
         });
         const currentUsage = calculateLanguageModelUsage(
@@ -3401,6 +3507,7 @@ async function executeTools({
   tools,
   tracer,
   telemetry,
+  messages,
   abortSignal
 }) {
   const toolResults = await Promise.all(
@@ -3427,7 +3534,10 @@ async function executeTools({
         }),
         tracer,
         fn: async (span) => {
-          const result2 = await tool2.execute(toolCall.args, { abortSignal });
+          const result2 = await tool2.execute(toolCall.args, {
+            messages,
+            abortSignal
+          });
           try {
             span.setAttributes(
               selectTelemetryAttributes({
@@ -3474,69 +3584,7 @@ var DefaultGenerateTextResult = class {
 
 // core/generate-text/stream-text.ts
 import { createIdGenerator as createIdGenerator4 } from "@ai-sdk/provider-utils";
-import { formatStreamPart } from "@ai-sdk/ui-utils";
-
-// core/util/create-stitchable-stream.ts
-function createStitchableStream() {
-  let innerStreamReaders = [];
-  let controller = null;
-  let isClosed = false;
-  const processPull = async () => {
-    if (isClosed && innerStreamReaders.length === 0) {
-      controller == null ? void 0 : controller.close();
-      return;
-    }
-    if (innerStreamReaders.length === 0) {
-      return;
-    }
-    try {
-      const { value, done } = await innerStreamReaders[0].read();
-      if (done) {
-        innerStreamReaders.shift();
-        if (innerStreamReaders.length > 0) {
-          await processPull();
-        } else if (isClosed) {
-          controller == null ? void 0 : controller.close();
-        }
-      } else {
-        controller == null ? void 0 : controller.enqueue(value);
-      }
-    } catch (error) {
-      controller == null ? void 0 : controller.error(error);
-      innerStreamReaders.shift();
-      if (isClosed && innerStreamReaders.length === 0) {
-        controller == null ? void 0 : controller.close();
-      }
-    }
-  };
-  return {
-    stream: new ReadableStream({
-      start(controllerParam) {
-        controller = controllerParam;
-      },
-      pull: processPull,
-      async cancel() {
-        for (const reader of innerStreamReaders) {
-          await reader.cancel();
-        }
-        innerStreamReaders = [];
-        isClosed = true;
-      }
-    }),
-    addStream: (innerStream) => {
-      if (isClosed) {
-        throw new Error("Cannot add inner stream: outer stream is closed");
-      }
-      innerStreamReaders.push(innerStream.getReader());
-    },
-    close: () => {
-      isClosed = true;
-      if (innerStreamReaders.length === 0) {
-        controller == null ? void 0 : controller.close();
-      }
-    }
-  };
-}
+import { formatDataStreamPart } from "@ai-sdk/ui-utils";
 
 // core/util/merge-streams.ts
 function mergeStreams(stream1, stream2) {
@@ -3634,6 +3682,7 @@ function runToolsTransformation({
   toolCallStreaming,
   tracer,
   telemetry,
+  messages,
   abortSignal
 }) {
   let toolResultsStreamController = null;
@@ -3729,7 +3778,10 @@ function runToolsTransformation({
                   }
                 }),
                 tracer,
-                fn: async (span) => tool2.execute(toolCall.args, { abortSignal }).then(
+                fn: async (span) => tool2.execute(toolCall.args, {
+                  messages,
+                  abortSignal
+                }).then(
                   (result) => {
                     toolResultsStreamController.enqueue({
                       ...toolCall,
@@ -3821,7 +3873,7 @@ function runToolsTransformation({
 
 // core/generate-text/stream-text.ts
 var originalGenerateId4 = createIdGenerator4({ prefix: "aitxt", size: 24 });
-async function streamText({
+function streamText({
   model,
   tools,
   toolChoice,
@@ -3837,594 +3889,587 @@ async function streamText({
   experimental_providerMetadata: providerMetadata,
   experimental_toolCallStreaming: toolCallStreaming = false,
   experimental_activeTools: activeTools,
-  onChunk,
-  onFinish,
-  onStepFinish,
-  _internal: {
-    now: now2 = now,
-    generateId: generateId3 = originalGenerateId4,
-    currentDate = () => /* @__PURE__ */ new Date()
-  } = {},
-  ...settings
-}) {
-  if (maxSteps < 1) {
-    throw new InvalidArgumentError({
-      parameter: "maxSteps",
-      value: maxSteps,
-      message: "maxSteps must be at least 1"
-    });
-  }
-  const baseTelemetryAttributes = getBaseTelemetryAttributes({
-    model,
-    telemetry,
-    headers,
-    settings: { ...settings, maxRetries }
-  });
-  const tracer = getTracer(telemetry);
-  const initialPrompt = standardizePrompt({
-    prompt: { system, prompt, messages },
-    tools
-  });
-  return recordSpan({
-    name: "ai.streamText",
-    attributes: selectTelemetryAttributes({
-      telemetry,
-      attributes: {
-        ...assembleOperationName({ operationId: "ai.streamText", telemetry }),
-        ...baseTelemetryAttributes,
-        // specific settings that only make sense on the outer level:
-        "ai.prompt": {
-          input: () => JSON.stringify({ system, prompt, messages })
-        },
-        "ai.settings.maxSteps": maxSteps
-      }
-    }),
-    tracer,
-    endWhenDone: false,
-    fn: async (rootSpan) => {
-      const retry = retryWithExponentialBackoff({ maxRetries });
-      const startStep = async ({
-        responseMessages
-      }) => {
-        const promptFormat = responseMessages.length === 0 ? initialPrompt.type : "messages";
-        const promptMessages = await convertToLanguageModelPrompt({
-          prompt: {
-            type: promptFormat,
-            system: initialPrompt.system,
-            messages: [...initialPrompt.messages, ...responseMessages]
-          },
-          modelSupportsImageUrls: model.supportsImageUrls,
-          modelSupportsUrl: model.supportsUrl
-        });
-        const mode = {
-          type: "regular",
-          ...prepareToolsAndToolChoice({ tools, toolChoice, activeTools })
-        };
-        const {
-          result: { stream: stream2, warnings: warnings2, rawResponse: rawResponse2, request: request2 },
-          doStreamSpan: doStreamSpan2,
-          startTimestampMs: startTimestampMs2
-        } = await retry(
-          () => recordSpan({
-            name: "ai.streamText.doStream",
-            attributes: selectTelemetryAttributes({
-              telemetry,
-              attributes: {
-                ...assembleOperationName({
-                  operationId: "ai.streamText.doStream",
-                  telemetry
-                }),
-                ...baseTelemetryAttributes,
-                "ai.prompt.format": {
-                  input: () => promptFormat
-                },
-                "ai.prompt.messages": {
-                  input: () => JSON.stringify(promptMessages)
-                },
-                "ai.prompt.tools": {
-                  // convert the language model level tools:
-                  input: () => {
-                    var _a11;
-                    return (_a11 = mode.tools) == null ? void 0 : _a11.map((tool2) => JSON.stringify(tool2));
-                  }
-                },
-                "ai.prompt.toolChoice": {
-                  input: () => mode.toolChoice != null ? JSON.stringify(mode.toolChoice) : void 0
-                },
-                // standardized gen-ai llm span attributes:
-                "gen_ai.system": model.provider,
-                "gen_ai.request.model": model.modelId,
-                "gen_ai.request.frequency_penalty": settings.frequencyPenalty,
-                "gen_ai.request.max_tokens": settings.maxTokens,
-                "gen_ai.request.presence_penalty": settings.presencePenalty,
-                "gen_ai.request.stop_sequences": settings.stopSequences,
-                "gen_ai.request.temperature": settings.temperature,
-                "gen_ai.request.top_k": settings.topK,
-                "gen_ai.request.top_p": settings.topP
-              }
-            }),
-            tracer,
-            endWhenDone: false,
-            fn: async (doStreamSpan3) => ({
-              startTimestampMs: now2(),
-              // get before the call
-              doStreamSpan: doStreamSpan3,
-              result: await model.doStream({
-                mode,
-                ...prepareCallSettings(settings),
-                inputFormat: promptFormat,
-                prompt: promptMessages,
-                providerMetadata,
-                abortSignal,
-                headers
-              })
-            })
-          })
-        );
-        return {
-          result: {
-            stream: runToolsTransformation({
-              tools,
-              generatorStream: stream2,
-              toolCallStreaming,
-              tracer,
-              telemetry,
-              abortSignal
-            }),
-            warnings: warnings2,
-            request: request2 != null ? request2 : {},
-            rawResponse: rawResponse2
-          },
-          doStreamSpan: doStreamSpan2,
-          startTimestampMs: startTimestampMs2
-        };
-      };
-      const {
-        result: { stream, warnings, rawResponse, request },
-        doStreamSpan,
-        startTimestampMs
-      } = await startStep({ responseMessages: [] });
-      return new DefaultStreamTextResult({
-        stream,
-        warnings,
-        rawResponse,
-        request,
-        onChunk,
-        onFinish,
-        onStepFinish,
-        rootSpan,
-        doStreamSpan,
-        telemetry,
-        startTimestampMs,
-        maxSteps,
-        continueSteps,
-        startStep,
-        modelId: model.modelId,
-        now: now2,
-        currentDate,
-        generateId: generateId3,
-        tools
-      });
-    }
+  onChunk,
+  onFinish,
+  onStepFinish,
+  _internal: {
+    now: now2 = now,
+    generateId: generateId3 = originalGenerateId4,
+    currentDate = () => /* @__PURE__ */ new Date()
+  } = {},
+  ...settings
+}) {
+  return new DefaultStreamTextResult({
+    model,
+    telemetry,
+    headers,
+    settings,
+    maxRetries,
+    abortSignal,
+    system,
+    prompt,
+    messages,
+    tools,
+    toolChoice,
+    toolCallStreaming,
+    activeTools,
+    maxSteps,
+    continueSteps,
+    providerMetadata,
+    onChunk,
+    onFinish,
+    onStepFinish,
+    now: now2,
+    currentDate,
+    generateId: generateId3
   });
 }
 var DefaultStreamTextResult = class {
   constructor({
-    stream,
-    warnings,
-    rawResponse,
-    request,
-    onChunk,
-    onFinish,
-    onStepFinish,
-    rootSpan,
-    doStreamSpan,
+    model,
     telemetry,
-    startTimestampMs,
+    headers,
+    settings,
+    maxRetries,
+    abortSignal,
+    system,
+    prompt,
+    messages,
+    tools,
+    toolChoice,
+    toolCallStreaming,
+    activeTools,
     maxSteps,
     continueSteps,
-    startStep,
-    modelId,
+    providerMetadata,
+    onChunk,
+    onFinish,
+    onStepFinish,
     now: now2,
     currentDate,
-    generateId: generateId3,
-    tools
+    generateId: generateId3
   }) {
-    this.rawWarnings = warnings;
-    this.rawResponse = rawResponse;
-    const { resolve: resolveUsage, promise: usagePromise } = createResolvablePromise();
-    this.usage = usagePromise;
-    const { resolve: resolveFinishReason, promise: finishReasonPromise } = createResolvablePromise();
-    this.finishReason = finishReasonPromise;
-    const { resolve: resolveText, promise: textPromise } = createResolvablePromise();
-    this.text = textPromise;
-    const { resolve: resolveToolCalls, promise: toolCallsPromise } = createResolvablePromise();
-    this.toolCalls = toolCallsPromise;
-    const { resolve: resolveToolResults, promise: toolResultsPromise } = createResolvablePromise();
-    this.toolResults = toolResultsPromise;
-    const { resolve: resolveSteps, promise: stepsPromise } = createResolvablePromise();
-    this.steps = stepsPromise;
-    const {
-      resolve: resolveProviderMetadata,
-      promise: providerMetadataPromise
-    } = createResolvablePromise();
-    this.experimental_providerMetadata = providerMetadataPromise;
-    const { resolve: resolveRequest, promise: requestPromise } = createResolvablePromise();
-    this.request = requestPromise;
-    const { resolve: resolveResponse, promise: responsePromise } = createResolvablePromise();
-    this.response = responsePromise;
-    const { resolve: resolveWarnings, promise: warningsPromise } = createResolvablePromise();
-    this.warnings = warningsPromise;
-    const {
-      stream: stitchableStream,
-      addStream,
-      close: closeStitchableStream
-    } = createStitchableStream();
-    this.originalStream = stitchableStream;
-    const stepResults = [];
+    this.warningsPromise = new DelayedPromise();
+    this.usagePromise = new DelayedPromise();
+    this.finishReasonPromise = new DelayedPromise();
+    this.providerMetadataPromise = new DelayedPromise();
+    this.textPromise = new DelayedPromise();
+    this.toolCallsPromise = new DelayedPromise();
+    this.toolResultsPromise = new DelayedPromise();
+    this.requestPromise = new DelayedPromise();
+    this.responsePromise = new DelayedPromise();
+    this.stepsPromise = new DelayedPromise();
+    this.stitchableStream = createStitchableStream();
+    if (maxSteps < 1) {
+      throw new InvalidArgumentError({
+        parameter: "maxSteps",
+        value: maxSteps,
+        message: "maxSteps must be at least 1"
+      });
+    }
+    const tracer = getTracer(telemetry);
+    const baseTelemetryAttributes = getBaseTelemetryAttributes({
+      model,
+      telemetry,
+      headers,
+      settings: { ...settings, maxRetries }
+    });
+    const initialPrompt = standardizePrompt({
+      prompt: { system, prompt, messages },
+      tools
+    });
     const self = this;
-    function addStepStream({
-      stream: stream2,
-      startTimestamp,
-      doStreamSpan: doStreamSpan2,
-      currentStep,
-      responseMessages,
-      usage = {
-        promptTokens: 0,
-        completionTokens: 0,
-        totalTokens: 0
-      },
-      stepType,
-      previousStepText = "",
-      stepRequest,
-      hasLeadingWhitespace
-    }) {
-      const stepToolCalls = [];
-      const stepToolResults = [];
-      let stepFinishReason = "unknown";
-      let stepUsage = {
-        promptTokens: 0,
-        completionTokens: 0,
-        totalTokens: 0
-      };
-      let stepProviderMetadata;
-      let stepFirstChunk = true;
-      let stepText = "";
-      let fullStepText = stepType === "continue" ? previousStepText : "";
-      let stepLogProbs;
-      let stepResponse = {
-        id: generateId3(),
-        timestamp: currentDate(),
-        modelId
-      };
-      let chunkBuffer = "";
-      let chunkTextPublished = false;
-      let inWhitespacePrefix = true;
-      let hasWhitespaceSuffix = false;
-      async function publishTextChunk({
-        controller,
-        chunk
-      }) {
-        controller.enqueue(chunk);
-        stepText += chunk.textDelta;
-        fullStepText += chunk.textDelta;
-        chunkTextPublished = true;
-        hasWhitespaceSuffix = chunk.textDelta.trimEnd() !== chunk.textDelta;
-        await (onChunk == null ? void 0 : onChunk({ chunk }));
-      }
-      addStream(
-        stream2.pipeThrough(
-          new TransformStream({
-            async transform(chunk, controller) {
-              var _a11, _b, _c;
-              if (stepFirstChunk) {
-                const msToFirstChunk = now2() - startTimestamp;
-                stepFirstChunk = false;
-                doStreamSpan2.addEvent("ai.stream.firstChunk", {
-                  "ai.response.msToFirstChunk": msToFirstChunk
-                });
-                doStreamSpan2.setAttributes({
-                  "ai.response.msToFirstChunk": msToFirstChunk
-                });
-              }
-              if (chunk.type === "text-delta" && chunk.textDelta.length === 0) {
-                return;
-              }
-              const chunkType = chunk.type;
-              switch (chunkType) {
-                case "text-delta": {
-                  if (continueSteps) {
-                    const trimmedChunkText = inWhitespacePrefix && hasLeadingWhitespace ? chunk.textDelta.trimStart() : chunk.textDelta;
-                    if (trimmedChunkText.length === 0) {
-                      break;
+    recordSpan({
+      name: "ai.streamText",
+      attributes: selectTelemetryAttributes({
+        telemetry,
+        attributes: {
+          ...assembleOperationName({ operationId: "ai.streamText", telemetry }),
+          ...baseTelemetryAttributes,
+          // specific settings that only make sense on the outer level:
+          "ai.prompt": {
+            input: () => JSON.stringify({ system, prompt, messages })
+          },
+          "ai.settings.maxSteps": maxSteps
+        }
+      }),
+      tracer,
+      endWhenDone: false,
+      fn: async (rootSpan) => {
+        const retry = retryWithExponentialBackoff({ maxRetries });
+        const stepResults = [];
+        async function streamStep({
+          currentStep,
+          responseMessages,
+          usage,
+          stepType,
+          previousStepText,
+          hasLeadingWhitespace
+        }) {
+          const promptFormat = responseMessages.length === 0 ? initialPrompt.type : "messages";
+          const stepInputMessages = [
+            ...initialPrompt.messages,
+            ...responseMessages
+          ];
+          const promptMessages = await convertToLanguageModelPrompt({
+            prompt: {
+              type: promptFormat,
+              system: initialPrompt.system,
+              messages: stepInputMessages
+            },
+            modelSupportsImageUrls: model.supportsImageUrls,
+            modelSupportsUrl: model.supportsUrl
+          });
+          const mode = {
+            type: "regular",
+            ...prepareToolsAndToolChoice({ tools, toolChoice, activeTools })
+          };
+          const {
+            result: { stream, warnings, rawResponse, request },
+            doStreamSpan,
+            startTimestampMs
+          } = await retry(
+            () => recordSpan({
+              name: "ai.streamText.doStream",
+              attributes: selectTelemetryAttributes({
+                telemetry,
+                attributes: {
+                  ...assembleOperationName({
+                    operationId: "ai.streamText.doStream",
+                    telemetry
+                  }),
+                  ...baseTelemetryAttributes,
+                  "ai.prompt.format": {
+                    input: () => promptFormat
+                  },
+                  "ai.prompt.messages": {
+                    input: () => JSON.stringify(promptMessages)
+                  },
+                  "ai.prompt.tools": {
+                    // convert the language model level tools:
+                    input: () => {
+                      var _a11;
+                      return (_a11 = mode.tools) == null ? void 0 : _a11.map((tool2) => JSON.stringify(tool2));
                     }
-                    inWhitespacePrefix = false;
-                    chunkBuffer += trimmedChunkText;
-                    const split = splitOnLastWhitespace(chunkBuffer);
-                    if (split != null) {
-                      chunkBuffer = split.suffix;
-                      await publishTextChunk({
-                        controller,
-                        chunk: {
-                          type: "text-delta",
-                          textDelta: split.prefix + split.whitespace
+                  },
+                  "ai.prompt.toolChoice": {
+                    input: () => mode.toolChoice != null ? JSON.stringify(mode.toolChoice) : void 0
+                  },
+                  // standardized gen-ai llm span attributes:
+                  "gen_ai.system": model.provider,
+                  "gen_ai.request.model": model.modelId,
+                  "gen_ai.request.frequency_penalty": settings.frequencyPenalty,
+                  "gen_ai.request.max_tokens": settings.maxTokens,
+                  "gen_ai.request.presence_penalty": settings.presencePenalty,
+                  "gen_ai.request.stop_sequences": settings.stopSequences,
+                  "gen_ai.request.temperature": settings.temperature,
+                  "gen_ai.request.top_k": settings.topK,
+                  "gen_ai.request.top_p": settings.topP
+                }
+              }),
+              tracer,
+              endWhenDone: false,
+              fn: async (doStreamSpan2) => ({
+                startTimestampMs: now2(),
+                // get before the call
+                doStreamSpan: doStreamSpan2,
+                result: await model.doStream({
+                  mode,
+                  ...prepareCallSettings(settings),
+                  inputFormat: promptFormat,
+                  prompt: promptMessages,
+                  providerMetadata,
+                  abortSignal,
+                  headers
+                })
+              })
+            })
+          );
+          const transformedStream = runToolsTransformation({
+            tools,
+            generatorStream: stream,
+            toolCallStreaming,
+            tracer,
+            telemetry,
+            messages: stepInputMessages,
+            abortSignal
+          });
+          const stepRequest = request != null ? request : {};
+          const stepToolCalls = [];
+          const stepToolResults = [];
+          let stepFinishReason = "unknown";
+          let stepUsage = {
+            promptTokens: 0,
+            completionTokens: 0,
+            totalTokens: 0
+          };
+          let stepProviderMetadata;
+          let stepFirstChunk = true;
+          let stepText = "";
+          let fullStepText = stepType === "continue" ? previousStepText : "";
+          let stepLogProbs;
+          let stepResponse = {
+            id: generateId3(),
+            timestamp: currentDate(),
+            modelId: model.modelId
+          };
+          let chunkBuffer = "";
+          let chunkTextPublished = false;
+          let inWhitespacePrefix = true;
+          let hasWhitespaceSuffix = false;
+          async function publishTextChunk({
+            controller,
+            chunk
+          }) {
+            controller.enqueue(chunk);
+            stepText += chunk.textDelta;
+            fullStepText += chunk.textDelta;
+            chunkTextPublished = true;
+            hasWhitespaceSuffix = chunk.textDelta.trimEnd() !== chunk.textDelta;
+            await (onChunk == null ? void 0 : onChunk({ chunk }));
+          }
+          self.stitchableStream.addStream(
+            transformedStream.pipeThrough(
+              new TransformStream({
+                async transform(chunk, controller) {
+                  var _a11, _b, _c;
+                  if (stepFirstChunk) {
+                    const msToFirstChunk = now2() - startTimestampMs;
+                    stepFirstChunk = false;
+                    doStreamSpan.addEvent("ai.stream.firstChunk", {
+                      "ai.response.msToFirstChunk": msToFirstChunk
+                    });
+                    doStreamSpan.setAttributes({
+                      "ai.response.msToFirstChunk": msToFirstChunk
+                    });
+                  }
+                  if (chunk.type === "text-delta" && chunk.textDelta.length === 0) {
+                    return;
+                  }
+                  const chunkType = chunk.type;
+                  switch (chunkType) {
+                    case "text-delta": {
+                      if (continueSteps) {
+                        const trimmedChunkText = inWhitespacePrefix && hasLeadingWhitespace ? chunk.textDelta.trimStart() : chunk.textDelta;
+                        if (trimmedChunkText.length === 0) {
+                          break;
+                        }
+                        inWhitespacePrefix = false;
+                        chunkBuffer += trimmedChunkText;
+                        const split = splitOnLastWhitespace(chunkBuffer);
+                        if (split != null) {
+                          chunkBuffer = split.suffix;
+                          await publishTextChunk({
+                            controller,
+                            chunk: {
+                              type: "text-delta",
+                              textDelta: split.prefix + split.whitespace
+                            }
+                          });
                         }
+                      } else {
+                        await publishTextChunk({ controller, chunk });
+                      }
+                      break;
+                    }
+                    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": {
+                      stepResponse = {
+                        id: (_a11 = chunk.id) != null ? _a11 : stepResponse.id,
+                        timestamp: (_b = chunk.timestamp) != null ? _b : stepResponse.timestamp,
+                        modelId: (_c = chunk.modelId) != null ? _c : stepResponse.modelId
+                      };
+                      break;
+                    }
+                    case "finish": {
+                      stepUsage = chunk.usage;
+                      stepFinishReason = chunk.finishReason;
+                      stepProviderMetadata = chunk.experimental_providerMetadata;
+                      stepLogProbs = chunk.logprobs;
+                      const msToFinish = now2() - startTimestampMs;
+                      doStreamSpan.addEvent("ai.stream.finish");
+                      doStreamSpan.setAttributes({
+                        "ai.response.msToFinish": msToFinish,
+                        "ai.response.avgCompletionTokensPerSecond": 1e3 * stepUsage.completionTokens / msToFinish
                       });
+                      break;
                     }
-                  } else {
-                    await publishTextChunk({ controller, chunk });
-                  }
-                  break;
-                }
-                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": {
-                  stepResponse = {
-                    id: (_a11 = chunk.id) != null ? _a11 : stepResponse.id,
-                    timestamp: (_b = chunk.timestamp) != null ? _b : stepResponse.timestamp,
-                    modelId: (_c = chunk.modelId) != null ? _c : stepResponse.modelId
-                  };
-                  break;
-                }
-                case "finish": {
-                  stepUsage = chunk.usage;
-                  stepFinishReason = chunk.finishReason;
-                  stepProviderMetadata = chunk.experimental_providerMetadata;
-                  stepLogProbs = chunk.logprobs;
-                  const msToFinish = now2() - startTimestamp;
-                  doStreamSpan2.addEvent("ai.stream.finish");
-                  doStreamSpan2.setAttributes({
-                    "ai.response.msToFinish": msToFinish,
-                    "ai.response.avgCompletionTokensPerSecond": 1e3 * stepUsage.completionTokens / msToFinish
-                  });
-                  break;
-                }
-                case "tool-call-streaming-start":
-                case "tool-call-delta": {
-                  controller.enqueue(chunk);
-                  await (onChunk == null ? void 0 : onChunk({ chunk }));
-                  break;
-                }
-                case "error": {
-                  controller.enqueue(chunk);
-                  stepFinishReason = "error";
-                  break;
-                }
-                default: {
-                  const exhaustiveCheck = chunkType;
-                  throw new Error(`Unknown chunk type: ${exhaustiveCheck}`);
-                }
-              }
-            },
-            // invoke onFinish callback and resolve toolResults promise when the stream is about to close:
-            async flush(controller) {
-              var _a11, _b;
-              const stepToolCallsJson = stepToolCalls.length > 0 ? JSON.stringify(stepToolCalls) : void 0;
-              let nextStepType = "done";
-              if (currentStep + 1 < maxSteps) {
-                if (continueSteps && stepFinishReason === "length" && // only use continue when there are no tool calls:
-                stepToolCalls.length === 0) {
-                  nextStepType = "continue";
-                } else if (
-                  // there are tool calls:
-                  stepToolCalls.length > 0 && // all current tool calls have results:
-                  stepToolResults.length === stepToolCalls.length
-                ) {
-                  nextStepType = "tool-result";
-                }
-              }
-              if (continueSteps && chunkBuffer.length > 0 && (nextStepType !== "continue" || // when the next step is a regular step, publish the buffer
-              stepType === "continue" && !chunkTextPublished)) {
-                await publishTextChunk({
-                  controller,
-                  chunk: {
-                    type: "text-delta",
-                    textDelta: chunkBuffer
-                  }
-                });
-                chunkBuffer = "";
-              }
-              try {
-                doStreamSpan2.setAttributes(
-                  selectTelemetryAttributes({
-                    telemetry,
-                    attributes: {
-                      "ai.response.finishReason": stepFinishReason,
-                      "ai.response.text": { output: () => stepText },
-                      "ai.response.toolCalls": {
-                        output: () => stepToolCallsJson
-                      },
-                      "ai.response.id": stepResponse.id,
-                      "ai.response.model": stepResponse.modelId,
-                      "ai.response.timestamp": stepResponse.timestamp.toISOString(),
-                      "ai.usage.promptTokens": stepUsage.promptTokens,
-                      "ai.usage.completionTokens": stepUsage.completionTokens,
-                      // standardized gen-ai llm span attributes:
-                      "gen_ai.response.finish_reasons": [stepFinishReason],
-                      "gen_ai.response.id": stepResponse.id,
-                      "gen_ai.response.model": stepResponse.modelId,
-                      "gen_ai.usage.input_tokens": stepUsage.promptTokens,
-                      "gen_ai.usage.output_tokens": stepUsage.completionTokens
+                    case "tool-call-streaming-start":
+                    case "tool-call-delta": {
+                      controller.enqueue(chunk);
+                      await (onChunk == null ? void 0 : onChunk({ chunk }));
+                      break;
                     }
-                  })
-                );
-              } catch (error) {
-              } finally {
-                doStreamSpan2.end();
-              }
-              controller.enqueue({
-                type: "step-finish",
-                finishReason: stepFinishReason,
-                usage: stepUsage,
-                experimental_providerMetadata: stepProviderMetadata,
-                logprobs: stepLogProbs,
-                response: {
-                  ...stepResponse
+                    case "error": {
+                      controller.enqueue(chunk);
+                      stepFinishReason = "error";
+                      break;
+                    }
+                    default: {
+                      const exhaustiveCheck = chunkType;
+                      throw new Error(`Unknown chunk type: ${exhaustiveCheck}`);
+                    }
+                  }
                 },
-                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"
+                // invoke onFinish callback and resolve toolResults promise when the stream is about to close:
+                async flush(controller) {
+                  const stepToolCallsJson = stepToolCalls.length > 0 ? JSON.stringify(stepToolCalls) : void 0;
+                  let nextStepType = "done";
+                  if (currentStep + 1 < maxSteps) {
+                    if (continueSteps && stepFinishReason === "length" && // only use continue when there are no tool calls:
+                    stepToolCalls.length === 0) {
+                      nextStepType = "continue";
+                    } else if (
+                      // there are tool calls:
+                      stepToolCalls.length > 0 && // all current tool calls have results:
+                      stepToolResults.length === stepToolCalls.length
+                    ) {
+                      nextStepType = "tool-result";
+                    }
+                  }
+                  if (continueSteps && chunkBuffer.length > 0 && (nextStepType !== "continue" || // when the next step is a regular step, publish the buffer
+                  stepType === "continue" && !chunkTextPublished)) {
+                    await publishTextChunk({
+                      controller,
+                      chunk: {
+                        type: "text-delta",
+                        textDelta: chunkBuffer
+                      }
+                    });
+                    chunkBuffer = "";
+                  }
+                  try {
+                    doStreamSpan.setAttributes(
+                      selectTelemetryAttributes({
+                        telemetry,
+                        attributes: {
+                          "ai.response.finishReason": stepFinishReason,
+                          "ai.response.text": { output: () => stepText },
+                          "ai.response.toolCalls": {
+                            output: () => stepToolCallsJson
+                          },
+                          "ai.response.id": stepResponse.id,
+                          "ai.response.model": stepResponse.modelId,
+                          "ai.response.timestamp": stepResponse.timestamp.toISOString(),
+                          "ai.usage.promptTokens": stepUsage.promptTokens,
+                          "ai.usage.completionTokens": stepUsage.completionTokens,
+                          // standardized gen-ai llm span attributes:
+                          "gen_ai.response.finish_reasons": [stepFinishReason],
+                          "gen_ai.response.id": stepResponse.id,
+                          "gen_ai.response.model": stepResponse.modelId,
+                          "gen_ai.usage.input_tokens": stepUsage.promptTokens,
+                          "gen_ai.usage.output_tokens": stepUsage.completionTokens
+                        }
+                      })
+                    );
+                  } catch (error) {
+                  } finally {
+                    doStreamSpan.end();
+                  }
+                  controller.enqueue({
+                    type: "step-finish",
+                    finishReason: stepFinishReason,
+                    usage: stepUsage,
+                    experimental_providerMetadata: stepProviderMetadata,
+                    logprobs: stepLogProbs,
+                    response: {
+                      ...stepResponse
+                    },
+                    isContinued: nextStepType === "continue"
                   });
-                }
-              } else {
-                responseMessages.push(
-                  ...toResponseMessages({
+                  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,
-                    tools: tools != null ? tools : {},
                     toolCalls: stepToolCalls,
-                    toolResults: stepToolResults
-                  })
-                );
-              }
-              const currentStepResult = {
-                stepType,
-                text: stepText,
-                toolCalls: stepToolCalls,
-                toolResults: stepToolResults,
-                finishReason: stepFinishReason,
-                usage: stepUsage,
-                warnings: self.rawWarnings,
-                logprobs: stepLogProbs,
-                request: stepRequest,
-                response: {
-                  ...stepResponse,
-                  headers: (_a11 = self.rawResponse) == null ? void 0 : _a11.headers,
-                  // deep clone msgs to avoid mutating past messages in multi-step:
-                  messages: JSON.parse(JSON.stringify(responseMessages))
-                },
-                experimental_providerMetadata: stepProviderMetadata,
-                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") {
-                const {
-                  result,
-                  doStreamSpan: doStreamSpan3,
-                  startTimestampMs: startTimestamp2
-                } = await startStep({ responseMessages });
-                self.rawWarnings = result.warnings;
-                self.rawResponse = result.rawResponse;
-                addStepStream({
-                  stream: result.stream,
-                  startTimestamp: startTimestamp2,
-                  doStreamSpan: doStreamSpan3,
-                  currentStep: currentStep + 1,
-                  responseMessages,
-                  usage: combinedUsage,
-                  stepType: nextStepType,
-                  previousStepText: fullStepText,
-                  stepRequest: result.request,
-                  hasLeadingWhitespace: hasWhitespaceSuffix
-                });
-                return;
-              }
-              try {
-                controller.enqueue({
-                  type: "finish",
-                  finishReason: stepFinishReason,
-                  usage: combinedUsage,
-                  experimental_providerMetadata: stepProviderMetadata,
-                  logprobs: stepLogProbs,
-                  response: {
-                    ...stepResponse
+                    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))
+                    },
+                    experimental_providerMetadata: stepProviderMetadata,
+                    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;
                   }
-                });
-                closeStitchableStream();
-                rootSpan.setAttributes(
-                  selectTelemetryAttributes({
-                    telemetry,
-                    attributes: {
-                      "ai.response.finishReason": stepFinishReason,
-                      "ai.response.text": { output: () => fullStepText },
-                      "ai.response.toolCalls": {
-                        output: () => stepToolCallsJson
+                  try {
+                    controller.enqueue({
+                      type: "finish",
+                      finishReason: stepFinishReason,
+                      usage: combinedUsage,
+                      experimental_providerMetadata: stepProviderMetadata,
+                      logprobs: stepLogProbs,
+                      response: {
+                        ...stepResponse
+                      }
+                    });
+                    self.stitchableStream.close();
+                    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,
+                      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
                       },
-                      "ai.usage.promptTokens": combinedUsage.promptTokens,
-                      "ai.usage.completionTokens": combinedUsage.completionTokens
-                    }
-                  })
-                );
-                resolveUsage(combinedUsage);
-                resolveFinishReason(stepFinishReason);
-                resolveText(fullStepText);
-                resolveToolCalls(stepToolCalls);
-                resolveProviderMetadata(stepProviderMetadata);
-                resolveToolResults(stepToolResults);
-                resolveRequest(stepRequest);
-                resolveResponse({
-                  ...stepResponse,
-                  headers: rawResponse == null ? void 0 : rawResponse.headers,
-                  messages: responseMessages
-                });
-                resolveSteps(stepResults);
-                resolveWarnings((_b = self.rawWarnings) != null ? _b : []);
-                await (onFinish == null ? void 0 : onFinish({
-                  finishReason: stepFinishReason,
-                  logprobs: stepLogProbs,
-                  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,
-                  responseMessages
-                }));
-              } catch (error) {
-                controller.error(error);
-              } finally {
-                rootSpan.end();
-              }
-            }
-          })
-        )
+                      warnings,
+                      experimental_providerMetadata: stepProviderMetadata,
+                      steps: stepResults
+                    }));
+                  } catch (error) {
+                    controller.error(error);
+                  } finally {
+                    rootSpan.end();
+                  }
+                }
+              })
+            )
+          );
+        }
+        await streamStep({
+          currentStep: 0,
+          responseMessages: [],
+          usage: {
+            promptTokens: 0,
+            completionTokens: 0,
+            totalTokens: 0
+          },
+          previousStepText: "",
+          stepType: "initial",
+          hasLeadingWhitespace: false
+        });
+      }
+    }).catch((error) => {
+      self.stitchableStream.addStream(
+        new ReadableStream({
+          start(controller) {
+            controller.error(error);
+          }
+        })
       );
-    }
-    addStepStream({
-      stream,
-      startTimestamp: startTimestampMs,
-      doStreamSpan,
-      currentStep: 0,
-      responseMessages: [],
-      usage: void 0,
-      stepType: "initial",
-      stepRequest: request,
-      hasLeadingWhitespace: false
+      self.stitchableStream.close();
     });
   }
+  get warnings() {
+    return this.warningsPromise.value;
+  }
+  get usage() {
+    return this.usagePromise.value;
+  }
+  get finishReason() {
+    return this.finishReasonPromise.value;
+  }
+  get experimental_providerMetadata() {
+    return this.providerMetadataPromise.value;
+  }
+  get text() {
+    return this.textPromise.value;
+  }
+  get toolCalls() {
+    return this.toolCallsPromise.value;
+  }
+  get toolResults() {
+    return this.toolResultsPromise.value;
+  }
+  get request() {
+    return this.requestPromise.value;
+  }
+  get response() {
+    return this.responsePromise.value;
+  }
+  get steps() {
+    return this.stepsPromise.value;
+  }
   /**
   Split out a new stream from the original stream.
   The original stream is replaced to allow for further splitting,
@@ -4434,8 +4479,8 @@ var DefaultStreamTextResult = class {
   However, the LLM results are expected to be small enough to not cause issues.
      */
   teeStream() {
-    const [stream1, stream2] = this.originalStream.tee();
-    this.originalStream = stream2;
+    const [stream1, stream2] = this.stitchableStream.stream.tee();
+    this.stitchableStream.stream = stream2;
     return stream1;
   }
   get textStream() {
@@ -4475,12 +4520,12 @@ var DefaultStreamTextResult = class {
         const chunkType = chunk.type;
         switch (chunkType) {
           case "text-delta": {
-            controller.enqueue(formatStreamPart("text", chunk.textDelta));
+            controller.enqueue(formatDataStreamPart("text", chunk.textDelta));
             break;
           }
           case "tool-call-streaming-start": {
             controller.enqueue(
-              formatStreamPart("tool_call_streaming_start", {
+              formatDataStreamPart("tool_call_streaming_start", {
                 toolCallId: chunk.toolCallId,
                 toolName: chunk.toolName
               })
@@ -4489,7 +4534,7 @@ var DefaultStreamTextResult = class {
           }
           case "tool-call-delta": {
             controller.enqueue(
-              formatStreamPart("tool_call_delta", {
+              formatDataStreamPart("tool_call_delta", {
                 toolCallId: chunk.toolCallId,
                 argsTextDelta: chunk.argsTextDelta
               })
@@ -4498,7 +4543,7 @@ var DefaultStreamTextResult = class {
           }
           case "tool-call": {
             controller.enqueue(
-              formatStreamPart("tool_call", {
+              formatDataStreamPart("tool_call", {
                 toolCallId: chunk.toolCallId,
                 toolName: chunk.toolName,
                 args: chunk.args
@@ -4508,7 +4553,7 @@ var DefaultStreamTextResult = class {
           }
           case "tool-result": {
             controller.enqueue(
-              formatStreamPart("tool_result", {
+              formatDataStreamPart("tool_result", {
                 toolCallId: chunk.toolCallId,
                 result: chunk.result
               })
@@ -4517,13 +4562,13 @@ var DefaultStreamTextResult = class {
           }
           case "error": {
             controller.enqueue(
-              formatStreamPart("error", getErrorMessage3(chunk.error))
+              formatDataStreamPart("error", getErrorMessage3(chunk.error))
             );
             break;
           }
           case "step-finish": {
             controller.enqueue(
-              formatStreamPart("finish_step", {
+              formatDataStreamPart("finish_step", {
                 finishReason: chunk.finishReason,
                 usage: sendUsage ? {
                   promptTokens: chunk.usage.promptTokens,
@@ -4536,7 +4581,7 @@ var DefaultStreamTextResult = class {
           }
           case "finish": {
             controller.enqueue(
-              formatStreamPart("finish_message", {
+              formatDataStreamPart("finish_message", {
                 finishReason: chunk.finishReason,
                 usage: sendUsage ? {
                   promptTokens: chunk.usage.promptTokens,
@@ -4806,7 +4851,7 @@ function magnitude(vector) {
 
 // streams/assistant-response.ts
 import {
-  formatStreamPart as formatStreamPart2
+  formatAssistantStreamPart
 } from "@ai-sdk/ui-utils";
 function AssistantResponse({ threadId, messageId }, process2) {
   const stream = new ReadableStream({
@@ -4815,17 +4860,21 @@ function AssistantResponse({ threadId, messageId }, process2) {
       const textEncoder = new TextEncoder();
       const sendMessage = (message) => {
         controller.enqueue(
-          textEncoder.encode(formatStreamPart2("assistant_message", message))
+          textEncoder.encode(
+            formatAssistantStreamPart("assistant_message", message)
+          )
         );
       };
       const sendDataMessage = (message) => {
         controller.enqueue(
-          textEncoder.encode(formatStreamPart2("data_message", message))
+          textEncoder.encode(
+            formatAssistantStreamPart("data_message", message)
+          )
         );
       };
       const sendError = (errorMessage) => {
         controller.enqueue(
-          textEncoder.encode(formatStreamPart2("error", errorMessage))
+          textEncoder.encode(formatAssistantStreamPart("error", errorMessage))
         );
       };
       const forwardStream = async (stream2) => {
@@ -4836,7 +4885,7 @@ function AssistantResponse({ threadId, messageId }, process2) {
             case "thread.message.created": {
               controller.enqueue(
                 textEncoder.encode(
-                  formatStreamPart2("assistant_message", {
+                  formatAssistantStreamPart("assistant_message", {
                     id: value.data.id,
                     role: "assistant",
                     content: [{ type: "text", text: { value: "" } }]
@@ -4850,7 +4899,7 @@ function AssistantResponse({ threadId, messageId }, process2) {
               if ((content == null ? void 0 : content.type) === "text" && ((_b = content.text) == null ? void 0 : _b.value) != null) {
                 controller.enqueue(
                   textEncoder.encode(
-                    formatStreamPart2("text", content.text.value)
+                    formatAssistantStreamPart("text", content.text.value)
                   )
                 );
               }
@@ -4867,7 +4916,7 @@ function AssistantResponse({ threadId, messageId }, process2) {
       };
       controller.enqueue(
         textEncoder.encode(
-          formatStreamPart2("assistant_control_data", {
+          formatAssistantStreamPart("assistant_control_data", {
             threadId,
             messageId
           })
@@ -4932,7 +4981,7 @@ function createCallbacksTransformer(callbacks = {}) {
 }
 
 // streams/stream-data.ts
-import { formatStreamPart as formatStreamPart3 } from "@ai-sdk/ui-utils";
+import { formatDataStreamPart as formatDataStreamPart2 } from "@ai-sdk/ui-utils";
 
 // util/constants.ts
 var HANGING_STREAM_WARNING_TIME_MS = 15 * 1e3;
@@ -4984,7 +5033,7 @@ var StreamData = class {
       throw new Error("Stream controller is not initialized.");
     }
     this.controller.enqueue(
-      this.encoder.encode(formatStreamPart3("data", [value]))
+      this.encoder.encode(formatDataStreamPart2("data", [value]))
     );
   }
   appendMessageAnnotation(value) {
@@ -4995,7 +5044,7 @@ var StreamData = class {
       throw new Error("Stream controller is not initialized.");
     }
     this.controller.enqueue(
-      this.encoder.encode(formatStreamPart3("message_annotations", [value]))
+      this.encoder.encode(formatDataStreamPart2("message_annotations", [value]))
     );
   }
 };
@@ -5005,7 +5054,7 @@ function createStreamDataTransformer() {
   return new TransformStream({
     transform: async (chunk, controller) => {
       const message = decoder.decode(chunk);
-      controller.enqueue(encoder.encode(formatStreamPart3("text", message)));
+      controller.enqueue(encoder.encode(formatDataStreamPart2("text", message)));
     }
   });
 }
@@ -5138,14 +5187,16 @@ export {
   experimental_createProviderRegistry,
   experimental_customProvider,
   experimental_wrapLanguageModel,
-  formatStreamPart4 as formatStreamPart,
+  formatAssistantStreamPart2 as formatAssistantStreamPart,
+  formatDataStreamPart3 as formatDataStreamPart,
   generateId2 as generateId,
   generateObject,
   generateText,
   jsonSchema,
-  parseStreamPart,
-  processDataProtocolResponse,
-  readDataStream,
+  parseAssistantStreamPart,
+  parseDataStreamPart,
+  processDataStream,
+  processTextStream,
   streamObject,
   streamText,
   tool