ai 4.0.0-canary.1 → 4.0.0-canary.11

package/dist/index.js

@@ -21,7 +21,6 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var streams_exports = {};
 __export(streams_exports, {
   AISDKError: () => import_provider13.AISDKError,
-  AIStream: () => AIStream,
   APICallError: () => import_provider13.APICallError,
   AssistantResponse: () => AssistantResponse,
   DownloadError: () => DownloadError,
@@ -43,48 +42,35 @@ __export(streams_exports, {
   NoSuchProviderError: () => NoSuchProviderError,
   NoSuchToolError: () => NoSuchToolError,
   RetryError: () => RetryError,
-  StreamData: () => StreamData2,
-  StreamingTextResponse: () => StreamingTextResponse,
+  StreamData: () => StreamData,
   TypeValidationError: () => import_provider13.TypeValidationError,
   UnsupportedFunctionalityError: () => import_provider13.UnsupportedFunctionalityError,
   convertToCoreMessages: () => convertToCoreMessages,
   cosineSimilarity: () => cosineSimilarity,
-  createCallbacksTransformer: () => createCallbacksTransformer,
-  createEventStreamTransformer: () => createEventStreamTransformer,
   createStreamDataTransformer: () => createStreamDataTransformer,
   embed: () => embed,
   embedMany: () => embedMany,
-  experimental_AssistantResponse: () => experimental_AssistantResponse,
-  experimental_StreamData: () => experimental_StreamData,
-  experimental_createModelRegistry: () => experimental_createModelRegistry,
   experimental_createProviderRegistry: () => experimental_createProviderRegistry,
   experimental_customProvider: () => experimental_customProvider,
-  experimental_generateObject: () => experimental_generateObject,
-  experimental_generateText: () => experimental_generateText,
-  experimental_streamObject: () => experimental_streamObject,
-  experimental_streamText: () => experimental_streamText,
   experimental_wrapLanguageModel: () => experimental_wrapLanguageModel,
-  formatStreamPart: () => import_ui_utils9.formatStreamPart,
-  generateId: () => generateId2,
+  formatStreamPart: () => import_ui_utils10.formatStreamPart,
+  generateId: () => import_provider_utils11.generateId,
   generateObject: () => generateObject,
   generateText: () => generateText,
-  jsonSchema: () => import_ui_utils6.jsonSchema,
-  parseStreamPart: () => import_ui_utils9.parseStreamPart,
-  processDataProtocolResponse: () => import_ui_utils9.processDataProtocolResponse,
-  readDataStream: () => import_ui_utils9.readDataStream,
-  readableFromAsyncIterable: () => readableFromAsyncIterable,
+  jsonSchema: () => import_ui_utils7.jsonSchema,
+  parseStreamPart: () => import_ui_utils10.parseStreamPart,
+  processDataProtocolResponse: () => import_ui_utils10.processDataProtocolResponse,
+  readDataStream: () => import_ui_utils10.readDataStream,
   streamObject: () => streamObject,
   streamText: () => streamText,
-  streamToResponse: () => streamToResponse,
-  tool: () => tool,
-  trimStartOfStreamHelper: () => trimStartOfStreamHelper
+  tool: () => tool
 });
 module.exports = __toCommonJS(streams_exports);
-var import_ui_utils9 = require("@ai-sdk/ui-utils");
-var import_provider_utils10 = require("@ai-sdk/provider-utils");
+var import_ui_utils10 = require("@ai-sdk/ui-utils");
+var import_provider_utils11 = require("@ai-sdk/provider-utils");
 
 // core/index.ts
-var import_ui_utils6 = require("@ai-sdk/ui-utils");
+var import_ui_utils7 = require("@ai-sdk/ui-utils");
 
 // util/retry-with-exponential-backoff.ts
 var import_provider2 = require("@ai-sdk/provider");
@@ -116,24 +102,6 @@ var RetryError = class extends import_provider.AISDKError {
   static isInstance(error) {
     return import_provider.AISDKError.hasMarker(error, marker);
   }
-  /**
-   * @deprecated use `isInstance` instead
-   */
-  static isRetryError(error) {
-    return error instanceof Error && error.name === name && typeof error.reason === "string" && Array.isArray(error.errors);
-  }
-  /**
-   * @deprecated Do not use this method. It will be removed in the next major version.
-   */
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      reason: this.reason,
-      lastError: this.lastError,
-      errors: this.errors
-    };
-  }
 };
 _a = symbol;
 
@@ -171,7 +139,7 @@ async function _retryWithExponentialBackoff(f, {
         errors: newErrors
       });
     }
-    if (error instanceof Error && import_provider2.APICallError.isAPICallError(error) && error.isRetryable === true && tryNumber <= maxRetries) {
+    if (error instanceof Error && import_provider2.APICallError.isInstance(error) && error.isRetryable === true && tryNumber <= maxRetries) {
       await delay(delayInMs);
       return _retryWithExponentialBackoff(
         f,
@@ -686,25 +654,6 @@ var DownloadError = class extends import_provider3.AISDKError {
   static isInstance(error) {
     return import_provider3.AISDKError.hasMarker(error, marker2);
   }
-  /**
-   * @deprecated use `isInstance` instead
-   */
-  static isDownloadError(error) {
-    return error instanceof Error && error.name === name2 && typeof error.url === "string" && (error.statusCode == null || typeof error.statusCode === "number") && (error.statusText == null || typeof error.statusText === "string");
-  }
-  /**
-   * @deprecated Do not use this method. It will be removed in the next major version.
-   */
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      url: this.url,
-      statusCode: this.statusCode,
-      statusText: this.statusText,
-      cause: this.cause
-    };
-  }
 };
 _a2 = symbol2;
 
@@ -774,24 +723,6 @@ var InvalidDataContentError = class extends import_provider4.AISDKError {
   static isInstance(error) {
     return import_provider4.AISDKError.hasMarker(error, marker3);
   }
-  /**
-   * @deprecated use `isInstance` instead
-   */
-  static isInvalidDataContentError(error) {
-    return error instanceof Error && error.name === name3 && error.content != null;
-  }
-  /**
-   * @deprecated Do not use this method. It will be removed in the next major version.
-   */
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      stack: this.stack,
-      cause: this.cause,
-      content: this.content
-    };
-  }
 };
 _a3 = symbol3;
 
@@ -865,23 +796,6 @@ var InvalidMessageRoleError = class extends import_provider5.AISDKError {
   static isInstance(error) {
     return import_provider5.AISDKError.hasMarker(error, marker4);
   }
-  /**
-   * @deprecated use `isInstance` instead
-   */
-  static isInvalidMessageRoleError(error) {
-    return error instanceof Error && error.name === name4 && typeof error.role === "string";
-  }
-  /**
-   * @deprecated Do not use this method. It will be removed in the next major version.
-   */
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      stack: this.stack,
-      role: this.role
-    };
-  }
 };
 _a4 = symbol4;
 
@@ -1109,21 +1023,6 @@ var InvalidArgumentError = class extends import_provider6.AISDKError {
   static isInstance(error) {
     return import_provider6.AISDKError.hasMarker(error, marker5);
   }
-  /**
-   * @deprecated use `isInstance` instead
-   */
-  static isInvalidArgumentError(error) {
-    return error instanceof Error && error.name === name5 && typeof error.parameter === "string" && typeof error.value === "string";
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      stack: this.stack,
-      parameter: this.parameter,
-      value: this.value
-    };
-  }
 };
 _a5 = symbol5;
 
@@ -1556,9 +1455,7 @@ function convertToCoreMessages(messages, options) {
         });
         break;
       }
-      case "function":
-      case "data":
-      case "tool": {
+      case "data": {
         break;
       }
       default: {
@@ -1646,28 +1543,30 @@ function standardizePrompt({
 }
 
 // core/types/usage.ts
-function calculateLanguageModelUsage(usage) {
+function calculateLanguageModelUsage({
+  promptTokens,
+  completionTokens
+}) {
   return {
-    promptTokens: usage.promptTokens,
-    completionTokens: usage.completionTokens,
-    totalTokens: usage.promptTokens + usage.completionTokens
+    promptTokens,
+    completionTokens,
+    totalTokens: promptTokens + completionTokens
   };
 }
 
 // core/util/prepare-response-headers.ts
-function prepareResponseHeaders(init, {
+function prepareResponseHeaders(headers, {
   contentType,
   dataStreamVersion
 }) {
-  var _a11;
-  const headers = new Headers((_a11 = init == null ? void 0 : init.headers) != null ? _a11 : {});
-  if (!headers.has("Content-Type")) {
-    headers.set("Content-Type", contentType);
+  const responseHeaders = new Headers(headers != null ? headers : {});
+  if (!responseHeaders.has("Content-Type")) {
+    responseHeaders.set("Content-Type", contentType);
   }
   if (dataStreamVersion !== void 0) {
-    headers.set("X-Vercel-AI-Data-Stream", dataStreamVersion);
+    responseHeaders.set("X-Vercel-AI-Data-Stream", dataStreamVersion);
   }
-  return headers;
+  return responseHeaders;
 }
 
 // core/generate-object/inject-json-instruction.ts
@@ -1705,23 +1604,6 @@ var NoObjectGeneratedError = class extends import_provider9.AISDKError {
   static isInstance(error) {
     return import_provider9.AISDKError.hasMarker(error, marker7);
   }
-  /**
-   * @deprecated Use isInstance instead.
-   */
-  static isNoObjectGeneratedError(error) {
-    return error instanceof Error && error.name === name7;
-  }
-  /**
-   * @deprecated Do not use this method. It will be removed in the next major version.
-   */
-  toJSON() {
-    return {
-      name: this.name,
-      cause: this.cause,
-      message: this.message,
-      stack: this.stack
-    };
-  }
 };
 _a7 = symbol7;
 
@@ -2253,9 +2135,6 @@ async function generateObject({
                       "ai.response.timestamp": responseData.timestamp.toISOString(),
                       "ai.usage.promptTokens": result2.usage.promptTokens,
                       "ai.usage.completionTokens": result2.usage.completionTokens,
-                      // deprecated:
-                      "ai.finishReason": result2.finishReason,
-                      "ai.result.object": { output: () => result2.text },
                       // standardized gen-ai llm span attributes:
                       "gen_ai.response.finish_reasons": [result2.finishReason],
                       "gen_ai.response.id": responseData.id,
@@ -2360,9 +2239,6 @@ async function generateObject({
                       "ai.response.timestamp": responseData.timestamp.toISOString(),
                       "ai.usage.promptTokens": result2.usage.promptTokens,
                       "ai.usage.completionTokens": result2.usage.completionTokens,
-                      // deprecated:
-                      "ai.finishReason": result2.finishReason,
-                      "ai.result.object": { output: () => objectText },
                       // standardized gen-ai llm span attributes:
                       "gen_ai.response.finish_reasons": [result2.finishReason],
                       "gen_ai.response.id": responseData.id,
@@ -2416,12 +2292,7 @@ async function generateObject({
               output: () => JSON.stringify(validationResult.value)
             },
             "ai.usage.promptTokens": usage.promptTokens,
-            "ai.usage.completionTokens": usage.completionTokens,
-            // deprecated:
-            "ai.finishReason": finishReason,
-            "ai.result.object": {
-              output: () => JSON.stringify(validationResult.value)
-            }
+            "ai.usage.completionTokens": usage.completionTokens
           }
         })
       );
@@ -2450,42 +2321,23 @@ var DefaultGenerateObjectResult = class {
     this.experimental_providerMetadata = options.providerMetadata;
     this.response = options.response;
     this.request = options.request;
-    this.rawResponse = {
-      headers: options.response.headers
-    };
     this.logprobs = options.logprobs;
   }
   toJsonResponse(init) {
     var _a11;
     return new Response(JSON.stringify(this.object), {
       status: (_a11 = init == null ? void 0 : init.status) != null ? _a11 : 200,
-      headers: prepareResponseHeaders(init, {
+      headers: prepareResponseHeaders(init == null ? void 0 : init.headers, {
         contentType: "application/json; charset=utf-8"
       })
     });
   }
 };
-var experimental_generateObject = generateObject;
 
 // core/generate-object/stream-object.ts
 var import_provider_utils6 = require("@ai-sdk/provider-utils");
 var import_ui_utils2 = require("@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() {
@@ -2531,23 +2383,23 @@ function now() {
 }
 
 // core/util/prepare-outgoing-http-headers.ts
-function prepareOutgoingHttpHeaders(init, {
+function prepareOutgoingHttpHeaders(headers, {
   contentType,
   dataStreamVersion
 }) {
-  const headers = {};
-  if ((init == null ? void 0 : init.headers) != null) {
-    for (const [key, value] of Object.entries(init.headers)) {
-      headers[key] = value;
+  const outgoingHeaders = {};
+  if (headers != null) {
+    for (const [key, value] of Object.entries(headers)) {
+      outgoingHeaders[key] = value;
     }
   }
-  if (headers["Content-Type"] == null) {
-    headers["Content-Type"] = contentType;
+  if (outgoingHeaders["Content-Type"] == null) {
+    outgoingHeaders["Content-Type"] = contentType;
   }
   if (dataStreamVersion !== void 0) {
-    headers["X-Vercel-AI-Data-Stream"] = dataStreamVersion;
+    outgoingHeaders["X-Vercel-AI-Data-Stream"] = dataStreamVersion;
   }
-  return headers;
+  return outgoingHeaders;
 }
 
 // core/util/write-to-server-response.ts
@@ -2577,9 +2429,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 = (0, import_provider_utils6.createIdGenerator)({ prefix: "aiobj", size: 24 });
-async function streamObject({
+function streamObject({
   model,
   schema: inputSchema,
   schemaName,
@@ -2613,407 +2547,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 }
-  });
-  const tracer = getTracer(telemetry);
-  const retry = retryWithExponentialBackoff({ maxRetries });
-  return 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
-            }),
-            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;
-              }
-            }
-          };
-          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,
-            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}`);
-        }
-      }
-      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)
-          })
-        })
-      );
-      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
-      });
-    }
+    settings,
+    maxRetries,
+    abortSignal,
+    outputStrategy,
+    system,
+    prompt,
+    messages,
+    schemaName,
+    schemaDescription,
+    inputProviderMetadata: providerMetadata,
+    mode,
+    onFinish,
+    generateId: generateId3,
+    currentDate,
+    now: now2
   });
 }
 var DefaultStreamObjectResult = class {
   constructor({
-    stream,
-    warnings,
-    rawResponse,
-    request,
+    model,
+    headers,
+    telemetry,
+    settings,
+    maxRetries,
+    abortSignal,
     outputStrategy,
+    system,
+    prompt,
+    messages,
+    schemaName,
+    schemaDescription,
+    inputProviderMetadata,
+    mode,
     onFinish,
-    rootSpan,
-    doStreamSpan,
-    telemetry,
-    startTimestampMs,
-    modelId,
-    now: now2,
+    generateId: generateId3,
     currentDate,
-    generateId: generateId3
+    now: now2
   }) {
-    this.warnings = warnings;
-    this.rawResponse = rawResponse;
-    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;
+    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,
+      headers,
+      settings: { ...settings, maxRetries }
+    });
+    const tracer = getTracer(telemetry);
+    const retry = retryWithExponentialBackoff({ maxRetries });
     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
+    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
             });
-            doStreamSpan.setAttributes({
-              "ai.stream.msToFirstChunk": msToFirstChunk
+            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: 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;
+          }
+          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;
           }
-          if (typeof chunk === "string") {
-            accumulatedText += chunk;
-            textDelta += chunk;
-            const { value: currentObjectJson, state: parseState } = (0, import_ui_utils2.parsePartialJson)(accumulatedText);
-            if (currentObjectJson !== void 0 && !(0, import_ui_utils2.isDeepEqualData)(latestObjectJson, currentObjectJson)) {
-              const validationResult = outputStrategy.validatePartialResult({
-                value: currentObjectJson,
-                textDelta,
-                latestObject,
-                isFirstDelta,
-                isFinalDelta: parseState === "successful-parse"
-              });
-              if (validationResult.success && !(0, import_ui_utils2.isDeepEqualData)(latestObject, validationResult.value.partial)) {
-                latestObjectJson = currentObjectJson;
-                latestObject = validationResult.value.partial;
-                controller.enqueue({
-                  type: "object",
-                  object: latestObject
+          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.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
                 });
-                controller.enqueue({
-                  type: "text-delta",
-                  textDelta: validationResult.value.textDelta
+                doStreamSpan.setAttributes({
+                  "ai.stream.msToFirstChunk": msToFirstChunk
                 });
-                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);
+              if (typeof chunk === "string") {
+                accumulatedText += chunk;
+                textDelta += chunk;
+                const { value: currentObjectJson, state: parseState } = (0, import_ui_utils2.parsePartialJson)(accumulatedText);
+                if (currentObjectJson !== void 0 && !(0, import_ui_utils2.isDeepEqualData)(latestObjectJson, currentObjectJson)) {
+                  const validationResult = outputStrategy.validatePartialResult({
+                    value: currentObjectJson,
+                    textDelta,
+                    latestObject,
+                    isFirstDelta,
+                    isFinalDelta: parseState === "successful-parse"
+                  });
+                  if (validationResult.success && !(0, import_ui_utils2.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;
               }
-              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,
-                  // deprecated
-                  "ai.finishReason": finishReason,
-                  "ai.result.object": { output: () => JSON.stringify(object) },
-                  // 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
+              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;
                 }
-              })
-            );
-            doStreamSpan.end();
-            rootSpan.setAttributes(
-              selectTelemetryAttributes({
-                telemetry,
-                attributes: {
-                  "ai.usage.promptTokens": finalUsage.promptTokens,
-                  "ai.usage.completionTokens": finalUsage.completionTokens,
-                  "ai.response.object": {
-                    output: () => JSON.stringify(object)
-                  },
-                  // deprecated
-                  "ai.result.object": { output: () => JSON.stringify(object) }
+                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;
                 }
-              })
-            );
-            await (onFinish == null ? void 0 : onFinish({
-              usage: finalUsage,
-              object,
-              error,
-              rawResponse,
-              response: {
-                ...response,
-                headers: rawResponse == null ? void 0 : rawResponse.headers
-              },
-              warnings,
-              experimental_providerMetadata: providerMetadata
-            }));
-          } catch (error2) {
-            controller.error(error2);
-          } finally {
-            rootSpan.end();
+                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();
+              }
+            }
+          })
+        );
+        self.stitchableStream.addStream(transformedStream);
+      }
+    }).catch((error) => {
+      self.stitchableStream.addStream(
+        new ReadableStream({
+          start(controller) {
+            controller.error(error);
           }
-        }
-      })
-    );
+        })
+      );
+    }).finally(() => {
+      self.stitchableStream.close();
+    });
+    this.outputStrategy = outputStrategy;
   }
   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":
@@ -3034,10 +2994,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":
@@ -3058,7 +3020,7 @@ var DefaultStreamObjectResult = class {
     });
   }
   get fullStream() {
-    return createAsyncIterableStream(this.originalStream, {
+    return createAsyncIterableStream(this.stitchableStream.stream, {
       transform(chunk, controller) {
         controller.enqueue(chunk);
       }
@@ -3069,7 +3031,7 @@ var DefaultStreamObjectResult = class {
       response,
       status: init == null ? void 0 : init.status,
       statusText: init == null ? void 0 : init.statusText,
-      headers: prepareOutgoingHttpHeaders(init, {
+      headers: prepareOutgoingHttpHeaders(init == null ? void 0 : init.headers, {
         contentType: "text/plain; charset=utf-8"
       }),
       stream: this.textStream.pipeThrough(new TextEncoderStream())
@@ -3079,13 +3041,12 @@ var DefaultStreamObjectResult = class {
     var _a11;
     return new Response(this.textStream.pipeThrough(new TextEncoderStream()), {
       status: (_a11 = init == null ? void 0 : init.status) != null ? _a11 : 200,
-      headers: prepareResponseHeaders(init, {
+      headers: prepareResponseHeaders(init == null ? void 0 : init.headers, {
         contentType: "text/plain; charset=utf-8"
       })
     });
   }
 };
-var experimental_streamObject = streamObject;
 
 // core/generate-text/generate-text.ts
 var import_provider_utils8 = require("@ai-sdk/provider-utils");
@@ -3116,25 +3077,6 @@ var InvalidToolArgumentsError = class extends import_provider11.AISDKError {
   static isInstance(error) {
     return import_provider11.AISDKError.hasMarker(error, marker8);
   }
-  /**
-   * @deprecated use `isInstance` instead
-   */
-  static isInvalidToolArgumentsError(error) {
-    return error instanceof Error && error.name === name8 && typeof error.toolName === "string" && typeof error.toolArgs === "string";
-  }
-  /**
-   * @deprecated Do not use this method. It will be removed in the next major version.
-   */
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      cause: this.cause,
-      stack: this.stack,
-      toolName: this.toolName,
-      toolArgs: this.toolArgs
-    };
-  }
 };
 _a8 = symbol8;
 
@@ -3158,24 +3100,6 @@ var NoSuchToolError = class extends import_provider12.AISDKError {
   static isInstance(error) {
     return import_provider12.AISDKError.hasMarker(error, marker9);
   }
-  /**
-   * @deprecated use `isInstance` instead
-   */
-  static isNoSuchToolError(error) {
-    return error instanceof Error && error.name === name9 && "toolName" in error && error.toolName != void 0 && typeof error.name === "string";
-  }
-  /**
-   * @deprecated Do not use this method. It will be removed in the next major version.
-   */
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      stack: this.stack,
-      toolName: this.toolName,
-      availableTools: this.availableTools
-    };
-  }
 };
 _a9 = symbol9;
 
@@ -3328,11 +3252,8 @@ async function generateText({
   maxRetries,
   abortSignal,
   headers,
-  maxAutomaticRoundtrips = 0,
-  maxToolRoundtrips = maxAutomaticRoundtrips,
-  maxSteps = maxToolRoundtrips != null ? maxToolRoundtrips + 1 : 1,
-  experimental_continuationSteps,
-  experimental_continueSteps: continueSteps = experimental_continuationSteps != null ? experimental_continuationSteps : false,
+  maxSteps = 1,
+  experimental_continueSteps: continueSteps = false,
   experimental_telemetry: telemetry,
   experimental_providerMetadata: providerMetadata,
   experimental_activeTools: activeTools,
@@ -3484,14 +3405,6 @@ async function generateText({
                     "ai.response.timestamp": responseData.timestamp.toISOString(),
                     "ai.usage.promptTokens": result.usage.promptTokens,
                     "ai.usage.completionTokens": result.usage.completionTokens,
-                    // deprecated:
-                    "ai.finishReason": result.finishReason,
-                    "ai.result.text": {
-                      output: () => result.text
-                    },
-                    "ai.result.toolCalls": {
-                      output: () => JSON.stringify(result.toolCalls)
-                    },
                     // standardized gen-ai llm span attributes:
                     "gen_ai.response.finish_reasons": [result.finishReason],
                     "gen_ai.response.id": responseData.id,
@@ -3594,15 +3507,7 @@ async function generateText({
               output: () => JSON.stringify(currentModelResponse.toolCalls)
             },
             "ai.usage.promptTokens": currentModelResponse.usage.promptTokens,
-            "ai.usage.completionTokens": currentModelResponse.usage.completionTokens,
-            // deprecated:
-            "ai.finishReason": currentModelResponse.finishReason,
-            "ai.result.text": {
-              output: () => currentModelResponse.text
-            },
-            "ai.result.toolCalls": {
-              output: () => JSON.stringify(currentModelResponse.toolCalls)
-            }
+            "ai.usage.completionTokens": currentModelResponse.usage.completionTokens
           }
         })
       );
@@ -3620,7 +3525,6 @@ async function generateText({
           messages: responseMessages
         },
         logprobs: currentModelResponse.logprobs,
-        responseMessages,
         steps,
         providerMetadata: currentModelResponse.providerMetadata
       });
@@ -3697,105 +3601,38 @@ var DefaultGenerateTextResult = class {
     this.warnings = options.warnings;
     this.request = options.request;
     this.response = options.response;
-    this.responseMessages = options.responseMessages;
-    this.roundtrips = options.steps;
     this.steps = options.steps;
     this.experimental_providerMetadata = options.providerMetadata;
-    this.rawResponse = {
-      headers: options.response.headers
-    };
     this.logprobs = options.logprobs;
   }
 };
-var experimental_generateText = generateText;
 
 // core/generate-text/stream-text.ts
 var import_provider_utils9 = require("@ai-sdk/provider-utils");
+var import_ui_utils6 = require("@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;
-    }
+// core/util/merge-streams.ts
+function mergeStreams(stream1, stream2) {
+  const reader1 = stream1.getReader();
+  const reader2 = stream2.getReader();
+  let lastRead1 = void 0;
+  let lastRead2 = void 0;
+  let stream1Done = false;
+  let stream2Done = false;
+  async function readStream1(controller) {
     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();
-        }
+      if (lastRead1 == null) {
+        lastRead1 = reader1.read();
+      }
+      const result = await lastRead1;
+      lastRead1 = void 0;
+      if (!result.done) {
+        controller.enqueue(result.value);
       } else {
-        controller == null ? void 0 : controller.enqueue(value);
+        controller.close();
       }
     } 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();
-      }
-    }
-  };
-}
-
-// core/util/merge-streams.ts
-function mergeStreams(stream1, stream2) {
-  const reader1 = stream1.getReader();
-  const reader2 = stream2.getReader();
-  let lastRead1 = void 0;
-  let lastRead2 = void 0;
-  let stream1Done = false;
-  let stream2Done = false;
-  async function readStream1(controller) {
-    try {
-      if (lastRead1 == null) {
-        lastRead1 = reader1.read();
-      }
-      const result = await lastRead1;
-      lastRead1 = void 0;
-      if (!result.done) {
-        controller.enqueue(result.value);
-      } else {
-        controller.close();
-      }
-    } catch (error) {
-      controller.error(error);
+      controller.error(error);
     }
   }
   async function readStream2(controller) {
@@ -4057,7 +3894,7 @@ function runToolsTransformation({
 
 // core/generate-text/stream-text.ts
 var originalGenerateId4 = (0, import_provider_utils9.createIdGenerator)({ prefix: "aitxt", size: 24 });
-async function streamText({
+function streamText({
   model,
   tools,
   toolChoice,
@@ -4067,8 +3904,7 @@ async function streamText({
   maxRetries,
   abortSignal,
   headers,
-  maxToolRoundtrips = 0,
-  maxSteps = maxToolRoundtrips != null ? maxToolRoundtrips + 1 : 1,
+  maxSteps = 1,
   experimental_continueSteps: continueSteps = false,
   experimental_telemetry: telemetry,
   experimental_providerMetadata: providerMetadata,
@@ -4091,598 +3927,606 @@ async function streamText({
       message: "maxSteps must be at least 1"
     });
   }
-  const baseTelemetryAttributes = getBaseTelemetryAttributes({
+  return new DefaultStreamTextResult({
     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
-      });
-    }
+    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.warnings = 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: resolveResponseMessages,
-      promise: responseMessagesPromise
-    } = createResolvablePromise();
-    this.responseMessages = responseMessagesPromise;
-    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();
+    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,
-                  // deprecated:
-                  "ai.stream.msToFirstChunk": msToFirstChunk
-                });
-                doStreamSpan2.setAttributes({
-                  "ai.response.msToFirstChunk": msToFirstChunk,
-                  // deprecated:
-                  "ai.stream.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
-                        }
-                      });
+    const stepResults = [];
+    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));
                     }
-                  } 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}`);
+                  },
+                  "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
             },
-            // invoke onFinish callback and resolve toolResults promise when the stream is about to close:
-            async flush(controller) {
-              var _a11;
-              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
+            doStreamSpan: doStreamSpan2,
+            startTimestampMs: startTimestampMs2
+          };
+        };
+        const {
+          result: { stream, warnings, rawResponse, request },
+          doStreamSpan,
+          startTimestampMs
+        } = await startStep({ responseMessages: [] });
+        function addStepStream({
+          stream: stream2,
+          startTimestamp,
+          doStreamSpan: doStreamSpan2,
+          currentStep,
+          responseMessages,
+          usage = {
+            promptTokens: 0,
+            completionTokens: 0,
+            totalTokens: 0
+          },
+          stepType,
+          previousStepText = "",
+          stepRequest,
+          hasLeadingWhitespace,
+          warnings: warnings2,
+          response
+        }) {
+          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(
+            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
+                    });
                   }
-                });
-                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,
-                      // deprecated
-                      "ai.finishReason": stepFinishReason,
-                      "ai.result.text": { output: () => stepText },
-                      "ai.result.toolCalls": {
-                        output: () => stepToolCallsJson
-                      },
-                      // 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
+                  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;
                     }
-                  })
-                );
-              } catch (error) {
-              } finally {
-                doStreamSpan2.end();
-              }
-              controller.enqueue({
-                type: "step-finish",
-                finishReason: stepFinishReason,
-                usage: stepUsage,
-                experimental_providerMetadata: stepProviderMetadata,
-                logprobs: stepLogProbs,
-                response: {
-                  ...stepResponse
+                    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}`);
+                    }
+                  }
                 },
-                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 {
+                    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
+                        }
+                      })
+                    );
+                  } catch (error) {
+                  } finally {
+                    doStreamSpan2.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.warnings,
-                logprobs: stepLogProbs,
-                request: stepRequest,
-                rawResponse: self.rawResponse,
-                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.warnings = 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: warnings2,
+                    logprobs: stepLogProbs,
+                    request: stepRequest,
+                    response: {
+                      ...stepResponse,
+                      headers: response == null ? void 0 : response.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 });
+                    warnings2 = result.warnings;
+                    response = 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,
+                      warnings: warnings2,
+                      response
+                    });
+                    return;
                   }
-                });
-                closeStitchableStream();
-                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,
-                      // deprecated
-                      "ai.finishReason": stepFinishReason,
-                      "ai.result.text": { output: () => fullStepText },
-                      "ai.result.toolCalls": {
-                        output: () => stepToolCallsJson
+                  try {
+                    controller.enqueue({
+                      type: "finish",
+                      finishReason: stepFinishReason,
+                      usage: combinedUsage,
+                      experimental_providerMetadata: stepProviderMetadata,
+                      logprobs: stepLogProbs,
+                      response: {
+                        ...stepResponse
                       }
-                    }
-                  })
-                );
-                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);
-                resolveResponseMessages(responseMessages);
-                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,
-                  rawResponse,
-                  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();
-              }
-            }
-          })
-        )
+                    });
+                    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(warnings2 != null ? warnings2 : []);
+                    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: warnings2,
+                      experimental_providerMetadata: stepProviderMetadata,
+                      steps: stepResults
+                    }));
+                  } catch (error) {
+                    controller.error(error);
+                  } finally {
+                    rootSpan.end();
+                  }
+                }
+              })
+            )
+          );
+        }
+        addStepStream({
+          stream,
+          startTimestamp: startTimestampMs,
+          doStreamSpan,
+          currentStep: 0,
+          responseMessages: [],
+          usage: void 0,
+          stepType: "initial",
+          stepRequest: request,
+          hasLeadingWhitespace: false,
+          warnings,
+          response: rawResponse
+        });
+      }
+    }).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,
@@ -4692,8 +4536,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() {
@@ -4714,37 +4558,18 @@ var DefaultStreamTextResult = class {
       }
     });
   }
-  toAIStream(callbacks = {}) {
-    return this.toDataStreamInternal({ callbacks });
-  }
   toDataStreamInternal({
-    callbacks = {},
     getErrorMessage: getErrorMessage3 = () => "",
     // mask error messages for safety by default
     sendUsage = true
   } = {}) {
     let aggregatedResponse = "";
     const callbackTransformer = new TransformStream({
-      async start() {
-        if (callbacks.onStart)
-          await callbacks.onStart();
-      },
       async transform(chunk, controller) {
         controller.enqueue(chunk);
         if (chunk.type === "text-delta") {
-          const textDelta = chunk.textDelta;
-          aggregatedResponse += textDelta;
-          if (callbacks.onToken)
-            await callbacks.onToken(textDelta);
-          if (callbacks.onText)
-            await callbacks.onText(textDelta);
+          aggregatedResponse += chunk.textDelta;
         }
-      },
-      async flush() {
-        if (callbacks.onCompletion)
-          await callbacks.onCompletion(aggregatedResponse);
-        if (callbacks.onFinal)
-          await callbacks.onFinal(aggregatedResponse);
       }
     });
     const streamPartsTransformer = new TransformStream({
@@ -4752,12 +4577,12 @@ var DefaultStreamTextResult = class {
         const chunkType = chunk.type;
         switch (chunkType) {
           case "text-delta": {
-            controller.enqueue((0, import_ui_utils9.formatStreamPart)("text", chunk.textDelta));
+            controller.enqueue((0, import_ui_utils6.formatStreamPart)("text", chunk.textDelta));
             break;
           }
           case "tool-call-streaming-start": {
             controller.enqueue(
-              (0, import_ui_utils9.formatStreamPart)("tool_call_streaming_start", {
+              (0, import_ui_utils6.formatStreamPart)("tool_call_streaming_start", {
                 toolCallId: chunk.toolCallId,
                 toolName: chunk.toolName
               })
@@ -4766,7 +4591,7 @@ var DefaultStreamTextResult = class {
           }
           case "tool-call-delta": {
             controller.enqueue(
-              (0, import_ui_utils9.formatStreamPart)("tool_call_delta", {
+              (0, import_ui_utils6.formatStreamPart)("tool_call_delta", {
                 toolCallId: chunk.toolCallId,
                 argsTextDelta: chunk.argsTextDelta
               })
@@ -4775,7 +4600,7 @@ var DefaultStreamTextResult = class {
           }
           case "tool-call": {
             controller.enqueue(
-              (0, import_ui_utils9.formatStreamPart)("tool_call", {
+              (0, import_ui_utils6.formatStreamPart)("tool_call", {
                 toolCallId: chunk.toolCallId,
                 toolName: chunk.toolName,
                 args: chunk.args
@@ -4785,7 +4610,7 @@ var DefaultStreamTextResult = class {
           }
           case "tool-result": {
             controller.enqueue(
-              (0, import_ui_utils9.formatStreamPart)("tool_result", {
+              (0, import_ui_utils6.formatStreamPart)("tool_result", {
                 toolCallId: chunk.toolCallId,
                 result: chunk.result
               })
@@ -4794,13 +4619,13 @@ var DefaultStreamTextResult = class {
           }
           case "error": {
             controller.enqueue(
-              (0, import_ui_utils9.formatStreamPart)("error", getErrorMessage3(chunk.error))
+              (0, import_ui_utils6.formatStreamPart)("error", getErrorMessage3(chunk.error))
             );
             break;
           }
           case "step-finish": {
             controller.enqueue(
-              (0, import_ui_utils9.formatStreamPart)("finish_step", {
+              (0, import_ui_utils6.formatStreamPart)("finish_step", {
                 finishReason: chunk.finishReason,
                 usage: sendUsage ? {
                   promptTokens: chunk.usage.promptTokens,
@@ -4813,7 +4638,7 @@ var DefaultStreamTextResult = class {
           }
           case "finish": {
             controller.enqueue(
-              (0, import_ui_utils9.formatStreamPart)("finish_message", {
+              (0, import_ui_utils6.formatStreamPart)("finish_message", {
                 finishReason: chunk.finishReason,
                 usage: sendUsage ? {
                   promptTokens: chunk.usage.promptTokens,
@@ -4832,23 +4657,19 @@ var DefaultStreamTextResult = class {
     });
     return this.fullStream.pipeThrough(callbackTransformer).pipeThrough(streamPartsTransformer).pipeThrough(new TextEncoderStream());
   }
-  pipeAIStreamToResponse(response, init) {
-    return this.pipeDataStreamToResponse(response, init);
-  }
-  pipeDataStreamToResponse(response, options) {
-    const init = options == null ? void 0 : "init" in options ? options.init : {
-      headers: "headers" in options ? options.headers : void 0,
-      status: "status" in options ? options.status : void 0,
-      statusText: "statusText" in options ? options.statusText : void 0
-    };
-    const data = options == null ? void 0 : "data" in options ? options.data : void 0;
-    const getErrorMessage3 = options == null ? void 0 : "getErrorMessage" in options ? options.getErrorMessage : void 0;
-    const sendUsage = options == null ? void 0 : "sendUsage" in options ? options.sendUsage : void 0;
+  pipeDataStreamToResponse(response, {
+    status,
+    statusText,
+    headers,
+    data,
+    getErrorMessage: getErrorMessage3,
+    sendUsage
+  } = {}) {
     writeToServerResponse({
       response,
-      status: init == null ? void 0 : init.status,
-      statusText: init == null ? void 0 : init.statusText,
-      headers: prepareOutgoingHttpHeaders(init, {
+      status,
+      statusText,
+      headers: prepareOutgoingHttpHeaders(headers, {
         contentType: "text/plain; charset=utf-8",
         dataStreamVersion: "v1"
       }),
@@ -4860,15 +4681,12 @@ var DefaultStreamTextResult = class {
       response,
       status: init == null ? void 0 : init.status,
       statusText: init == null ? void 0 : init.statusText,
-      headers: prepareOutgoingHttpHeaders(init, {
+      headers: prepareOutgoingHttpHeaders(init == null ? void 0 : init.headers, {
         contentType: "text/plain; charset=utf-8"
       }),
       stream: this.textStream.pipeThrough(new TextEncoderStream())
     });
   }
-  toAIStreamResponse(options) {
-    return this.toDataStreamResponse(options);
-  }
   toDataStream(options) {
     const stream = this.toDataStreamInternal({
       getErrorMessage: options == null ? void 0 : options.getErrorMessage,
@@ -4876,22 +4694,20 @@ var DefaultStreamTextResult = class {
     });
     return (options == null ? void 0 : options.data) ? mergeStreams(options == null ? void 0 : options.data.stream, stream) : stream;
   }
-  toDataStreamResponse(options) {
-    var _a11;
-    const init = options == null ? void 0 : "init" in options ? options.init : {
-      headers: "headers" in options ? options.headers : void 0,
-      status: "status" in options ? options.status : void 0,
-      statusText: "statusText" in options ? options.statusText : void 0
-    };
-    const data = options == null ? void 0 : "data" in options ? options.data : void 0;
-    const getErrorMessage3 = options == null ? void 0 : "getErrorMessage" in options ? options.getErrorMessage : void 0;
-    const sendUsage = options == null ? void 0 : "sendUsage" in options ? options.sendUsage : void 0;
+  toDataStreamResponse({
+    headers,
+    status,
+    statusText,
+    data,
+    getErrorMessage: getErrorMessage3,
+    sendUsage
+  } = {}) {
     return new Response(
       this.toDataStream({ data, getErrorMessage: getErrorMessage3, sendUsage }),
       {
-        status: (_a11 = init == null ? void 0 : init.status) != null ? _a11 : 200,
-        statusText: init == null ? void 0 : init.statusText,
-        headers: prepareResponseHeaders(init, {
+        status,
+        statusText,
+        headers: prepareResponseHeaders(headers, {
           contentType: "text/plain; charset=utf-8",
           dataStreamVersion: "v1"
         })
@@ -4902,13 +4718,12 @@ var DefaultStreamTextResult = class {
     var _a11;
     return new Response(this.textStream.pipeThrough(new TextEncoderStream()), {
       status: (_a11 = init == null ? void 0 : init.status) != null ? _a11 : 200,
-      headers: prepareResponseHeaders(init, {
+      headers: prepareResponseHeaders(init == null ? void 0 : init.headers, {
         contentType: "text/plain; charset=utf-8"
       })
     });
   }
 };
-var experimental_streamText = streamText;
 
 // core/middleware/wrap-language-model.ts
 var experimental_wrapLanguageModel = ({
@@ -4995,26 +4810,6 @@ var NoSuchProviderError = class extends import_provider15.NoSuchModelError {
   static isInstance(error) {
     return import_provider15.AISDKError.hasMarker(error, marker10);
   }
-  /**
-   * @deprecated use `isInstance` instead
-   */
-  static isNoSuchProviderError(error) {
-    return error instanceof Error && error.name === name10 && typeof error.providerId === "string" && Array.isArray(error.availableProviders);
-  }
-  /**
-   * @deprecated Do not use this method. It will be removed in the next major version.
-   */
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      stack: this.stack,
-      modelId: this.modelId,
-      modelType: this.modelType,
-      providerId: this.providerId,
-      availableProviders: this.availableProviders
-    };
-  }
 };
 _a10 = symbol10;
 
@@ -5027,15 +4822,11 @@ function experimental_createProviderRegistry(providers) {
   }
   return registry;
 }
-var experimental_createModelRegistry = experimental_createProviderRegistry;
 var DefaultProviderRegistry = class {
   constructor() {
     this.providers = {};
   }
-  registerProvider({
-    id,
-    provider
-  }) {
+  registerProvider({ id, provider }) {
     this.providers[id] = provider;
   }
   getProvider(id) {
@@ -5071,10 +4862,10 @@ var DefaultProviderRegistry = class {
     return model;
   }
   textEmbeddingModel(id) {
-    var _a11, _b, _c;
+    var _a11;
     const [providerId, modelId] = this.splitId(id, "textEmbeddingModel");
     const provider = this.getProvider(providerId);
-    const model = (_c = (_a11 = provider.textEmbeddingModel) == null ? void 0 : _a11.call(provider, modelId)) != null ? _c : "textEmbedding" in provider ? (_b = provider.textEmbedding) == null ? void 0 : _b.call(provider, modelId) : void 0;
+    const model = (_a11 = provider.textEmbeddingModel) == null ? void 0 : _a11.call(provider, modelId);
     if (model == null) {
       throw new import_provider16.NoSuchModelError({
         modelId: id,
@@ -5115,123 +4906,8 @@ function magnitude(vector) {
   return Math.sqrt(dotProduct(vector, vector));
 }
 
-// streams/ai-stream.ts
-var import_eventsource_parser = require("eventsource-parser");
-function createEventStreamTransformer(customParser) {
-  const textDecoder = new TextDecoder();
-  let eventSourceParser;
-  return new TransformStream({
-    async start(controller) {
-      eventSourceParser = (0, import_eventsource_parser.createParser)(
-        (event) => {
-          if ("data" in event && event.type === "event" && event.data === "[DONE]" || // Replicate doesn't send [DONE] but does send a 'done' event
-          // @see https://replicate.com/docs/streaming
-          event.event === "done") {
-            controller.terminate();
-            return;
-          }
-          if ("data" in event) {
-            const parsedMessage = customParser ? customParser(event.data, {
-              event: event.event
-            }) : event.data;
-            if (parsedMessage)
-              controller.enqueue(parsedMessage);
-          }
-        }
-      );
-    },
-    transform(chunk) {
-      eventSourceParser.feed(textDecoder.decode(chunk));
-    }
-  });
-}
-function createCallbacksTransformer(cb) {
-  const textEncoder = new TextEncoder();
-  let aggregatedResponse = "";
-  const callbacks = cb || {};
-  return new TransformStream({
-    async start() {
-      if (callbacks.onStart)
-        await callbacks.onStart();
-    },
-    async transform(message, controller) {
-      const content = typeof message === "string" ? message : message.content;
-      controller.enqueue(textEncoder.encode(content));
-      aggregatedResponse += content;
-      if (callbacks.onToken)
-        await callbacks.onToken(content);
-      if (callbacks.onText && typeof message === "string") {
-        await callbacks.onText(message);
-      }
-    },
-    async flush() {
-      if (callbacks.onCompletion) {
-        await callbacks.onCompletion(aggregatedResponse);
-      }
-    }
-  });
-}
-function trimStartOfStreamHelper() {
-  let isStreamStart = true;
-  return (text) => {
-    if (isStreamStart) {
-      text = text.trimStart();
-      if (text)
-        isStreamStart = false;
-    }
-    return text;
-  };
-}
-function AIStream(response, customParser, callbacks) {
-  if (!response.ok) {
-    if (response.body) {
-      const reader = response.body.getReader();
-      return new ReadableStream({
-        async start(controller) {
-          const { done, value } = await reader.read();
-          if (!done) {
-            const errorText = new TextDecoder().decode(value);
-            controller.error(new Error(`Response error: ${errorText}`));
-          }
-        }
-      });
-    } else {
-      return new ReadableStream({
-        start(controller) {
-          controller.error(new Error("Response error: No response body"));
-        }
-      });
-    }
-  }
-  const responseBodyStream = response.body || createEmptyReadableStream();
-  return responseBodyStream.pipeThrough(createEventStreamTransformer(customParser)).pipeThrough(createCallbacksTransformer(callbacks));
-}
-function createEmptyReadableStream() {
-  return new ReadableStream({
-    start(controller) {
-      controller.close();
-    }
-  });
-}
-function readableFromAsyncIterable(iterable) {
-  let it = iterable[Symbol.asyncIterator]();
-  return new ReadableStream({
-    async pull(controller) {
-      const { done, value } = await it.next();
-      if (done)
-        controller.close();
-      else
-        controller.enqueue(value);
-    },
-    async cancel(reason) {
-      var _a11;
-      await ((_a11 = it.return) == null ? void 0 : _a11.call(it, reason));
-    }
-  });
-}
-
 // streams/assistant-response.ts
-var import_ui_utils7 = require("@ai-sdk/ui-utils");
+var import_ui_utils8 = require("@ai-sdk/ui-utils");
 function AssistantResponse({ threadId, messageId }, process2) {
   const stream = new ReadableStream({
     async start(controller) {
@@ -5239,17 +4915,17 @@ function AssistantResponse({ threadId, messageId }, process2) {
       const textEncoder = new TextEncoder();
       const sendMessage = (message) => {
         controller.enqueue(
-          textEncoder.encode((0, import_ui_utils7.formatStreamPart)("assistant_message", message))
+          textEncoder.encode((0, import_ui_utils8.formatStreamPart)("assistant_message", message))
         );
       };
       const sendDataMessage = (message) => {
         controller.enqueue(
-          textEncoder.encode((0, import_ui_utils7.formatStreamPart)("data_message", message))
+          textEncoder.encode((0, import_ui_utils8.formatStreamPart)("data_message", message))
         );
       };
       const sendError = (errorMessage) => {
         controller.enqueue(
-          textEncoder.encode((0, import_ui_utils7.formatStreamPart)("error", errorMessage))
+          textEncoder.encode((0, import_ui_utils8.formatStreamPart)("error", errorMessage))
         );
       };
       const forwardStream = async (stream2) => {
@@ -5260,7 +4936,7 @@ function AssistantResponse({ threadId, messageId }, process2) {
             case "thread.message.created": {
               controller.enqueue(
                 textEncoder.encode(
-                  (0, import_ui_utils7.formatStreamPart)("assistant_message", {
+                  (0, import_ui_utils8.formatStreamPart)("assistant_message", {
                     id: value.data.id,
                     role: "assistant",
                     content: [{ type: "text", text: { value: "" } }]
@@ -5274,7 +4950,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(
-                    (0, import_ui_utils7.formatStreamPart)("text", content.text.value)
+                    (0, import_ui_utils8.formatStreamPart)("text", content.text.value)
                   )
                 );
               }
@@ -5291,7 +4967,7 @@ function AssistantResponse({ threadId, messageId }, process2) {
       };
       controller.enqueue(
         textEncoder.encode(
-          (0, import_ui_utils7.formatStreamPart)("assistant_control_data", {
+          (0, import_ui_utils8.formatStreamPart)("assistant_control_data", {
             threadId,
             messageId
           })
@@ -5299,8 +4975,6 @@ function AssistantResponse({ threadId, messageId }, process2) {
       );
       try {
         await process2({
-          threadId,
-          messageId,
           sendMessage,
           sendDataMessage,
           forwardStream
@@ -5323,24 +4997,48 @@ function AssistantResponse({ threadId, messageId }, process2) {
     }
   });
 }
-var experimental_AssistantResponse = AssistantResponse;
 
 // streams/langchain-adapter.ts
 var langchain_adapter_exports = {};
 __export(langchain_adapter_exports, {
-  toAIStream: () => toAIStream,
   toDataStream: () => toDataStream,
   toDataStreamResponse: () => toDataStreamResponse
 });
 
+// streams/stream-callbacks.ts
+function createCallbacksTransformer(callbacks = {}) {
+  const textEncoder = new TextEncoder();
+  let aggregatedResponse = "";
+  return new TransformStream({
+    async start() {
+      if (callbacks.onStart)
+        await callbacks.onStart();
+    },
+    async transform(message, controller) {
+      controller.enqueue(textEncoder.encode(message));
+      aggregatedResponse += message;
+      if (callbacks.onToken)
+        await callbacks.onToken(message);
+      if (callbacks.onText && typeof message === "string") {
+        await callbacks.onText(message);
+      }
+    },
+    async flush() {
+      if (callbacks.onCompletion) {
+        await callbacks.onCompletion(aggregatedResponse);
+      }
+    }
+  });
+}
+
 // streams/stream-data.ts
-var import_ui_utils8 = require("@ai-sdk/ui-utils");
+var import_ui_utils9 = require("@ai-sdk/ui-utils");
 
 // util/constants.ts
 var HANGING_STREAM_WARNING_TIME_MS = 15 * 1e3;
 
 // streams/stream-data.ts
-var StreamData2 = class {
+var StreamData = class {
   constructor() {
     this.encoder = new TextEncoder();
     this.controller = null;
@@ -5386,7 +5084,7 @@ var StreamData2 = class {
       throw new Error("Stream controller is not initialized.");
     }
     this.controller.enqueue(
-      this.encoder.encode((0, import_ui_utils8.formatStreamPart)("data", [value]))
+      this.encoder.encode((0, import_ui_utils9.formatStreamPart)("data", [value]))
     );
   }
   appendMessageAnnotation(value) {
@@ -5397,7 +5095,7 @@ var StreamData2 = class {
       throw new Error("Stream controller is not initialized.");
     }
     this.controller.enqueue(
-      this.encoder.encode((0, import_ui_utils8.formatStreamPart)("message_annotations", [value]))
+      this.encoder.encode((0, import_ui_utils9.formatStreamPart)("message_annotations", [value]))
     );
   }
 };
@@ -5407,17 +5105,12 @@ function createStreamDataTransformer() {
   return new TransformStream({
     transform: async (chunk, controller) => {
       const message = decoder.decode(chunk);
-      controller.enqueue(encoder.encode((0, import_ui_utils8.formatStreamPart)("text", message)));
+      controller.enqueue(encoder.encode((0, import_ui_utils9.formatStreamPart)("text", message)));
     }
   });
 }
-var experimental_StreamData = class extends StreamData2 {
-};
 
 // streams/langchain-adapter.ts
-function toAIStream(stream, callbacks) {
-  return toDataStream(stream, callbacks);
-}
 function toDataStream(stream, callbacks) {
   return stream.pipeThrough(
     new TransformStream({
@@ -5450,7 +5143,7 @@ function toDataStreamResponse(stream, options) {
   return new Response(responseStream, {
     status: (_a11 = init == null ? void 0 : init.status) != null ? _a11 : 200,
     statusText: init == null ? void 0 : init.statusText,
-    headers: prepareResponseHeaders(init, {
+    headers: prepareResponseHeaders(init == null ? void 0 : init.headers, {
       contentType: "text/plain; charset=utf-8",
       dataStreamVersion: "v1"
     })
@@ -5475,8 +5168,16 @@ __export(llamaindex_adapter_exports, {
   toDataStream: () => toDataStream2,
   toDataStreamResponse: () => toDataStreamResponse2
 });
+var import_provider_utils10 = require("@ai-sdk/provider-utils");
 function toDataStream2(stream, callbacks) {
-  return toReadableStream(stream).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(createStreamDataTransformer());
+  const trimStart = trimStartOfStream();
+  return (0, import_provider_utils10.convertAsyncIteratorToReadableStream)(stream[Symbol.asyncIterator]()).pipeThrough(
+    new TransformStream({
+      async transform(message, controller) {
+        controller.enqueue(trimStart(message.delta));
+      }
+    })
+  ).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(createStreamDataTransformer());
 }
 function toDataStreamResponse2(stream, options = {}) {
   var _a11;
@@ -5486,79 +5187,26 @@ function toDataStreamResponse2(stream, options = {}) {
   return new Response(responseStream, {
     status: (_a11 = init == null ? void 0 : init.status) != null ? _a11 : 200,
     statusText: init == null ? void 0 : init.statusText,
-    headers: prepareResponseHeaders(init, {
+    headers: prepareResponseHeaders(init == null ? void 0 : init.headers, {
       contentType: "text/plain; charset=utf-8",
       dataStreamVersion: "v1"
     })
   });
 }
-function toReadableStream(res) {
-  const it = res[Symbol.asyncIterator]();
-  const trimStartOfStream = trimStartOfStreamHelper();
-  return new ReadableStream({
-    async pull(controller) {
-      var _a11;
-      const { value, done } = await it.next();
-      if (done) {
-        controller.close();
-        return;
-      }
-      const text = trimStartOfStream((_a11 = value.delta) != null ? _a11 : "");
-      if (text) {
-        controller.enqueue(text);
-      }
+function trimStartOfStream() {
+  let isStreamStart = true;
+  return (text) => {
+    if (isStreamStart) {
+      text = text.trimStart();
+      if (text)
+        isStreamStart = false;
     }
-  });
-}
-
-// streams/stream-to-response.ts
-function streamToResponse(res, response, init, data) {
-  var _a11;
-  response.writeHead((_a11 = init == null ? void 0 : init.status) != null ? _a11 : 200, {
-    "Content-Type": "text/plain; charset=utf-8",
-    ...init == null ? void 0 : init.headers
-  });
-  let processedStream = res;
-  if (data) {
-    processedStream = mergeStreams(data.stream, res);
-  }
-  const reader = processedStream.getReader();
-  function read() {
-    reader.read().then(({ done, value }) => {
-      if (done) {
-        response.end();
-        return;
-      }
-      response.write(value);
-      read();
-    });
-  }
-  read();
+    return text;
+  };
 }
-
-// streams/streaming-text-response.ts
-var StreamingTextResponse = class extends Response {
-  constructor(res, init, data) {
-    let processedStream = res;
-    if (data) {
-      processedStream = mergeStreams(data.stream, res);
-    }
-    super(processedStream, {
-      ...init,
-      status: 200,
-      headers: prepareResponseHeaders(init, {
-        contentType: "text/plain; charset=utf-8"
-      })
-    });
-  }
-};
-
-// streams/index.ts
-var generateId2 = import_provider_utils10.generateId;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AISDKError,
-  AIStream,
   APICallError,
   AssistantResponse,
   DownloadError,
@@ -5581,25 +5229,15 @@ var generateId2 = import_provider_utils10.generateId;
   NoSuchToolError,
   RetryError,
   StreamData,
-  StreamingTextResponse,
   TypeValidationError,
   UnsupportedFunctionalityError,
   convertToCoreMessages,
   cosineSimilarity,
-  createCallbacksTransformer,
-  createEventStreamTransformer,
   createStreamDataTransformer,
   embed,
   embedMany,
-  experimental_AssistantResponse,
-  experimental_StreamData,
-  experimental_createModelRegistry,
   experimental_createProviderRegistry,
   experimental_customProvider,
-  experimental_generateObject,
-  experimental_generateText,
-  experimental_streamObject,
-  experimental_streamText,
   experimental_wrapLanguageModel,
   formatStreamPart,
   generateId,
@@ -5609,11 +5247,8 @@ var generateId2 = import_provider_utils10.generateId;
   parseStreamPart,
   processDataProtocolResponse,
   readDataStream,
-  readableFromAsyncIterable,
   streamObject,
   streamText,
-  streamToResponse,
-  tool,
-  trimStartOfStreamHelper
+  tool
 });
 //# sourceMappingURL=index.js.map