ai 5.0.0-canary.20 → 5.0.0-canary.22

package/dist/index.mjs

@@ -12,406 +12,6 @@ import {
   jsonSchema as jsonSchema2
 } from "@ai-sdk/provider-utils";
 
-// src/data-stream/create-data-stream.ts
-function createDataStream({
-  execute,
-  onError = () => "An error occurred."
-  // mask error messages for safety by default
-}) {
-  let controller;
-  const ongoingStreamPromises = [];
-  const stream = new ReadableStream({
-    start(controllerArg) {
-      controller = controllerArg;
-    }
-  });
-  function safeEnqueue(data) {
-    try {
-      controller.enqueue(data);
-    } catch (error) {
-    }
-  }
-  try {
-    const result = execute({
-      write(part) {
-        safeEnqueue(part);
-      },
-      merge(streamArg) {
-        ongoingStreamPromises.push(
-          (async () => {
-            const reader = streamArg.getReader();
-            while (true) {
-              const { done, value } = await reader.read();
-              if (done)
-                break;
-              safeEnqueue(value);
-            }
-          })().catch((error) => {
-            safeEnqueue({ type: "error", value: onError(error) });
-          })
-        );
-      },
-      onError
-    });
-    if (result) {
-      ongoingStreamPromises.push(
-        result.catch((error) => {
-          safeEnqueue({ type: "error", value: onError(error) });
-        })
-      );
-    }
-  } catch (error) {
-    safeEnqueue({ type: "error", value: onError(error) });
-  }
-  const waitForStreams = new Promise(async (resolve) => {
-    while (ongoingStreamPromises.length > 0) {
-      await ongoingStreamPromises.shift();
-    }
-    resolve();
-  });
-  waitForStreams.finally(() => {
-    try {
-      controller.close();
-    } catch (error) {
-    }
-  });
-  return stream;
-}
-
-// src/util/prepare-headers.ts
-function prepareHeaders(headers, defaultHeaders) {
-  const responseHeaders = new Headers(headers != null ? headers : {});
-  for (const [key, value] of Object.entries(defaultHeaders)) {
-    if (!responseHeaders.has(key)) {
-      responseHeaders.set(key, value);
-    }
-  }
-  return responseHeaders;
-}
-
-// src/data-stream/data-stream-headers.ts
-var dataStreamHeaders = {
-  "content-type": "text/event-stream",
-  "cache-control": "no-cache",
-  connection: "keep-alive",
-  "x-vercel-ai-data-stream": "v2",
-  "x-accel-buffering": "no"
-  // disable nginx buffering
-};
-
-// src/data-stream/json-to-sse-transform-stream.ts
-var JsonToSseTransformStream = class extends TransformStream {
-  constructor() {
-    super({
-      transform(part, controller) {
-        controller.enqueue(`data: ${JSON.stringify(part)}
-
-`);
-      },
-      flush(controller) {
-        controller.enqueue("data: [DONE]\n\n");
-      }
-    });
-  }
-};
-
-// src/data-stream/create-data-stream-response.ts
-function createDataStreamResponse({
-  status,
-  statusText,
-  headers,
-  dataStream
-}) {
-  return new Response(
-    dataStream.pipeThrough(new JsonToSseTransformStream()).pipeThrough(new TextEncoderStream()),
-    {
-      status,
-      statusText,
-      headers: prepareHeaders(headers, dataStreamHeaders)
-    }
-  );
-}
-
-// src/util/write-to-server-response.ts
-function writeToServerResponse({
-  response,
-  status,
-  statusText,
-  headers,
-  stream
-}) {
-  response.writeHead(status != null ? status : 200, statusText, headers);
-  const reader = stream.getReader();
-  const read = async () => {
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-          break;
-        response.write(value);
-      }
-    } catch (error) {
-      throw error;
-    } finally {
-      response.end();
-    }
-  };
-  read();
-}
-
-// src/data-stream/pipe-data-stream-to-response.ts
-function pipeDataStreamToResponse({
-  response,
-  status,
-  statusText,
-  headers,
-  dataStream
-}) {
-  writeToServerResponse({
-    response,
-    status,
-    statusText,
-    headers: Object.fromEntries(
-      prepareHeaders(headers, dataStreamHeaders).entries()
-    ),
-    stream: dataStream.pipeThrough(new JsonToSseTransformStream()).pipeThrough(new TextEncoderStream())
-  });
-}
-
-// src/data-stream/process-data-stream.ts
-import {
-  createEventSourceParserStream,
-  safeParseJSON
-} from "@ai-sdk/provider-utils";
-
-// src/util/async-iterable-stream.ts
-function createAsyncIterableStream(source) {
-  const stream = source.pipeThrough(new TransformStream());
-  stream[Symbol.asyncIterator] = () => {
-    const reader = stream.getReader();
-    return {
-      async next() {
-        const { done, value } = await reader.read();
-        return done ? { done: true, value: void 0 } : { done: false, value };
-      }
-    };
-  };
-  return stream;
-}
-
-// src/data-stream/data-stream-parts.ts
-import { z } from "zod";
-var languageModelUsageSchema = z.object({
-  inputTokens: z.number().optional(),
-  outputTokens: z.number().optional(),
-  totalTokens: z.number().optional(),
-  reasoningTokens: z.number().optional(),
-  cachedInputTokens: z.number().optional()
-});
-var finishReasonSchema = z.enum([
-  "stop",
-  "length",
-  "tool-calls",
-  "content-filter",
-  "other",
-  "error",
-  "unknown"
-]);
-var toolCallSchema = z.object({
-  toolCallId: z.string(),
-  toolName: z.string(),
-  args: z.unknown()
-});
-var toolResultValueSchema = z.object({
-  toolCallId: z.string(),
-  result: z.unknown(),
-  providerMetadata: z.any().optional()
-});
-var sourceSchema = z.object({
-  type: z.literal("source"),
-  sourceType: z.literal("url"),
-  id: z.string(),
-  url: z.string(),
-  title: z.string().optional(),
-  providerMetadata: z.any().optional()
-  // Use z.any() for generic metadata
-});
-var dataStreamPartSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("text"),
-    value: z.string()
-  }),
-  z.object({
-    type: z.literal("data"),
-    value: z.array(z.any())
-    // TODO json validation
-  }),
-  z.object({
-    type: z.literal("error"),
-    value: z.string()
-  }),
-  z.object({
-    type: z.literal("message-annotations"),
-    value: z.array(z.any())
-    // TODO json validation
-  }),
-  z.object({
-    type: z.literal("tool-call"),
-    value: toolCallSchema
-  }),
-  z.object({
-    type: z.literal("tool-result"),
-    value: toolResultValueSchema
-  }),
-  z.object({
-    type: z.literal("tool-call-streaming-start"),
-    value: z.object({ toolCallId: z.string(), toolName: z.string() })
-  }),
-  z.object({
-    type: z.literal("tool-call-delta"),
-    value: z.object({ toolCallId: z.string(), argsTextDelta: z.string() })
-  }),
-  z.object({
-    type: z.literal("finish-message"),
-    value: z.object({
-      finishReason: finishReasonSchema,
-      // TODO v5 remove usage from finish event (only on step-finish)
-      usage: languageModelUsageSchema.optional()
-    })
-  }),
-  z.object({
-    type: z.literal("finish-step"),
-    value: z.object({
-      isContinued: z.boolean(),
-      finishReason: finishReasonSchema,
-      usage: languageModelUsageSchema.optional()
-    })
-  }),
-  z.object({
-    type: z.literal("start-step"),
-    value: z.object({
-      messageId: z.string()
-    })
-  }),
-  z.object({
-    type: z.literal("reasoning"),
-    value: z.object({
-      text: z.string(),
-      providerMetadata: z.record(z.any()).optional()
-    })
-  }),
-  z.object({
-    type: z.literal("source"),
-    value: sourceSchema
-  }),
-  z.object({
-    type: z.literal("file"),
-    value: z.object({
-      url: z.string(),
-      mediaType: z.string()
-    })
-  }),
-  z.object({
-    type: z.literal("reasoning-part-finish"),
-    value: z.null()
-  })
-]);
-
-// src/data-stream/process-data-stream.ts
-async function processDataStream({
-  stream,
-  onTextPart,
-  onReasoningPart,
-  onReasoningPartFinish,
-  onSourcePart,
-  onFilePart,
-  onDataPart,
-  onErrorPart,
-  onToolCallStreamingStartPart,
-  onToolCallDeltaPart,
-  onToolCallPart,
-  onToolResultPart,
-  onMessageAnnotationsPart,
-  onFinishMessagePart,
-  onFinishStepPart,
-  onStartStepPart
-}) {
-  const streamParts = createAsyncIterableStream(
-    stream.pipeThrough(new TextDecoderStream()).pipeThrough(createEventSourceParserStream()).pipeThrough(
-      new TransformStream({
-        async transform({ data }, controller) {
-          if (data === "[DONE]") {
-            return;
-          }
-          controller.enqueue(
-            await safeParseJSON({
-              text: data,
-              schema: dataStreamPartSchema
-            })
-          );
-        }
-      })
-    )
-  );
-  for await (const parseResult of streamParts) {
-    if (!parseResult.success) {
-      throw new Error("Failed to parse data stream part");
-    }
-    const { type, value } = parseResult.value;
-    switch (type) {
-      case "text":
-        await (onTextPart == null ? void 0 : onTextPart(value));
-        break;
-      case "reasoning":
-        await (onReasoningPart == null ? void 0 : onReasoningPart(value));
-        break;
-      case "reasoning-part-finish":
-        await (onReasoningPartFinish == null ? void 0 : onReasoningPartFinish(value));
-        break;
-      case "file":
-        await (onFilePart == null ? void 0 : onFilePart(value));
-        break;
-      case "source":
-        await (onSourcePart == null ? void 0 : onSourcePart(value));
-        break;
-      case "data":
-        await (onDataPart == null ? void 0 : onDataPart(value));
-        break;
-      case "error":
-        await (onErrorPart == null ? void 0 : onErrorPart(value));
-        break;
-      case "message-annotations":
-        await (onMessageAnnotationsPart == null ? void 0 : onMessageAnnotationsPart(value));
-        break;
-      case "tool-call-streaming-start":
-        await (onToolCallStreamingStartPart == null ? void 0 : onToolCallStreamingStartPart(value));
-        break;
-      case "tool-call-delta":
-        await (onToolCallDeltaPart == null ? void 0 : onToolCallDeltaPart(value));
-        break;
-      case "tool-call":
-        await (onToolCallPart == null ? void 0 : onToolCallPart(value));
-        break;
-      case "tool-result":
-        await (onToolResultPart == null ? void 0 : onToolResultPart(value));
-        break;
-      case "finish-message":
-        await (onFinishMessagePart == null ? void 0 : onFinishMessagePart(value));
-        break;
-      case "finish-step":
-        await (onFinishStepPart == null ? void 0 : onFinishStepPart(value));
-        break;
-      case "start-step":
-        await (onStartStepPart == null ? void 0 : onStartStepPart(value));
-        break;
-      default: {
-        const exhaustiveCheck = type;
-        throw new Error(`Unknown stream part type: ${exhaustiveCheck}`);
-      }
-    }
-  }
-}
-
 // src/error/index.ts
 import {
   AISDKError as AISDKError16,
@@ -774,6 +374,17 @@ var RetryError = class extends AISDKError15 {
 };
 _a15 = symbol15;
 
+// src/util/prepare-headers.ts
+function prepareHeaders(headers, defaultHeaders) {
+  const responseHeaders = new Headers(headers != null ? headers : {});
+  for (const [key, value] of Object.entries(defaultHeaders)) {
+    if (!responseHeaders.has(key)) {
+      responseHeaders.set(key, value);
+    }
+  }
+  return responseHeaders;
+}
+
 // src/text-stream/create-text-stream-response.ts
 function createTextStreamResponse({
   status,
@@ -790,6 +401,33 @@ function createTextStreamResponse({
   });
 }
 
+// src/util/write-to-server-response.ts
+function writeToServerResponse({
+  response,
+  status,
+  statusText,
+  headers,
+  stream
+}) {
+  response.writeHead(status != null ? status : 200, statusText, headers);
+  const reader = stream.getReader();
+  const read = async () => {
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        response.write(value);
+      }
+    } catch (error) {
+      throw error;
+    } finally {
+      response.end();
+    }
+  };
+  read();
+}
+
 // src/text-stream/pipe-text-stream-to-response.ts
 function pipeTextStreamToResponse({
   response,
@@ -821,271 +459,170 @@ function appendClientMessage({
     message
   ];
 }
-
-// src/ui/append-response-messages.ts
-import { AISDKError as AISDKError18 } from "@ai-sdk/provider";
-
-// src/ui/extract-max-tool-invocation-step.ts
-function extractMaxToolInvocationStep(toolInvocations) {
-  return toolInvocations == null ? void 0 : toolInvocations.reduce((max, toolInvocation) => {
-    var _a17;
-    return Math.max(max, (_a17 = toolInvocation.step) != null ? _a17 : 0);
-  }, 0);
-}
-
-// src/ui/get-tool-invocations.ts
-function getToolInvocations(message) {
-  return message.parts.filter(
-    (part) => part.type === "tool-invocation"
-  ).map((part) => part.toolInvocation);
-}
-
-// core/prompt/data-content.ts
-import { AISDKError as AISDKError17 } from "@ai-sdk/provider";
+
+// src/ui/call-chat-api.ts
 import {
-  convertBase64ToUint8Array,
-  convertUint8ArrayToBase64
+  parseJsonEventStream
 } from "@ai-sdk/provider-utils";
-import { z as z2 } from "zod";
 
-// core/prompt/split-data-url.ts
-function splitDataUrl(dataUrl) {
+// src/ui-message-stream/ui-message-stream-parts.ts
+import { z } from "zod";
+var toolCallSchema = z.object({
+  toolCallId: z.string(),
+  toolName: z.string(),
+  args: z.unknown()
+});
+var toolResultValueSchema = z.object({
+  toolCallId: z.string(),
+  result: z.unknown(),
+  providerMetadata: z.any().optional()
+});
+var sourceSchema = z.object({
+  type: z.literal("source"),
+  sourceType: z.literal("url"),
+  id: z.string(),
+  url: z.string(),
+  title: z.string().optional(),
+  providerMetadata: z.any().optional()
+  // Use z.any() for generic metadata
+});
+var uiMessageStreamPartSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("text"),
+    value: z.string()
+  }),
+  z.object({
+    type: z.literal("error"),
+    value: z.string()
+  }),
+  z.object({
+    type: z.literal("tool-call"),
+    value: toolCallSchema
+  }),
+  z.object({
+    type: z.literal("tool-result"),
+    value: toolResultValueSchema
+  }),
+  z.object({
+    type: z.literal("tool-call-streaming-start"),
+    value: z.object({ toolCallId: z.string(), toolName: z.string() })
+  }),
+  z.object({
+    type: z.literal("tool-call-delta"),
+    value: z.object({ toolCallId: z.string(), argsTextDelta: z.string() })
+  }),
+  z.object({
+    type: z.literal("reasoning"),
+    value: z.object({
+      text: z.string(),
+      providerMetadata: z.record(z.any()).optional()
+    })
+  }),
+  z.object({
+    type: z.literal("source"),
+    value: sourceSchema
+  }),
+  z.object({
+    type: z.literal("file"),
+    value: z.object({
+      url: z.string(),
+      mediaType: z.string()
+    })
+  }),
+  z.object({
+    type: z.literal("metadata"),
+    value: z.object({
+      metadata: z.unknown()
+    })
+  }),
+  z.object({
+    type: z.literal("start-step"),
+    value: z.object({
+      metadata: z.unknown()
+    })
+  }),
+  z.object({
+    type: z.literal("finish-step"),
+    value: z.object({
+      metadata: z.unknown()
+    })
+  }),
+  z.object({
+    type: z.literal("start"),
+    value: z.object({
+      messageId: z.string().optional(),
+      metadata: z.unknown()
+    })
+  }),
+  z.object({
+    type: z.literal("finish"),
+    value: z.object({
+      metadata: z.unknown()
+    })
+  }),
+  z.object({
+    type: z.literal("reasoning-part-finish"),
+    value: z.null()
+  })
+]);
+
+// src/util/consume-stream.ts
+async function consumeStream({
+  stream,
+  onError
+}) {
+  const reader = stream.getReader();
   try {
-    const [header, base64Content] = dataUrl.split(",");
-    return {
-      mediaType: header.split(";")[0].split(":")[1],
-      base64Content
-    };
+    while (true) {
+      const { done } = await reader.read();
+      if (done)
+        break;
+    }
   } catch (error) {
-    return {
-      mediaType: void 0,
-      base64Content: void 0
-    };
+    onError == null ? void 0 : onError(error);
+  } finally {
+    reader.releaseLock();
   }
 }
 
-// core/prompt/data-content.ts
-var dataContentSchema = z2.union([
-  z2.string(),
-  z2.instanceof(Uint8Array),
-  z2.instanceof(ArrayBuffer),
-  z2.custom(
-    // Buffer might not be available in some environments such as CloudFlare:
-    (value) => {
-      var _a17, _b;
-      return (_b = (_a17 = globalThis.Buffer) == null ? void 0 : _a17.isBuffer(value)) != null ? _b : false;
-    },
-    { message: "Must be a Buffer" }
-  )
-]);
-function convertToLanguageModelV2DataContent(content) {
-  if (content instanceof Uint8Array) {
-    return { data: content, mediaType: void 0 };
-  }
-  if (content instanceof ArrayBuffer) {
-    return { data: new Uint8Array(content), mediaType: void 0 };
-  }
-  if (typeof content === "string") {
-    try {
-      content = new URL(content);
-    } catch (error) {
-    }
-  }
-  if (content instanceof URL && content.protocol === "data:") {
-    const { mediaType: dataUrlMediaType, base64Content } = splitDataUrl(
-      content.toString()
-    );
-    if (dataUrlMediaType == null || base64Content == null) {
-      throw new AISDKError17({
-        name: "InvalidDataContentError",
-        message: `Invalid data URL format in content ${content.toString()}`
-      });
-    }
-    return { data: base64Content, mediaType: dataUrlMediaType };
-  }
-  return { data: content, mediaType: void 0 };
-}
-function convertDataContentToBase64String(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  if (content instanceof ArrayBuffer) {
-    return convertUint8ArrayToBase64(new Uint8Array(content));
-  }
-  return convertUint8ArrayToBase64(content);
-}
-function convertDataContentToUint8Array(content) {
-  if (content instanceof Uint8Array) {
-    return content;
+// src/ui/process-ui-message-stream.ts
+import { validateTypes } from "@ai-sdk/provider-utils";
+
+// src/util/merge-objects.ts
+function mergeObjects(base, overrides) {
+  if (base === void 0 && overrides === void 0) {
+    return void 0;
   }
-  if (typeof content === "string") {
-    try {
-      return convertBase64ToUint8Array(content);
-    } catch (error) {
-      throw new InvalidDataContentError({
-        message: "Invalid data content. Content string is not a base64-encoded media.",
-        content,
-        cause: error
-      });
-    }
+  if (base === void 0) {
+    return overrides;
   }
-  if (content instanceof ArrayBuffer) {
-    return new Uint8Array(content);
+  if (overrides === void 0) {
+    return base;
   }
-  throw new InvalidDataContentError({ content });
-}
-
-// src/ui/append-response-messages.ts
-function appendResponseMessages({
-  messages,
-  responseMessages,
-  _internal: { currentDate = () => /* @__PURE__ */ new Date() } = {}
-}) {
-  var _a17, _b;
-  const clonedMessages = structuredClone(messages);
-  for (const message of responseMessages) {
-    const role = message.role;
-    const lastMessage = clonedMessages[clonedMessages.length - 1];
-    const isLastMessageAssistant = lastMessage.role === "assistant";
-    switch (role) {
-      case "assistant": {
-        let getToolInvocationsForStep2 = function(step) {
-          return (typeof message.content === "string" ? [] : message.content.filter((part) => part.type === "tool-call")).map((call) => ({
-            state: "call",
-            step,
-            args: call.args,
-            toolCallId: call.toolCallId,
-            toolName: call.toolName
-          }));
-        };
-        var getToolInvocationsForStep = getToolInvocationsForStep2;
-        const parts = [{ type: "step-start" }];
-        let textContent = "";
-        let reasoningTextContent = void 0;
-        if (typeof message.content === "string") {
-          textContent = message.content;
-          parts.push({
-            type: "text",
-            text: message.content
-          });
-        } else {
-          let reasoningPart = void 0;
-          for (const part of message.content) {
-            switch (part.type) {
-              case "text": {
-                reasoningPart = void 0;
-                textContent += part.text;
-                parts.push({
-                  type: "text",
-                  text: part.text
-                });
-                break;
-              }
-              case "reasoning": {
-                if (reasoningPart == null) {
-                  reasoningPart = {
-                    type: "reasoning",
-                    text: ""
-                  };
-                  parts.push(reasoningPart);
-                }
-                reasoningTextContent = (reasoningTextContent != null ? reasoningTextContent : "") + part.text;
-                reasoningPart.text += part.text;
-                reasoningPart.providerMetadata = part.providerOptions;
-                break;
-              }
-              case "tool-call":
-                break;
-              case "file":
-                if (part.data instanceof URL) {
-                  throw new AISDKError18({
-                    name: "InvalidAssistantFileData",
-                    message: "File data cannot be a URL"
-                  });
-                }
-                parts.push({
-                  type: "file",
-                  mediaType: part.mediaType,
-                  url: `data:${part.mediaType};base64,${convertDataContentToBase64String(part.data)}`
-                });
-                break;
-            }
-          }
-        }
-        if (isLastMessageAssistant) {
-          const maxStep = extractMaxToolInvocationStep(
-            getToolInvocations(lastMessage)
-          );
-          (_a17 = lastMessage.parts) != null ? _a17 : lastMessage.parts = [];
-          lastMessage.parts.push(...parts);
-          getToolInvocationsForStep2(maxStep === void 0 ? 0 : maxStep + 1).map((call) => ({
-            type: "tool-invocation",
-            toolInvocation: call
-          })).forEach((part) => {
-            lastMessage.parts.push(part);
-          });
-        } else {
-          clonedMessages.push({
-            role: "assistant",
-            id: message.id,
-            createdAt: currentDate(),
-            // generate a createdAt date for the message, will be overridden by the client
-            parts: [
-              ...parts,
-              ...getToolInvocationsForStep2(0).map((call) => ({
-                type: "tool-invocation",
-                toolInvocation: call
-              }))
-            ]
-          });
-        }
-        break;
-      }
-      case "tool": {
-        if (lastMessage.role !== "assistant") {
-          throw new Error(
-            `Tool result must follow an assistant message: ${lastMessage.role}`
-          );
-        }
-        (_b = lastMessage.parts) != null ? _b : lastMessage.parts = [];
-        for (const contentPart of message.content) {
-          const toolCall = getToolInvocations(lastMessage).find(
-            (call) => call.toolCallId === contentPart.toolCallId
-          );
-          const toolCallPart = lastMessage.parts.find(
-            (part) => part.type === "tool-invocation" && part.toolInvocation.toolCallId === contentPart.toolCallId
-          );
-          if (!toolCall) {
-            throw new Error("Tool call not found in previous message");
-          }
-          toolCall.state = "result";
-          const toolResult = toolCall;
-          toolResult.result = contentPart.result;
-          if (toolCallPart) {
-            toolCallPart.toolInvocation = toolResult;
-          } else {
-            lastMessage.parts.push({
-              type: "tool-invocation",
-              toolInvocation: toolResult
-            });
-          }
-        }
-        break;
-      }
-      default: {
-        const _exhaustiveCheck = role;
-        throw new Error(`Unsupported message role: ${_exhaustiveCheck}`);
+  const result = { ...base };
+  for (const key in overrides) {
+    if (Object.prototype.hasOwnProperty.call(overrides, key)) {
+      const overridesValue = overrides[key];
+      if (overridesValue === void 0)
+        continue;
+      const baseValue = key in base ? base[key] : void 0;
+      const isSourceObject = overridesValue !== null && typeof overridesValue === "object" && !Array.isArray(overridesValue) && !(overridesValue instanceof Date) && !(overridesValue instanceof RegExp);
+      const isTargetObject = baseValue !== null && baseValue !== void 0 && typeof baseValue === "object" && !Array.isArray(baseValue) && !(baseValue instanceof Date) && !(baseValue instanceof RegExp);
+      if (isSourceObject && isTargetObject) {
+        result[key] = mergeObjects(
+          baseValue,
+          overridesValue
+        );
+      } else {
+        result[key] = overridesValue;
       }
     }
   }
-  return clonedMessages;
+  return result;
 }
 
-// src/ui/process-chat-response.ts
-import { generateId as generateIdFunction } from "@ai-sdk/provider-utils";
-
 // src/util/parse-partial-json.ts
-import { safeParseJSON as safeParseJSON2 } from "@ai-sdk/provider-utils";
+import { safeParseJSON } from "@ai-sdk/provider-utils";
 
 // src/util/fix-json.ts
 function fixJson(input) {
@@ -1410,33 +947,48 @@ async function parsePartialJson(jsonText) {
   if (jsonText === void 0) {
     return { value: void 0, state: "undefined-input" };
   }
-  let result = await safeParseJSON2({ text: jsonText });
+  let result = await safeParseJSON({ text: jsonText });
   if (result.success) {
     return { value: result.value, state: "successful-parse" };
   }
-  result = await safeParseJSON2({ text: fixJson(jsonText) });
+  result = await safeParseJSON({ text: fixJson(jsonText) });
   if (result.success) {
     return { value: result.value, state: "repaired-parse" };
   }
   return { value: void 0, state: "failed-parse" };
 }
 
-// src/ui/process-chat-response.ts
-async function processChatResponse({
+// src/ui/extract-max-tool-invocation-step.ts
+function extractMaxToolInvocationStep(toolInvocations) {
+  return toolInvocations == null ? void 0 : toolInvocations.reduce((max, toolInvocation) => {
+    var _a17;
+    return Math.max(max, (_a17 = toolInvocation.step) != null ? _a17 : 0);
+  }, 0);
+}
+
+// src/ui/get-tool-invocations.ts
+function getToolInvocations(message) {
+  return message.parts.filter(
+    (part) => part.type === "tool-invocation"
+  ).map((part) => part.toolInvocation);
+}
+
+// src/ui/process-ui-message-stream.ts
+function processUIMessageStream({
   stream,
-  update,
+  onUpdate,
   onToolCall,
   onFinish,
-  generateId: generateId3 = generateIdFunction,
-  getCurrentDate = () => /* @__PURE__ */ new Date(),
-  lastMessage
+  lastMessage,
+  newMessageId,
+  messageMetadataSchema
 }) {
   var _a17;
-  const replaceLastMessage = (lastMessage == null ? void 0 : lastMessage.role) === "assistant";
-  let step = replaceLastMessage ? 1 + ((_a17 = extractMaxToolInvocationStep(getToolInvocations(lastMessage))) != null ? _a17 : 0) : 0;
-  const message = replaceLastMessage ? structuredClone(lastMessage) : {
-    id: generateId3(),
-    createdAt: getCurrentDate(),
+  const isContinuation = (lastMessage == null ? void 0 : lastMessage.role) === "assistant";
+  let step = isContinuation ? 1 + ((_a17 = extractMaxToolInvocationStep(getToolInvocations(lastMessage))) != null ? _a17 : 0) : 0;
+  const message = isContinuation ? structuredClone(lastMessage) : {
+    id: newMessageId,
+    metadata: {},
     role: "assistant",
     parts: []
   };
@@ -1455,198 +1007,214 @@ async function processChatResponse({
       });
     }
   }
-  const data = [];
-  let messageAnnotations = replaceLastMessage ? lastMessage == null ? void 0 : lastMessage.annotations : void 0;
   const partialToolCalls = {};
-  let usage = {
-    inputTokens: void 0,
-    outputTokens: void 0,
-    totalTokens: void 0
-  };
-  let finishReason = "unknown";
-  function execUpdate() {
-    const copiedData = [...data];
-    if (messageAnnotations == null ? void 0 : messageAnnotations.length) {
-      message.annotations = messageAnnotations;
-    }
-    const copiedMessage = {
-      // deep copy the message to ensure that deep changes (msg attachments) are updated
-      // with SolidJS. SolidJS uses referential integration of sub-objects to detect changes.
-      ...structuredClone(message),
-      // add a revision id to ensure that the message is updated with SWR. SWR uses a
-      // hashing approach by default to detect changes, but it only works for shallow
-      // changes. This is why we need to add a revision id to ensure that the message
-      // is updated with SWR (without it, the changes get stuck in SWR and are not
-      // forwarded to rendering):
-      revisionId: generateId3()
-    };
-    update({
-      message: copiedMessage,
-      data: copiedData,
-      replaceLastMessage
-    });
-  }
-  await processDataStream({
-    stream,
-    onTextPart(value) {
-      if (currentTextPart == null) {
-        currentTextPart = {
-          type: "text",
-          text: value
-        };
-        message.parts.push(currentTextPart);
-      } else {
-        currentTextPart.text += value;
-      }
-      execUpdate();
-    },
-    onReasoningPart(value) {
-      if (currentReasoningPart == null) {
-        currentReasoningPart = {
-          type: "reasoning",
-          text: value.text,
-          providerMetadata: value.providerMetadata
-        };
-        message.parts.push(currentReasoningPart);
-      } else {
-        currentReasoningPart.text += value.text;
-        currentReasoningPart.providerMetadata = value.providerMetadata;
-      }
-      execUpdate();
-    },
-    onReasoningPartFinish(value) {
-      if (currentReasoningPart != null) {
-        currentReasoningPart = void 0;
-      }
-    },
-    onFilePart(value) {
-      message.parts.push({
-        type: "file",
-        mediaType: value.mediaType,
-        url: value.url
-      });
-      execUpdate();
-    },
-    onSourcePart(value) {
-      message.parts.push({
-        type: "source",
-        source: value
-      });
-      execUpdate();
-    },
-    onToolCallStreamingStartPart(value) {
-      const toolInvocations = getToolInvocations(message);
-      partialToolCalls[value.toolCallId] = {
-        text: "",
-        step,
-        toolName: value.toolName,
-        index: toolInvocations.length
-      };
-      updateToolInvocationPart(value.toolCallId, {
-        state: "partial-call",
-        step,
-        toolCallId: value.toolCallId,
-        toolName: value.toolName,
-        args: void 0
-      });
-      execUpdate();
-    },
-    async onToolCallDeltaPart(value) {
-      const partialToolCall = partialToolCalls[value.toolCallId];
-      partialToolCall.text += value.argsTextDelta;
-      const { value: partialArgs } = await parsePartialJson(
-        partialToolCall.text
-      );
-      updateToolInvocationPart(value.toolCallId, {
-        state: "partial-call",
-        step: partialToolCall.step,
-        toolCallId: value.toolCallId,
-        toolName: partialToolCall.toolName,
-        args: partialArgs
-      });
-      execUpdate();
-    },
-    async onToolCallPart(value) {
-      updateToolInvocationPart(value.toolCallId, {
-        state: "call",
-        step,
-        ...value
-      });
-      execUpdate();
-      if (onToolCall) {
-        const result = await onToolCall({
-          toolCall: value
+  async function updateMessageMetadata(metadata) {
+    if (metadata != null) {
+      const mergedMetadata = message.metadata != null ? mergeObjects(message.metadata, metadata) : metadata;
+      if (messageMetadataSchema != null) {
+        await validateTypes({
+          value: mergedMetadata,
+          schema: messageMetadataSchema
         });
-        if (result != null) {
-          updateToolInvocationPart(value.toolCallId, {
-            state: "result",
-            step,
-            ...value,
-            result
-          });
-          execUpdate();
-        }
-      }
-    },
-    onToolResultPart(value) {
-      const toolInvocations = getToolInvocations(message);
-      if (toolInvocations == null) {
-        throw new Error("tool_result must be preceded by a tool_call");
-      }
-      const toolInvocationIndex = toolInvocations.findIndex(
-        (invocation) => invocation.toolCallId === value.toolCallId
-      );
-      if (toolInvocationIndex === -1) {
-        throw new Error(
-          "tool_result must be preceded by a tool_call with the same toolCallId"
-        );
-      }
-      updateToolInvocationPart(value.toolCallId, {
-        ...toolInvocations[toolInvocationIndex],
-        state: "result",
-        ...value
-      });
-      execUpdate();
-    },
-    onDataPart(value) {
-      data.push(...value);
-      execUpdate();
-    },
-    onMessageAnnotationsPart(value) {
-      if (messageAnnotations == null) {
-        messageAnnotations = [...value];
-      } else {
-        messageAnnotations.push(...value);
       }
-      execUpdate();
-    },
-    onFinishStepPart(value) {
-      step += 1;
-      currentTextPart = value.isContinued ? currentTextPart : void 0;
-      currentReasoningPart = void 0;
-    },
-    onStartStepPart(value) {
-      if (!replaceLastMessage) {
-        message.id = value.messageId;
-      }
-      message.parts.push({ type: "step-start" });
-      execUpdate();
-    },
-    onFinishMessagePart(value) {
-      finishReason = value.finishReason;
-      if (value.usage != null) {
-        usage = value.usage;
-      }
-    },
-    onErrorPart(error) {
-      throw new Error(error);
+      message.metadata = mergedMetadata;
     }
-  });
-  onFinish == null ? void 0 : onFinish({ message, finishReason, usage });
+  }
+  return stream.pipeThrough(
+    new TransformStream({
+      async transform(chunk, controller) {
+        const { type, value } = chunk;
+        switch (type) {
+          case "text": {
+            if (currentTextPart == null) {
+              currentTextPart = {
+                type: "text",
+                text: value
+              };
+              message.parts.push(currentTextPart);
+            } else {
+              currentTextPart.text += value;
+            }
+            onUpdate == null ? void 0 : onUpdate({ message });
+            break;
+          }
+          case "reasoning": {
+            if (currentReasoningPart == null) {
+              currentReasoningPart = {
+                type: "reasoning",
+                text: value.text,
+                providerMetadata: value.providerMetadata
+              };
+              message.parts.push(currentReasoningPart);
+            } else {
+              currentReasoningPart.text += value.text;
+              currentReasoningPart.providerMetadata = value.providerMetadata;
+            }
+            onUpdate == null ? void 0 : onUpdate({ message });
+            break;
+          }
+          case "reasoning-part-finish": {
+            if (currentReasoningPart != null) {
+              currentReasoningPart = void 0;
+            }
+            break;
+          }
+          case "file": {
+            message.parts.push({
+              type: "file",
+              mediaType: value.mediaType,
+              url: value.url
+            });
+            onUpdate == null ? void 0 : onUpdate({ message });
+            break;
+          }
+          case "source": {
+            message.parts.push({
+              type: "source",
+              source: value
+            });
+            onUpdate == null ? void 0 : onUpdate({ message });
+            break;
+          }
+          case "tool-call-streaming-start": {
+            const toolInvocations = getToolInvocations(message);
+            partialToolCalls[value.toolCallId] = {
+              text: "",
+              step,
+              toolName: value.toolName,
+              index: toolInvocations.length
+            };
+            updateToolInvocationPart(value.toolCallId, {
+              state: "partial-call",
+              step,
+              toolCallId: value.toolCallId,
+              toolName: value.toolName,
+              args: void 0
+            });
+            onUpdate == null ? void 0 : onUpdate({ message });
+            break;
+          }
+          case "tool-call-delta": {
+            const partialToolCall = partialToolCalls[value.toolCallId];
+            partialToolCall.text += value.argsTextDelta;
+            const { value: partialArgs } = await parsePartialJson(
+              partialToolCall.text
+            );
+            updateToolInvocationPart(value.toolCallId, {
+              state: "partial-call",
+              step: partialToolCall.step,
+              toolCallId: value.toolCallId,
+              toolName: partialToolCall.toolName,
+              args: partialArgs
+            });
+            onUpdate == null ? void 0 : onUpdate({ message });
+            break;
+          }
+          case "tool-call": {
+            const call = { args: value.args, ...value };
+            updateToolInvocationPart(value.toolCallId, {
+              state: "call",
+              step,
+              ...call
+            });
+            onUpdate == null ? void 0 : onUpdate({ message });
+            if (onToolCall) {
+              const result = await onToolCall({
+                toolCall: call
+              });
+              if (result != null) {
+                updateToolInvocationPart(value.toolCallId, {
+                  state: "result",
+                  step,
+                  ...call,
+                  result
+                });
+                onUpdate == null ? void 0 : onUpdate({ message });
+              }
+            }
+            break;
+          }
+          case "tool-result": {
+            const toolInvocations = getToolInvocations(message);
+            if (toolInvocations == null) {
+              throw new Error("tool_result must be preceded by a tool_call");
+            }
+            const toolInvocationIndex = toolInvocations.findIndex(
+              (invocation) => invocation.toolCallId === value.toolCallId
+            );
+            if (toolInvocationIndex === -1) {
+              throw new Error(
+                "tool_result must be preceded by a tool_call with the same toolCallId"
+              );
+            }
+            const result = { result: value.result, ...value };
+            updateToolInvocationPart(value.toolCallId, {
+              ...toolInvocations[toolInvocationIndex],
+              state: "result",
+              ...result
+            });
+            onUpdate == null ? void 0 : onUpdate({ message });
+            break;
+          }
+          case "start-step": {
+            message.parts.push({ type: "step-start" });
+            await updateMessageMetadata(value.metadata);
+            onUpdate == null ? void 0 : onUpdate({ message });
+            break;
+          }
+          case "finish-step": {
+            step += 1;
+            currentTextPart = void 0;
+            currentReasoningPart = void 0;
+            await updateMessageMetadata(value.metadata);
+            if (value.metadata != null) {
+              onUpdate == null ? void 0 : onUpdate({ message });
+            }
+            break;
+          }
+          case "start": {
+            if (value.messageId != null) {
+              message.id = value.messageId;
+            }
+            await updateMessageMetadata(value.metadata);
+            if (value.messageId != null || value.metadata != null) {
+              onUpdate == null ? void 0 : onUpdate({ message });
+            }
+            break;
+          }
+          case "finish": {
+            await updateMessageMetadata(value.metadata);
+            if (value.metadata != null) {
+              onUpdate == null ? void 0 : onUpdate({ message });
+            }
+            break;
+          }
+          case "metadata": {
+            await updateMessageMetadata(value.metadata);
+            if (value.metadata != null) {
+              onUpdate == null ? void 0 : onUpdate({ message });
+            }
+            break;
+          }
+          case "error": {
+            throw new Error(value);
+          }
+          default: {
+            const _exhaustiveCheck = type;
+            throw new Error(`Unhandled stream part: ${_exhaustiveCheck}`);
+          }
+        }
+        controller.enqueue(chunk);
+      },
+      flush() {
+        onFinish == null ? void 0 : onFinish({ message });
+      }
+    })
+  );
 }
 
 // src/ui/process-chat-text-response.ts
-import { generateId as generateIdFunction2 } from "@ai-sdk/provider-utils";
+import { generateId as generateIdFunction } from "@ai-sdk/provider-utils";
 
 // src/ui/process-text-stream.ts
 async function processTextStream({
@@ -1668,13 +1236,11 @@ async function processChatTextResponse({
   stream,
   update,
   onFinish,
-  getCurrentDate = () => /* @__PURE__ */ new Date(),
-  generateId: generateId3 = generateIdFunction2
+  generateId: generateId3 = generateIdFunction
 }) {
   const textPart = { type: "text", text: "" };
   const resultMessage = {
     id: generateId3(),
-    createdAt: getCurrentDate(),
     role: "assistant",
     parts: [textPart]
   };
@@ -1682,21 +1248,10 @@ async function processChatTextResponse({
     stream,
     onTextPart: (chunk) => {
       textPart.text += chunk;
-      update({
-        message: { ...resultMessage },
-        data: [],
-        replaceLastMessage: false
-      });
+      update({ message: { ...resultMessage } });
     }
   });
-  onFinish == null ? void 0 : onFinish(resultMessage, {
-    usage: {
-      inputTokens: void 0,
-      outputTokens: void 0,
-      totalTokens: void 0
-    },
-    finishReason: "unknown"
-  });
+  onFinish == null ? void 0 : onFinish({ message: resultMessage });
 }
 
 // src/ui/call-chat-api.ts
@@ -1704,19 +1259,18 @@ var getOriginalFetch = () => fetch;
 async function callChatApi({
   api,
   body,
-  streamProtocol = "data",
+  streamProtocol = "ui-message",
   credentials,
   headers,
   abortController,
-  onResponse,
   onUpdate,
   onFinish,
   onToolCall,
   generateId: generateId3,
   fetch: fetch2 = getOriginalFetch(),
   lastMessage,
-  getCurrentDate,
-  requestType = "generate"
+  requestType = "generate",
+  messageMetadataSchema
 }) {
   var _a17, _b, _c;
   const response = requestType === "resume" ? await fetch2(`${api}?chatId=${body.id}`, {
@@ -1737,9 +1291,6 @@ async function callChatApi({
     signal: (_b = abortController == null ? void 0 : abortController()) == null ? void 0 : _b.signal,
     credentials
   });
-  if (onResponse != null) {
-    await onResponse(response);
-  }
   if (!response.ok) {
     throw new Error(
       (_c = await response.text()) != null ? _c : "Failed to fetch the chat response."
@@ -1754,24 +1305,49 @@ async function callChatApi({
         stream: response.body,
         update: onUpdate,
         onFinish,
-        generateId: generateId3,
-        getCurrentDate
+        generateId: generateId3
       });
       return;
     }
-    case "data": {
-      await processChatResponse({
-        stream: response.body,
-        update: onUpdate,
-        lastMessage,
-        onToolCall,
-        onFinish({ message, finishReason, usage }) {
-          if (onFinish && message != null) {
-            onFinish(message, { usage, finishReason });
-          }
-        },
-        generateId: generateId3,
-        getCurrentDate
+    case "ui-message": {
+      await consumeStream({
+        stream: processUIMessageStream({
+          stream: parseJsonEventStream({
+            stream: response.body,
+            schema: uiMessageStreamPartSchema
+          }).pipeThrough(
+            new TransformStream({
+              async transform(part, controller) {
+                if (!part.success) {
+                  throw part.error;
+                }
+                controller.enqueue(part.value);
+              }
+            })
+          ),
+          onUpdate({ message }) {
+            const copiedMessage = {
+              // deep copy the message to ensure that deep changes (msg attachments) are updated
+              // with SolidJS. SolidJS uses referential integration of sub-objects to detect changes.
+              ...structuredClone(message),
+              // add a revision id to ensure that the message is updated with SWR. SWR uses a
+              // hashing approach by default to detect changes, but it only works for shallow
+              // changes. This is why we need to add a revision id to ensure that the message
+              // is updated with SWR (without it, the changes get stuck in SWR and are not
+              // forwarded to rendering):
+              revisionId: generateId3()
+            };
+            onUpdate({ message: copiedMessage });
+          },
+          lastMessage,
+          onToolCall,
+          onFinish,
+          newMessageId: generateId3(),
+          messageMetadataSchema
+        }),
+        onError: (error) => {
+          throw error;
+        }
       });
       return;
     }
@@ -1783,6 +1359,7 @@ async function callChatApi({
 }
 
 // src/ui/call-completion-api.ts
+import { parseJsonEventStream as parseJsonEventStream2 } from "@ai-sdk/provider-utils";
 var getOriginalFetch2 = () => fetch;
 async function callCompletionApi({
   api,
@@ -1795,10 +1372,8 @@ async function callCompletionApi({
   setLoading,
   setError,
   setAbortController,
-  onResponse,
   onFinish,
   onError,
-  onData,
   fetch: fetch2 = getOriginalFetch2()
 }) {
   var _a17;
@@ -1823,13 +1398,6 @@ async function callCompletionApi({
     }).catch((err) => {
       throw err;
     });
-    if (onResponse) {
-      try {
-        await onResponse(response);
-      } catch (err) {
-        throw err;
-      }
-    }
     if (!response.ok) {
       throw new Error(
         (_a17 = await response.text()) != null ? _a17 : "Failed to fetch the chat response."
@@ -1851,17 +1419,28 @@ async function callCompletionApi({
         break;
       }
       case "data": {
-        await processDataStream({
-          stream: response.body,
-          onTextPart(value) {
-            result += value;
-            setCompletion(result);
-          },
-          onDataPart(value) {
-            onData == null ? void 0 : onData(value);
-          },
-          onErrorPart(value) {
-            throw new Error(value);
+        await consumeStream({
+          stream: parseJsonEventStream2({
+            stream: response.body,
+            schema: uiMessageStreamPartSchema
+          }).pipeThrough(
+            new TransformStream({
+              async transform(part) {
+                if (!part.success) {
+                  throw part.error;
+                }
+                const { type, value } = part.value;
+                if (type === "text") {
+                  result += value;
+                  setCompletion(result);
+                } else if (type === "error") {
+                  throw new Error(value);
+                }
+              }
+            })
+          ),
+          onError: (error) => {
+            throw error;
           }
         });
         break;
@@ -2074,57 +1653,185 @@ function convertToModelMessages(messages, options) {
       }
     }
   }
-  return modelMessages;
+  return modelMessages;
+}
+var convertToCoreMessages = convertToModelMessages;
+
+// src/ui/should-resubmit-messages.ts
+function shouldResubmitMessages({
+  originalMaxToolInvocationStep,
+  originalMessageCount,
+  maxSteps,
+  messages
+}) {
+  var _a17;
+  const lastMessage = messages[messages.length - 1];
+  return (
+    // check if the feature is enabled:
+    maxSteps > 1 && // ensure there is a last message:
+    lastMessage != null && // ensure we actually have new steps (to prevent infinite loops in case of errors):
+    (messages.length > originalMessageCount || extractMaxToolInvocationStep(getToolInvocations(lastMessage)) !== originalMaxToolInvocationStep) && // check that next step is possible:
+    isAssistantMessageWithCompletedToolCalls(lastMessage) && // limit the number of automatic steps:
+    ((_a17 = extractMaxToolInvocationStep(getToolInvocations(lastMessage))) != null ? _a17 : 0) < maxSteps
+  );
+}
+function isAssistantMessageWithCompletedToolCalls(message) {
+  if (message.role !== "assistant") {
+    return false;
+  }
+  const lastStepStartIndex = message.parts.reduce((lastIndex, part, index) => {
+    return part.type === "step-start" ? index : lastIndex;
+  }, -1);
+  const lastStepToolInvocations = message.parts.slice(lastStepStartIndex + 1).filter((part) => part.type === "tool-invocation");
+  return lastStepToolInvocations.length > 0 && lastStepToolInvocations.every((part) => "result" in part.toolInvocation);
+}
+
+// src/ui/update-tool-call-result.ts
+function updateToolCallResult({
+  messages,
+  toolCallId,
+  toolResult: result
+}) {
+  const lastMessage = messages[messages.length - 1];
+  const invocationPart = lastMessage.parts.find(
+    (part) => part.type === "tool-invocation" && part.toolInvocation.toolCallId === toolCallId
+  );
+  if (invocationPart == null) {
+    return;
+  }
+  invocationPart.toolInvocation = {
+    ...invocationPart.toolInvocation,
+    state: "result",
+    result
+  };
+}
+
+// src/ui-message-stream/create-ui-message-stream.ts
+function createUIMessageStream({
+  execute,
+  onError = () => "An error occurred."
+  // mask error messages for safety by default
+}) {
+  let controller;
+  const ongoingStreamPromises = [];
+  const stream = new ReadableStream({
+    start(controllerArg) {
+      controller = controllerArg;
+    }
+  });
+  function safeEnqueue(data) {
+    try {
+      controller.enqueue(data);
+    } catch (error) {
+    }
+  }
+  try {
+    const result = execute({
+      write(part) {
+        safeEnqueue(part);
+      },
+      merge(streamArg) {
+        ongoingStreamPromises.push(
+          (async () => {
+            const reader = streamArg.getReader();
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done)
+                break;
+              safeEnqueue(value);
+            }
+          })().catch((error) => {
+            safeEnqueue({ type: "error", value: onError(error) });
+          })
+        );
+      },
+      onError
+    });
+    if (result) {
+      ongoingStreamPromises.push(
+        result.catch((error) => {
+          safeEnqueue({ type: "error", value: onError(error) });
+        })
+      );
+    }
+  } catch (error) {
+    safeEnqueue({ type: "error", value: onError(error) });
+  }
+  const waitForStreams = new Promise(async (resolve) => {
+    while (ongoingStreamPromises.length > 0) {
+      await ongoingStreamPromises.shift();
+    }
+    resolve();
+  });
+  waitForStreams.finally(() => {
+    try {
+      controller.close();
+    } catch (error) {
+    }
+  });
+  return stream;
 }
-var convertToCoreMessages = convertToModelMessages;
 
-// src/ui/should-resubmit-messages.ts
-function shouldResubmitMessages({
-  originalMaxToolInvocationStep,
-  originalMessageCount,
-  maxSteps,
-  messages
+// src/ui-message-stream/ui-message-stream-headers.ts
+var uiMessageStreamHeaders = {
+  "content-type": "text/event-stream",
+  "cache-control": "no-cache",
+  connection: "keep-alive",
+  "x-vercel-ai-ui-message-stream": "v1",
+  "x-accel-buffering": "no"
+  // disable nginx buffering
+};
+
+// src/ui-message-stream/json-to-sse-transform-stream.ts
+var JsonToSseTransformStream = class extends TransformStream {
+  constructor() {
+    super({
+      transform(part, controller) {
+        controller.enqueue(`data: ${JSON.stringify(part)}
+
+`);
+      },
+      flush(controller) {
+        controller.enqueue("data: [DONE]\n\n");
+      }
+    });
+  }
+};
+
+// src/ui-message-stream/create-ui-message-stream-response.ts
+function createUIMessageStreamResponse({
+  status,
+  statusText,
+  headers,
+  stream
 }) {
-  var _a17;
-  const lastMessage = messages[messages.length - 1];
-  return (
-    // check if the feature is enabled:
-    maxSteps > 1 && // ensure there is a last message:
-    lastMessage != null && // ensure we actually have new steps (to prevent infinite loops in case of errors):
-    (messages.length > originalMessageCount || extractMaxToolInvocationStep(getToolInvocations(lastMessage)) !== originalMaxToolInvocationStep) && // check that next step is possible:
-    isAssistantMessageWithCompletedToolCalls(lastMessage) && // limit the number of automatic steps:
-    ((_a17 = extractMaxToolInvocationStep(getToolInvocations(lastMessage))) != null ? _a17 : 0) < maxSteps
+  return new Response(
+    stream.pipeThrough(new JsonToSseTransformStream()).pipeThrough(new TextEncoderStream()),
+    {
+      status,
+      statusText,
+      headers: prepareHeaders(headers, uiMessageStreamHeaders)
+    }
   );
 }
-function isAssistantMessageWithCompletedToolCalls(message) {
-  if (message.role !== "assistant") {
-    return false;
-  }
-  const lastStepStartIndex = message.parts.reduce((lastIndex, part, index) => {
-    return part.type === "step-start" ? index : lastIndex;
-  }, -1);
-  const lastStepToolInvocations = message.parts.slice(lastStepStartIndex + 1).filter((part) => part.type === "tool-invocation");
-  return lastStepToolInvocations.length > 0 && lastStepToolInvocations.every((part) => "result" in part.toolInvocation);
-}
 
-// src/ui/update-tool-call-result.ts
-function updateToolCallResult({
-  messages,
-  toolCallId,
-  toolResult: result
+// src/ui-message-stream/pipe-ui-message-stream-to-response.ts
+function pipeUIMessageStreamToResponse({
+  response,
+  status,
+  statusText,
+  headers,
+  stream
 }) {
-  const lastMessage = messages[messages.length - 1];
-  const invocationPart = lastMessage.parts.find(
-    (part) => part.type === "tool-invocation" && part.toolInvocation.toolCallId === toolCallId
-  );
-  if (invocationPart == null) {
-    return;
-  }
-  invocationPart.toolInvocation = {
-    ...invocationPart.toolInvocation,
-    state: "result",
-    result
-  };
+  writeToServerResponse({
+    response,
+    status,
+    statusText,
+    headers: Object.fromEntries(
+      prepareHeaders(headers, uiMessageStreamHeaders).entries()
+    ),
+    stream: stream.pipeThrough(new JsonToSseTransformStream()).pipeThrough(new TextEncoderStream())
+  });
 }
 
 // src/util/data-url.ts
@@ -2821,7 +2528,7 @@ var DefaultEmbedManyResult = class {
 };
 
 // src/util/detect-media-type.ts
-import { convertBase64ToUint8Array as convertBase64ToUint8Array2 } from "@ai-sdk/provider-utils";
+import { convertBase64ToUint8Array } from "@ai-sdk/provider-utils";
 var imageMediaTypeSignatures = [
   {
     mediaType: "image/gif",
@@ -2928,7 +2635,7 @@ var audioMediaTypeSignatures = [
   }
 ];
 var stripID3 = (data) => {
-  const bytes = typeof data === "string" ? convertBase64ToUint8Array2(data) : data;
+  const bytes = typeof data === "string" ? convertBase64ToUint8Array(data) : data;
   const id3Size = (bytes[6] & 127) << 21 | (bytes[7] & 127) << 14 | (bytes[8] & 127) << 7 | bytes[9] & 127;
   return bytes.slice(id3Size + 10);
 };
@@ -2955,8 +2662,8 @@ function detectMediaType({
 
 // core/generate-text/generated-file.ts
 import {
-  convertBase64ToUint8Array as convertBase64ToUint8Array3,
-  convertUint8ArrayToBase64 as convertUint8ArrayToBase642
+  convertBase64ToUint8Array as convertBase64ToUint8Array2,
+  convertUint8ArrayToBase64
 } from "@ai-sdk/provider-utils";
 var DefaultGeneratedFile = class {
   constructor({
@@ -2971,14 +2678,14 @@ var DefaultGeneratedFile = class {
   // lazy conversion with caching to avoid unnecessary conversion overhead:
   get base64() {
     if (this.base64Data == null) {
-      this.base64Data = convertUint8ArrayToBase642(this.uint8ArrayData);
+      this.base64Data = convertUint8ArrayToBase64(this.uint8ArrayData);
     }
     return this.base64Data;
   }
   // lazy conversion with caching to avoid unnecessary conversion overhead:
   get uint8Array() {
     if (this.uint8ArrayData == null) {
-      this.uint8ArrayData = convertBase64ToUint8Array3(this.base64Data);
+      this.uint8ArrayData = convertBase64ToUint8Array2(this.base64Data);
     }
     return this.uint8ArrayData;
   }
@@ -2995,6 +2702,7 @@ async function generateImage({
   model,
   prompt,
   n = 1,
+  maxImagesPerCall,
   size,
   aspectRatio,
   seed,
@@ -3005,14 +2713,14 @@ async function generateImage({
 }) {
   var _a17, _b;
   const { retry } = prepareRetries({ maxRetries: maxRetriesArg });
-  const maxImagesPerCall = (_a17 = model.maxImagesPerCall) != null ? _a17 : 1;
-  const callCount = Math.ceil(n / maxImagesPerCall);
+  const maxImagesPerCallWithDefault = (_a17 = maxImagesPerCall != null ? maxImagesPerCall : model.maxImagesPerCall) != null ? _a17 : 1;
+  const callCount = Math.ceil(n / maxImagesPerCallWithDefault);
   const callImageCounts = Array.from({ length: callCount }, (_, i) => {
     if (i < callCount - 1) {
-      return maxImagesPerCall;
+      return maxImagesPerCallWithDefault;
     }
-    const remainder = n % maxImagesPerCall;
-    return remainder === 0 ? maxImagesPerCall : remainder;
+    const remainder = n % maxImagesPerCallWithDefault;
+    return remainder === 0 ? maxImagesPerCallWithDefault : remainder;
   });
   const results = await Promise.all(
     callImageCounts.map(
@@ -3089,7 +2797,7 @@ import {
 } from "@ai-sdk/provider";
 import {
   createIdGenerator,
-  safeParseJSON as safeParseJSON3
+  safeParseJSON as safeParseJSON2
 } from "@ai-sdk/provider-utils";
 
 // core/generate-text/extract-content-text.ts
@@ -3131,6 +2839,92 @@ async function download({ url }) {
   }
 }
 
+// core/prompt/data-content.ts
+import { AISDKError as AISDKError17 } from "@ai-sdk/provider";
+import {
+  convertBase64ToUint8Array as convertBase64ToUint8Array3,
+  convertUint8ArrayToBase64 as convertUint8ArrayToBase642
+} from "@ai-sdk/provider-utils";
+import { z as z2 } from "zod";
+
+// core/prompt/split-data-url.ts
+function splitDataUrl(dataUrl) {
+  try {
+    const [header, base64Content] = dataUrl.split(",");
+    return {
+      mediaType: header.split(";")[0].split(":")[1],
+      base64Content
+    };
+  } catch (error) {
+    return {
+      mediaType: void 0,
+      base64Content: void 0
+    };
+  }
+}
+
+// core/prompt/data-content.ts
+var dataContentSchema = z2.union([
+  z2.string(),
+  z2.instanceof(Uint8Array),
+  z2.instanceof(ArrayBuffer),
+  z2.custom(
+    // Buffer might not be available in some environments such as CloudFlare:
+    (value) => {
+      var _a17, _b;
+      return (_b = (_a17 = globalThis.Buffer) == null ? void 0 : _a17.isBuffer(value)) != null ? _b : false;
+    },
+    { message: "Must be a Buffer" }
+  )
+]);
+function convertToLanguageModelV2DataContent(content) {
+  if (content instanceof Uint8Array) {
+    return { data: content, mediaType: void 0 };
+  }
+  if (content instanceof ArrayBuffer) {
+    return { data: new Uint8Array(content), mediaType: void 0 };
+  }
+  if (typeof content === "string") {
+    try {
+      content = new URL(content);
+    } catch (error) {
+    }
+  }
+  if (content instanceof URL && content.protocol === "data:") {
+    const { mediaType: dataUrlMediaType, base64Content } = splitDataUrl(
+      content.toString()
+    );
+    if (dataUrlMediaType == null || base64Content == null) {
+      throw new AISDKError17({
+        name: "InvalidDataContentError",
+        message: `Invalid data URL format in content ${content.toString()}`
+      });
+    }
+    return { data: base64Content, mediaType: dataUrlMediaType };
+  }
+  return { data: content, mediaType: void 0 };
+}
+function convertDataContentToUint8Array(content) {
+  if (content instanceof Uint8Array) {
+    return content;
+  }
+  if (typeof content === "string") {
+    try {
+      return convertBase64ToUint8Array3(content);
+    } catch (error) {
+      throw new InvalidDataContentError({
+        message: "Invalid data content. Content string is not a base64-encoded media.",
+        content,
+        cause: error
+      });
+    }
+  }
+  if (content instanceof ArrayBuffer) {
+    return new Uint8Array(content);
+  }
+  throw new InvalidDataContentError({ content });
+}
+
 // core/prompt/convert-to-language-model-prompt.ts
 async function convertToLanguageModelPrompt({
   prompt,
@@ -3351,8 +3145,8 @@ function prepareCallSettings({
   topK,
   presencePenalty,
   frequencyPenalty,
-  stopSequences,
-  seed
+  seed,
+  stopSequences
 }) {
   if (maxOutputTokens != null) {
     if (!Number.isInteger(maxOutputTokens)) {
@@ -3426,12 +3220,12 @@ function prepareCallSettings({
   }
   return {
     maxOutputTokens,
-    temperature: temperature != null ? temperature : temperature === null ? void 0 : 0,
+    temperature,
     topP,
     topK,
     presencePenalty,
     frequencyPenalty,
-    stopSequences: stopSequences != null && stopSequences.length > 0 ? stopSequences : void 0,
+    stopSequences,
     seed
   };
 }
@@ -3638,6 +3432,23 @@ import {
   asSchema,
   safeValidateTypes as safeValidateTypes2
 } from "@ai-sdk/provider-utils";
+
+// src/util/async-iterable-stream.ts
+function createAsyncIterableStream(source) {
+  const stream = source.pipeThrough(new TransformStream());
+  stream[Symbol.asyncIterator] = () => {
+    const reader = stream.getReader();
+    return {
+      async next() {
+        const { done, value } = await reader.read();
+        return done ? { done: true, value: void 0 } : { done: false, value };
+      }
+    };
+  };
+  return stream;
+}
+
+// core/generate-object/output-strategy.ts
 var noSchemaOutputStrategy = {
   type: "no-schema",
   jsonSchema: void 0,
@@ -4188,7 +3999,7 @@ async function generateObject(options) {
       request = (_a17 = generateResult.request) != null ? _a17 : {};
       response = generateResult.responseData;
       async function processResult(result2) {
-        const parseResult = await safeParseJSON3({ text: result2 });
+        const parseResult = await safeParseJSON2({ text: result2 });
         if (!parseResult.success) {
           throw new NoObjectGeneratedError({
             message: "No object generated: could not parse the response.",
@@ -4933,8 +4744,8 @@ var DefaultStreamObjectResult = class {
 };
 
 // src/error/no-speech-generated-error.ts
-import { AISDKError as AISDKError19 } from "@ai-sdk/provider";
-var NoSpeechGeneratedError = class extends AISDKError19 {
+import { AISDKError as AISDKError18 } from "@ai-sdk/provider";
+var NoSpeechGeneratedError = class extends AISDKError18 {
   constructor(options) {
     super({
       name: "AI_NoSpeechGeneratedError",
@@ -5025,19 +4836,6 @@ var DefaultSpeechResult = class {
 // core/generate-text/generate-text.ts
 import { createIdGenerator as createIdGenerator3 } from "@ai-sdk/provider-utils";
 
-// src/util/split-on-last-whitespace.ts
-var lastWhitespaceRegexp = /^([\s\S]*?)(\s+)(\S*)$/;
-function splitOnLastWhitespace(text2) {
-  const match = text2.match(lastWhitespaceRegexp);
-  return match ? { prefix: match[1], whitespace: match[2], suffix: match[3] } : void 0;
-}
-
-// src/util/remove-text-after-last-whitespace.ts
-function removeTextAfterLastWhitespace(text2) {
-  const match = splitOnLastWhitespace(text2);
-  return match ? match.prefix + match.whitespace : text2;
-}
-
 // core/prompt/prepare-tools-and-tool-choice.ts
 import { asSchema as asSchema2 } from "@ai-sdk/provider-utils";
 
@@ -5139,20 +4937,11 @@ function asContent({
     ...toolResults
   ];
 }
-function extractFiles(content) {
-  return content.filter((part) => part.type === "file").map((part) => part.file);
-}
-function extractReasoning(content) {
-  return content.filter((part) => part.type === "reasoning");
-}
-function extractSources(content) {
-  return content.filter((part) => part.type === "source");
-}
 
 // core/generate-text/parse-tool-call.ts
 import {
   asSchema as asSchema3,
-  safeParseJSON as safeParseJSON4,
+  safeParseJSON as safeParseJSON3,
   safeValidateTypes as safeValidateTypes3
 } from "@ai-sdk/provider-utils";
 async function parseToolCall({
@@ -5208,88 +4997,118 @@ async function doParseToolCall({
       availableTools: Object.keys(tools)
     });
   }
-  const schema = asSchema3(tool2.parameters);
-  const parseResult = toolCall.args.trim() === "" ? await safeValidateTypes3({ value: {}, schema }) : await safeParseJSON4({ text: toolCall.args, schema });
-  if (parseResult.success === false) {
-    throw new InvalidToolArgumentsError({
-      toolName,
-      toolArgs: toolCall.args,
-      cause: parseResult.error
-    });
+  const schema = asSchema3(tool2.parameters);
+  const parseResult = toolCall.args.trim() === "" ? await safeValidateTypes3({ value: {}, schema }) : await safeParseJSON3({ text: toolCall.args, schema });
+  if (parseResult.success === false) {
+    throw new InvalidToolArgumentsError({
+      toolName,
+      toolArgs: toolCall.args,
+      cause: parseResult.error
+    });
+  }
+  return {
+    type: "tool-call",
+    toolCallId: toolCall.toolCallId,
+    toolName,
+    args: parseResult == null ? void 0 : parseResult.value
+  };
+}
+
+// core/generate-text/step-result.ts
+var DefaultStepResult = class {
+  constructor({
+    content,
+    finishReason,
+    usage,
+    warnings,
+    request,
+    response,
+    providerMetadata
+  }) {
+    this.content = content;
+    this.finishReason = finishReason;
+    this.usage = usage;
+    this.warnings = warnings;
+    this.request = request;
+    this.response = response;
+    this.providerMetadata = providerMetadata;
+  }
+  get text() {
+    return this.content.filter((part) => part.type === "text").map((part) => part.text).join("");
+  }
+  get reasoning() {
+    return this.content.filter((part) => part.type === "reasoning");
+  }
+  get reasoningText() {
+    return this.reasoning.length === 0 ? void 0 : this.reasoning.map((part) => part.text).join("");
+  }
+  get files() {
+    return this.content.filter((part) => part.type === "file").map((part) => part.file);
+  }
+  get sources() {
+    return this.content.filter((part) => part.type === "source");
+  }
+  get toolCalls() {
+    return this.content.filter((part) => part.type === "tool-call");
   }
-  return {
-    type: "tool-call",
-    toolCallId: toolCall.toolCallId,
-    toolName,
-    args: parseResult == null ? void 0 : parseResult.value
-  };
-}
-
-// core/generate-text/reasoning.ts
-function asReasoningText(reasoningParts) {
-  const reasoningText = reasoningParts.map((part) => part.text).join("");
-  return reasoningText.length > 0 ? reasoningText : void 0;
-}
+  get toolResults() {
+    return this.content.filter((part) => part.type === "tool-result");
+  }
+};
 
 // core/generate-text/to-response-messages.ts
 function toResponseMessages({
-  text: text2 = "",
-  files,
-  reasoning,
-  tools,
-  toolCalls,
-  toolResults,
-  messageId,
-  generateMessageId
+  content: inputContent,
+  tools
 }) {
   const responseMessages = [];
-  const content = [];
-  for (const part of reasoning) {
-    content.push(part);
-  }
-  if (files.length > 0) {
-    content.push(
-      ...files.map((file) => ({
-        type: "file",
-        data: file.base64,
-        mediaType: file.mediaType
-      }))
-    );
-  }
-  if (text2.length > 0) {
-    content.push({ type: "text", text: text2 });
-  }
-  if (toolCalls.length > 0) {
-    content.push(...toolCalls);
-  }
+  const content = inputContent.filter((part) => part.type !== "tool-result" && part.type !== "source").filter((part) => part.type !== "text" || part.text.length > 0).map((part) => {
+    switch (part.type) {
+      case "text":
+        return part;
+      case "reasoning":
+        return {
+          type: "reasoning",
+          text: part.text,
+          providerOptions: part.providerMetadata
+        };
+      case "file":
+        return {
+          type: "file",
+          data: part.file.base64,
+          mediaType: part.file.mediaType
+        };
+      case "tool-call":
+        return part;
+    }
+  });
   if (content.length > 0) {
     responseMessages.push({
       role: "assistant",
-      content,
-      id: messageId
+      content
     });
   }
-  if (toolResults.length > 0) {
+  const toolResultContent = inputContent.filter((part) => part.type === "tool-result").map((toolResult) => {
+    const tool2 = tools[toolResult.toolName];
+    return (tool2 == null ? void 0 : tool2.experimental_toToolResultContent) != null ? {
+      type: "tool-result",
+      toolCallId: toolResult.toolCallId,
+      toolName: toolResult.toolName,
+      result: tool2.experimental_toToolResultContent(toolResult.result),
+      experimental_content: tool2.experimental_toToolResultContent(
+        toolResult.result
+      )
+    } : {
+      type: "tool-result",
+      toolCallId: toolResult.toolCallId,
+      toolName: toolResult.toolName,
+      result: toolResult.result
+    };
+  });
+  if (toolResultContent.length > 0) {
     responseMessages.push({
       role: "tool",
-      id: generateMessageId(),
-      content: toolResults.map((toolResult) => {
-        const tool2 = tools[toolResult.toolName];
-        return (tool2 == null ? void 0 : tool2.experimental_toToolResultContent) != null ? {
-          type: "tool-result",
-          toolCallId: toolResult.toolCallId,
-          toolName: toolResult.toolName,
-          result: tool2.experimental_toToolResultContent(toolResult.result),
-          experimental_content: tool2.experimental_toToolResultContent(
-            toolResult.result
-          )
-        } : {
-          type: "tool-result",
-          toolCallId: toolResult.toolCallId,
-          toolName: toolResult.toolName,
-          result: toolResult.result
-        };
-      })
+      content: toolResultContent
     });
   }
   return responseMessages;
@@ -5300,10 +5119,6 @@ var originalGenerateId3 = createIdGenerator3({
   prefix: "aitxt",
   size: 24
 });
-var originalGenerateMessageId = createIdGenerator3({
-  prefix: "msg",
-  size: 24
-});
 async function generateText({
   model,
   tools,
@@ -5315,9 +5130,7 @@ async function generateText({
   abortSignal,
   headers,
   maxSteps = 1,
-  experimental_generateMessageId: generateMessageId = originalGenerateMessageId,
   experimental_output: output,
-  experimental_continueSteps: continueSteps = false,
   experimental_telemetry: telemetry,
   providerOptions,
   experimental_activeTools: activeTools,
@@ -5373,22 +5186,14 @@ async function generateText({
     }),
     tracer,
     fn: async (span) => {
-      var _a17, _b, _c, _d, _e, _f;
+      var _a17, _b, _c, _d;
       const callSettings2 = prepareCallSettings(settings);
       let currentModelResponse;
       let currentToolCalls = [];
       let currentToolResults = [];
       let stepCount = 0;
       const responseMessages = [];
-      let text2 = "";
-      const sources = [];
       const steps = [];
-      let usage = {
-        inputTokens: void 0,
-        outputTokens: void 0,
-        totalTokens: void 0
-      };
-      let stepType = "initial";
       do {
         const stepInputMessages = [
           ...initialPrompt.messages,
@@ -5454,7 +5259,7 @@ async function generateText({
               }),
               tracer,
               fn: async (span2) => {
-                var _a19, _b2, _c2, _d2, _e2, _f2, _g, _h;
+                var _a19, _b2, _c2, _d2, _e, _f, _g, _h;
                 const result = await stepModel.doGenerate({
                   ...callSettings2,
                   tools: stepTools,
@@ -5468,7 +5273,7 @@ async function generateText({
                 const responseData = {
                   id: (_b2 = (_a19 = result.response) == null ? void 0 : _a19.id) != null ? _b2 : generateId3(),
                   timestamp: (_d2 = (_c2 = result.response) == null ? void 0 : _c2.timestamp) != null ? _d2 : currentDate(),
-                  modelId: (_f2 = (_e2 = result.response) == null ? void 0 : _e2.modelId) != null ? _f2 : stepModel.modelId,
+                  modelId: (_f = (_e = result.response) == null ? void 0 : _e.modelId) != null ? _f : stepModel.modelId,
                   headers: (_g = result.response) == null ? void 0 : _g.headers,
                   body: (_h = result.response) == null ? void 0 : _h.body
                 };
@@ -5527,89 +5332,35 @@ async function generateText({
           messages: stepInputMessages,
           abortSignal
         });
-        usage = addLanguageModelUsage(usage, currentModelResponse.usage);
-        let nextStepType = "done";
-        if (++stepCount < maxSteps) {
-          if (continueSteps && currentModelResponse.finishReason === "length" && // only use continue when there are no tool calls:
-          currentToolCalls.length === 0) {
-            nextStepType = "continue";
-          } else if (
-            // there are tool calls:
-            currentToolCalls.length > 0 && // all current tool calls have results:
-            currentToolResults.length === currentToolCalls.length
-          ) {
-            nextStepType = "tool-result";
-          }
-        }
         const stepContent = asContent({
           content: currentModelResponse.content,
           toolCalls: currentToolCalls,
           toolResults: currentToolResults
         });
-        const originalText = (_d = extractContentText(currentModelResponse.content)) != null ? _d : "";
-        const stepTextLeadingWhitespaceTrimmed = stepType === "continue" && // only for continue steps
-        text2.trimEnd() !== text2 ? originalText.trimStart() : originalText;
-        const stepText = nextStepType === "continue" ? removeTextAfterLastWhitespace(stepTextLeadingWhitespaceTrimmed) : stepTextLeadingWhitespaceTrimmed;
-        text2 = nextStepType === "continue" || stepType === "continue" ? text2 + stepText : stepText;
-        sources.push(
-          ...currentModelResponse.content.filter(
-            (part) => part.type === "source"
-          )
+        responseMessages.push(
+          ...toResponseMessages({
+            content: stepContent,
+            tools: tools != null ? tools : {}
+          })
         );
-        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: text2,
-              files: extractFiles(stepContent),
-              reasoning: extractReasoning(stepContent).map((part) => ({
-                type: "reasoning",
-                text: part.text,
-                providerOptions: part.providerMetadata
-              })),
-              tools: tools != null ? tools : {},
-              toolCalls: currentToolCalls,
-              toolResults: currentToolResults,
-              messageId: generateMessageId(),
-              generateMessageId
-            })
-          );
-        }
-        const currentStepResult = {
-          stepType,
+        const currentStepResult = new DefaultStepResult({
           content: stepContent,
-          text: stepText,
-          reasoningText: asReasoningText(extractReasoning(stepContent)),
-          reasoning: extractReasoning(stepContent),
-          files: extractFiles(stepContent),
-          sources: extractSources(stepContent),
-          toolCalls: currentToolCalls,
-          toolResults: currentToolResults,
           finishReason: currentModelResponse.finishReason,
           usage: currentModelResponse.usage,
           warnings: currentModelResponse.warnings,
-          request: (_e = currentModelResponse.request) != null ? _e : {},
+          providerMetadata: currentModelResponse.providerMetadata,
+          request: (_d = currentModelResponse.request) != null ? _d : {},
           response: {
             ...currentModelResponse.response,
             // deep clone msgs to avoid mutating past messages in multi-step:
             messages: structuredClone(responseMessages)
-          },
-          providerMetadata: currentModelResponse.providerMetadata,
-          isContinued: nextStepType === "continue"
-        };
+          }
+        });
         steps.push(currentStepResult);
         await (onStepFinish == null ? void 0 : onStepFinish(currentStepResult));
-        stepType = nextStepType;
-      } while (stepType !== "done");
+      } while (++stepCount < maxSteps && // there are tool calls:
+      currentToolCalls.length > 0 && // all current tool calls have results:
+      currentToolResults.length === currentToolCalls.length);
       span.setAttributes(
         selectTelemetryAttributes({
           telemetry,
@@ -5630,32 +5381,17 @@ async function generateText({
           }
         })
       );
-      const resolvedOutput = await (output == null ? void 0 : output.parseOutput(
-        { text: text2 },
-        {
-          response: currentModelResponse.response,
-          usage,
-          finishReason: currentModelResponse.finishReason
-        }
-      ));
+      const lastStep = steps[steps.length - 1];
       return new DefaultGenerateTextResult({
-        text: text2,
-        content: asContent({
-          content: currentModelResponse.content,
-          toolCalls: currentToolCalls,
-          toolResults: currentToolResults
-        }),
-        resolvedOutput,
-        finishReason: currentModelResponse.finishReason,
-        usage,
-        warnings: currentModelResponse.warnings,
-        request: (_f = currentModelResponse.request) != null ? _f : {},
-        response: {
-          ...currentModelResponse.response,
-          messages: responseMessages
-        },
         steps,
-        providerMetadata: currentModelResponse.providerMetadata
+        resolvedOutput: await (output == null ? void 0 : output.parseOutput(
+          { text: lastStep.text },
+          {
+            response: lastStep.response,
+            usage: lastStep.usage,
+            finishReason: lastStep.finishReason
+          }
+        ))
       });
     }
   });
@@ -5737,35 +5473,67 @@ async function executeTools({
 }
 var DefaultGenerateTextResult = class {
   constructor(options) {
-    this.text = options.text;
-    this.content = options.content;
-    this.finishReason = options.finishReason;
-    this.usage = options.usage;
-    this.warnings = options.warnings;
-    this.request = options.request;
-    this.response = options.response;
     this.steps = options.steps;
-    this.providerMetadata = options.providerMetadata;
     this.resolvedOutput = options.resolvedOutput;
   }
+  get finalStep() {
+    return this.steps[this.steps.length - 1];
+  }
+  get content() {
+    return this.finalStep.content;
+  }
+  get text() {
+    return this.finalStep.text;
+  }
   get files() {
-    return extractFiles(this.content);
+    return this.finalStep.files;
   }
   get reasoningText() {
-    const texts = this.content.filter((part) => part.type === "reasoning").map((part) => part.text);
-    return texts.length > 0 ? texts.join("") : void 0;
+    return this.finalStep.reasoningText;
   }
   get reasoning() {
-    return this.content.filter((part) => part.type === "reasoning");
+    return this.finalStep.reasoning;
   }
   get toolCalls() {
-    return this.content.filter((part) => part.type === "tool-call");
+    return this.finalStep.toolCalls;
   }
   get toolResults() {
-    return this.content.filter((part) => part.type === "tool-result");
+    return this.finalStep.toolResults;
   }
   get sources() {
-    return this.steps.flatMap((step) => step.sources);
+    return this.finalStep.sources;
+  }
+  get finishReason() {
+    return this.finalStep.finishReason;
+  }
+  get warnings() {
+    return this.finalStep.warnings;
+  }
+  get providerMetadata() {
+    return this.finalStep.providerMetadata;
+  }
+  get response() {
+    return this.finalStep.response;
+  }
+  get request() {
+    return this.finalStep.request;
+  }
+  get usage() {
+    return this.finalStep.usage;
+  }
+  get totalUsage() {
+    return this.steps.reduce(
+      (totalUsage, step) => {
+        return addLanguageModelUsage(totalUsage, step.usage);
+      },
+      {
+        inputTokens: void 0,
+        outputTokens: void 0,
+        totalTokens: void 0,
+        reasoningTokens: void 0,
+        cachedInputTokens: void 0
+      }
+    );
   }
   get experimental_output() {
     if (this.resolvedOutput == null) {
@@ -5797,7 +5565,7 @@ __export(output_exports, {
 });
 import {
   asSchema as asSchema4,
-  safeParseJSON as safeParseJSON5,
+  safeParseJSON as safeParseJSON4,
   safeValidateTypes as safeValidateTypes4
 } from "@ai-sdk/provider-utils";
 var text = () => ({
@@ -5839,7 +5607,7 @@ var object = ({
       }
     },
     async parseOutput({ text: text2 }, context) {
-      const parseResult = await safeParseJSON5({ text: text2 });
+      const parseResult = await safeParseJSON4({ text: text2 });
       if (!parseResult.success) {
         throw new NoObjectGeneratedError({
           message: "No object generated: could not parse the response.",
@@ -5946,25 +5714,6 @@ function asArray(value) {
   return value === void 0 ? [] : Array.isArray(value) ? value : [value];
 }
 
-// src/util/consume-stream.ts
-async function consumeStream({
-  stream,
-  onError
-}) {
-  const reader = stream.getReader();
-  try {
-    while (true) {
-      const { done } = await reader.read();
-      if (done)
-        break;
-    }
-  } catch (error) {
-    onError == null ? void 0 : onError(error);
-  } finally {
-    reader.releaseLock();
-  }
-}
-
 // core/generate-text/run-tools-transformation.ts
 import { generateId } from "@ai-sdk/provider-utils";
 function runToolsTransformation({
@@ -6165,10 +5914,6 @@ var originalGenerateId4 = createIdGenerator4({
   prefix: "aitxt",
   size: 24
 });
-var originalGenerateMessageId2 = createIdGenerator4({
-  prefix: "msg",
-  size: 24
-});
 function streamText({
   model,
   tools,
@@ -6180,9 +5925,7 @@ function streamText({
   abortSignal,
   headers,
   maxSteps = 1,
-  experimental_generateMessageId: generateMessageId = originalGenerateMessageId2,
   experimental_output: output,
-  experimental_continueSteps: continueSteps = false,
   experimental_telemetry: telemetry,
   providerOptions,
   experimental_toolCallStreaming = false,
@@ -6219,7 +5962,6 @@ function streamText({
     repairToolCall,
     maxSteps,
     output,
-    continueSteps,
     providerOptions,
     onChunk,
     onError,
@@ -6227,8 +5969,7 @@ function streamText({
     onStepFinish,
     now: now2,
     currentDate,
-    generateId: generateId3,
-    generateMessageId
+    generateId: generateId3
   });
 }
 function createOutputTransformStream(output) {
@@ -6254,7 +5995,7 @@ function createOutputTransformStream(output) {
   }
   return new TransformStream({
     async transform(chunk, controller) {
-      if (chunk.type === "step-finish") {
+      if (chunk.type === "finish-step") {
         publishTextChunk({ controller });
       }
       if (chunk.type !== "text") {
@@ -6298,32 +6039,18 @@ var DefaultStreamTextResult = class {
     repairToolCall,
     maxSteps,
     output,
-    continueSteps,
     providerOptions,
     now: now2,
     currentDate,
     generateId: generateId3,
-    generateMessageId,
     onChunk,
     onError,
     onFinish,
     onStepFinish
   }) {
-    this.warningsPromise = new DelayedPromise();
-    this.usagePromise = new DelayedPromise();
+    this.totalUsagePromise = new DelayedPromise();
     this.finishReasonPromise = new DelayedPromise();
-    this.providerMetadataPromise = new DelayedPromise();
-    this.textPromise = new DelayedPromise();
-    this.reasoningPromise = new DelayedPromise();
-    this.reasoningDetailsPromise = new DelayedPromise();
-    this.sourcesPromise = new DelayedPromise();
-    this.filesPromise = new DelayedPromise();
-    this.toolCallsPromise = new DelayedPromise();
-    this.toolResultsPromise = new DelayedPromise();
-    this.requestPromise = new DelayedPromise();
-    this.responsePromise = new DelayedPromise();
     this.stepsPromise = new DelayedPromise();
-    this.contentPromise = new DelayedPromise();
     if (maxSteps < 1) {
       throw new InvalidArgumentError({
         parameter: "maxSteps",
@@ -6332,23 +6059,14 @@ var DefaultStreamTextResult = class {
       });
     }
     this.output = output;
-    let recordedStepText = "";
-    let recordedContinuationText = "";
-    let recordedFullText = "";
+    this.generateId = generateId3;
     let activeReasoningPart = void 0;
     let recordedContent = [];
-    const recordedSources = [];
-    const recordedResponse = {
-      id: generateId3(),
-      timestamp: currentDate(),
-      modelId: model.modelId,
-      messages: []
-    };
-    let recordedToolCalls = [];
-    let recordedToolResults = [];
+    const recordedResponseMessages = [];
     let recordedFinishReason = void 0;
-    let recordedUsage = void 0;
-    let stepType = "initial";
+    let recordedTotalUsage = void 0;
+    let recordedRequest = {};
+    let recordedWarnings = [];
     const recordedSteps = [];
     let rootSpan;
     const eventProcessor = new TransformStream({
@@ -6362,9 +6080,6 @@ var DefaultStreamTextResult = class {
           await (onError == null ? void 0 : onError({ error: part.error }));
         }
         if (part.type === "text") {
-          recordedStepText += part.text;
-          recordedContinuationText += part.text;
-          recordedFullText += part.text;
           const latestContent = recordedContent[recordedContent.length - 1];
           if ((latestContent == null ? void 0 : latestContent.type) === "text") {
             latestContent.text += part.text;
@@ -6377,12 +6092,12 @@ var DefaultStreamTextResult = class {
             activeReasoningPart = {
               type: "reasoning",
               text: part.text,
-              providerOptions: part.providerMetadata
+              providerMetadata: part.providerMetadata
             };
             recordedContent.push(activeReasoningPart);
           } else {
             activeReasoningPart.text += part.text;
-            activeReasoningPart.providerOptions = part.providerMetadata;
+            activeReasoningPart.providerMetadata = part.providerMetadata;
           }
         }
         if (part.type === "reasoning-part-finish" && activeReasoningPart != null) {
@@ -6393,129 +6108,76 @@ var DefaultStreamTextResult = class {
         }
         if (part.type === "source") {
           recordedContent.push(part);
-          recordedSources.push(part);
         }
         if (part.type === "tool-call") {
           recordedContent.push(part);
-          recordedToolCalls.push(part);
         }
         if (part.type === "tool-result") {
           recordedContent.push(part);
-          recordedToolResults.push(part);
         }
-        if (part.type === "step-finish") {
+        if (part.type === "start-step") {
+          recordedRequest = part.request;
+          recordedWarnings = part.warnings;
+        }
+        if (part.type === "finish-step") {
           const stepMessages = toResponseMessages({
-            text: recordedContinuationText,
-            files: extractFiles(recordedContent),
-            reasoning: extractReasoning(recordedContent),
-            tools: tools != null ? tools : {},
-            toolCalls: recordedToolCalls,
-            toolResults: recordedToolResults,
-            messageId: part.messageId,
-            generateMessageId
+            content: recordedContent,
+            tools: tools != null ? tools : {}
           });
-          const currentStep = recordedSteps.length;
-          let nextStepType = "done";
-          if (currentStep + 1 < maxSteps) {
-            if (continueSteps && part.finishReason === "length" && // only use continue when there are no tool calls:
-            recordedToolCalls.length === 0) {
-              nextStepType = "continue";
-            } else if (
-              // there are tool calls:
-              recordedToolCalls.length > 0 && // all current tool calls have results:
-              recordedToolResults.length === recordedToolCalls.length
-            ) {
-              nextStepType = "tool-result";
-            }
-          }
-          const currentStepResult = {
-            stepType,
+          const currentStepResult = new DefaultStepResult({
             content: recordedContent,
-            text: recordedStepText,
-            reasoningText: asReasoningText(extractReasoning(recordedContent)),
-            reasoning: extractReasoning(recordedContent),
-            files: extractFiles(recordedContent),
-            sources: extractSources(recordedContent),
-            toolCalls: recordedToolCalls,
-            toolResults: recordedToolResults,
             finishReason: part.finishReason,
             usage: part.usage,
-            warnings: part.warnings,
-            request: part.request,
+            warnings: recordedWarnings,
+            request: recordedRequest,
             response: {
               ...part.response,
-              messages: [...recordedResponse.messages, ...stepMessages]
+              messages: [...recordedResponseMessages, ...stepMessages]
             },
-            providerMetadata: part.providerMetadata,
-            isContinued: part.isContinued
-          };
+            providerMetadata: part.providerMetadata
+          });
           await (onStepFinish == null ? void 0 : onStepFinish(currentStepResult));
           recordedSteps.push(currentStepResult);
           recordedContent = [];
-          recordedToolCalls = [];
-          recordedToolResults = [];
-          recordedStepText = "";
           activeReasoningPart = void 0;
-          if (nextStepType !== "done") {
-            stepType = nextStepType;
-          }
-          if (nextStepType !== "continue") {
-            recordedResponse.messages.push(...stepMessages);
-            recordedContinuationText = "";
-          }
+          recordedResponseMessages.push(...stepMessages);
         }
         if (part.type === "finish") {
-          recordedResponse.id = part.response.id;
-          recordedResponse.timestamp = part.response.timestamp;
-          recordedResponse.modelId = part.response.modelId;
-          recordedResponse.headers = part.response.headers;
-          recordedUsage = part.usage;
+          recordedTotalUsage = part.totalUsage;
           recordedFinishReason = part.finishReason;
         }
       },
       async flush(controller) {
-        var _a17;
         try {
           if (recordedSteps.length === 0) {
             return;
           }
-          const lastStep = recordedSteps[recordedSteps.length - 1];
-          self.contentPromise.resolve(lastStep.content);
-          self.warningsPromise.resolve(lastStep.warnings);
-          self.requestPromise.resolve(lastStep.request);
-          self.responsePromise.resolve(lastStep.response);
-          self.toolCallsPromise.resolve(lastStep.toolCalls);
-          self.toolResultsPromise.resolve(lastStep.toolResults);
-          self.providerMetadataPromise.resolve(lastStep.providerMetadata);
-          self.reasoningPromise.resolve(lastStep.reasoningText);
-          self.reasoningDetailsPromise.resolve(lastStep.reasoning);
           const finishReason = recordedFinishReason != null ? recordedFinishReason : "unknown";
-          const usage = recordedUsage != null ? recordedUsage : {
+          const totalUsage = recordedTotalUsage != null ? recordedTotalUsage : {
             inputTokens: void 0,
             outputTokens: void 0,
             totalTokens: void 0
           };
           self.finishReasonPromise.resolve(finishReason);
-          self.usagePromise.resolve(usage);
-          self.textPromise.resolve(recordedFullText);
-          self.sourcesPromise.resolve(recordedSources);
-          self.filesPromise.resolve(lastStep.files);
+          self.totalUsagePromise.resolve(totalUsage);
           self.stepsPromise.resolve(recordedSteps);
+          const finalStep = recordedSteps[recordedSteps.length - 1];
           await (onFinish == null ? void 0 : onFinish({
             finishReason,
-            usage,
-            content: lastStep.content,
-            text: recordedFullText,
-            reasoningText: lastStep.reasoningText,
-            reasoning: lastStep.reasoning,
-            files: lastStep.files,
-            sources: lastStep.sources,
-            toolCalls: lastStep.toolCalls,
-            toolResults: lastStep.toolResults,
-            request: (_a17 = lastStep.request) != null ? _a17 : {},
-            response: lastStep.response,
-            warnings: lastStep.warnings,
-            providerMetadata: lastStep.providerMetadata,
+            totalUsage,
+            usage: finalStep.usage,
+            content: finalStep.content,
+            text: finalStep.text,
+            reasoningText: finalStep.reasoningText,
+            reasoning: finalStep.reasoning,
+            files: finalStep.files,
+            sources: finalStep.sources,
+            toolCalls: finalStep.toolCalls,
+            toolResults: finalStep.toolResults,
+            request: finalStep.request,
+            response: finalStep.response,
+            warnings: finalStep.warnings,
+            providerMetadata: finalStep.providerMetadata,
             steps: recordedSteps
           }));
           rootSpan.setAttributes(
@@ -6523,18 +6185,18 @@ var DefaultStreamTextResult = class {
               telemetry,
               attributes: {
                 "ai.response.finishReason": finishReason,
-                "ai.response.text": { output: () => recordedFullText },
+                "ai.response.text": { output: () => finalStep.text },
                 "ai.response.toolCalls": {
                   output: () => {
-                    var _a18;
-                    return ((_a18 = lastStep.toolCalls) == null ? void 0 : _a18.length) ? JSON.stringify(lastStep.toolCalls) : void 0;
+                    var _a17;
+                    return ((_a17 = finalStep.toolCalls) == null ? void 0 : _a17.length) ? JSON.stringify(finalStep.toolCalls) : void 0;
                   }
                 },
-                "ai.usage.inputTokens": usage.inputTokens,
-                "ai.usage.outputTokens": usage.outputTokens,
-                "ai.usage.totalTokens": usage.totalTokens,
-                "ai.usage.reasoningTokens": usage.reasoningTokens,
-                "ai.usage.cachedInputTokens": usage.cachedInputTokens
+                "ai.usage.inputTokens": totalUsage.inputTokens,
+                "ai.usage.outputTokens": totalUsage.outputTokens,
+                "ai.usage.totalTokens": totalUsage.totalTokens,
+                "ai.usage.reasoningTokens": totalUsage.reasoningTokens,
+                "ai.usage.cachedInputTokens": totalUsage.cachedInputTokens
               }
             })
           );
@@ -6593,11 +6255,7 @@ var DefaultStreamTextResult = class {
         async function streamStep({
           currentStep,
           responseMessages,
-          usage,
-          stepType: stepType2,
-          previousStepText,
-          hasLeadingWhitespace,
-          messageId
+          usage
         }) {
           const initialPrompt = await standardizePrompt({
             system,
@@ -6695,8 +6353,7 @@ var DefaultStreamTextResult = class {
           const stepToolCalls = [];
           const stepToolResults = [];
           let warnings;
-          const stepReasoning = [];
-          const stepFiles = [];
+          const stepContent = [];
           let activeReasoningPart2 = void 0;
           let stepFinishReason = "unknown";
           let stepUsage = {
@@ -6707,25 +6364,17 @@ var DefaultStreamTextResult = class {
           let stepProviderMetadata;
           let stepFirstChunk = true;
           let stepText = "";
-          let fullStepText = stepType2 === "continue" ? previousStepText : "";
           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.text;
-            fullStepText += chunk.text;
-            chunkTextPublished = true;
-            hasWhitespaceSuffix = chunk.text.trimEnd() !== chunk.text;
           }
           self.addStream(
             transformedStream.pipeThrough(
@@ -6734,6 +6383,7 @@ var DefaultStreamTextResult = class {
                   var _a17, _b, _c, _d;
                   if (chunk.type === "stream-start") {
                     warnings = chunk.warnings;
+                    controller.enqueue({ type: "start" });
                     return;
                   }
                   if (stepFirstChunk) {
@@ -6746,8 +6396,7 @@ var DefaultStreamTextResult = class {
                       "ai.response.msToFirstChunk": msToFirstChunk
                     });
                     controller.enqueue({
-                      type: "step-start",
-                      messageId,
+                      type: "start-step",
                       request: stepRequest,
                       warnings: warnings != null ? warnings : []
                     });
@@ -6758,27 +6407,7 @@ var DefaultStreamTextResult = class {
                   const chunkType = chunk.type;
                   switch (chunkType) {
                     case "text": {
-                      if (continueSteps) {
-                        const trimmedChunkText = inWhitespacePrefix && hasLeadingWhitespace ? chunk.text.trimStart() : chunk.text;
-                        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",
-                              text: split.prefix + split.whitespace
-                            }
-                          });
-                        }
-                      } else {
-                        await publishTextChunk({ controller, chunk });
-                      }
+                      await publishTextChunk({ controller, chunk });
                       break;
                     }
                     case "reasoning": {
@@ -6787,12 +6416,12 @@ var DefaultStreamTextResult = class {
                         activeReasoningPart2 = {
                           type: "reasoning",
                           text: chunk.text,
-                          providerOptions: chunk.providerMetadata
+                          providerMetadata: chunk.providerMetadata
                         };
-                        stepReasoning.push(activeReasoningPart2);
+                        stepContent.push(activeReasoningPart2);
                       } else {
                         activeReasoningPart2.text += chunk.text;
-                        activeReasoningPart2.providerOptions = chunk.providerMetadata;
+                        activeReasoningPart2.providerMetadata = chunk.providerMetadata;
                       }
                       break;
                     }
@@ -6804,11 +6433,13 @@ var DefaultStreamTextResult = class {
                     case "tool-call": {
                       controller.enqueue(chunk);
                       stepToolCalls.push(chunk);
+                      stepContent.push(chunk);
                       break;
                     }
                     case "tool-result": {
                       controller.enqueue(chunk);
                       stepToolResults.push(chunk);
+                      stepContent.push(chunk);
                       break;
                     }
                     case "response-metadata": {
@@ -6832,11 +6463,15 @@ var DefaultStreamTextResult = class {
                       break;
                     }
                     case "file": {
-                      stepFiles.push(chunk.file);
+                      stepContent.push(chunk);
+                      controller.enqueue(chunk);
+                      break;
+                    }
+                    case "source": {
+                      stepContent.push(chunk);
                       controller.enqueue(chunk);
                       break;
                     }
-                    case "source":
                     case "tool-call-streaming-start":
                     case "tool-call-delta": {
                       controller.enqueue(chunk);
@@ -6856,27 +6491,6 @@ var DefaultStreamTextResult = class {
                 // 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
-                  stepType2 === "continue" && !chunkTextPublished)) {
-                    await publishTextChunk({
-                      controller,
-                      chunk: { type: "text", text: chunkBuffer }
-                    });
-                    chunkBuffer = "";
-                  }
                   try {
                     doStreamSpan.setAttributes(
                       selectTelemetryAttributes({
@@ -6909,69 +6523,37 @@ var DefaultStreamTextResult = class {
                     doStreamSpan.end();
                   }
                   controller.enqueue({
-                    type: "step-finish",
+                    type: "finish-step",
                     finishReason: stepFinishReason,
                     usage: stepUsage,
                     providerMetadata: stepProviderMetadata,
-                    request: stepRequest,
                     response: {
                       ...stepResponse,
                       headers: response == null ? void 0 : response.headers
-                    },
-                    warnings,
-                    isContinued: nextStepType === "continue",
-                    messageId
+                    }
                   });
                   const combinedUsage = addLanguageModelUsage(usage, stepUsage);
-                  if (nextStepType === "done") {
+                  if (currentStep + 1 < maxSteps && // there are tool calls:
+                  stepToolCalls.length > 0 && // all current tool calls have results:
+                  stepToolResults.length === stepToolCalls.length) {
+                    responseMessages.push(
+                      ...toResponseMessages({
+                        content: stepContent,
+                        tools: tools != null ? tools : {}
+                      })
+                    );
+                    await streamStep({
+                      currentStep: currentStep + 1,
+                      responseMessages,
+                      usage: combinedUsage
+                    });
+                  } else {
                     controller.enqueue({
                       type: "finish",
                       finishReason: stepFinishReason,
-                      usage: combinedUsage,
-                      providerMetadata: stepProviderMetadata,
-                      response: {
-                        ...stepResponse,
-                        headers: response == null ? void 0 : response.headers
-                      }
+                      totalUsage: combinedUsage
                     });
                     self.closeStream();
-                  } else {
-                    if (stepType2 === "continue") {
-                      const lastMessage = responseMessages[responseMessages.length - 1];
-                      if (typeof lastMessage.content === "string") {
-                        lastMessage.content += stepText;
-                      } else {
-                        lastMessage.content.push({
-                          text: stepText,
-                          type: "text"
-                        });
-                      }
-                    } else {
-                      responseMessages.push(
-                        ...toResponseMessages({
-                          text: stepText,
-                          files: stepFiles,
-                          reasoning: stepReasoning,
-                          tools: tools != null ? tools : {},
-                          toolCalls: stepToolCalls,
-                          toolResults: stepToolResults,
-                          messageId,
-                          generateMessageId
-                        })
-                      );
-                    }
-                    await streamStep({
-                      currentStep: currentStep + 1,
-                      responseMessages,
-                      usage: combinedUsage,
-                      stepType: nextStepType,
-                      previousStepText: fullStepText,
-                      hasLeadingWhitespace: hasWhitespaceSuffix,
-                      messageId: (
-                        // keep the same id when continuing a step:
-                        nextStepType === "continue" ? messageId : generateMessageId()
-                      )
-                    });
                   }
                 }
               })
@@ -6985,11 +6567,7 @@ var DefaultStreamTextResult = class {
             inputTokens: void 0,
             outputTokens: void 0,
             totalTokens: void 0
-          },
-          previousStepText: "",
-          stepType: "initial",
-          hasLeadingWhitespace: false,
-          messageId: generateMessageId()
+          }
         });
       }
     }).catch((error) => {
@@ -7004,50 +6582,56 @@ var DefaultStreamTextResult = class {
       self.closeStream();
     });
   }
-  get content() {
-    return this.contentPromise.value;
+  get steps() {
+    return this.stepsPromise.value;
   }
-  get warnings() {
-    return this.warningsPromise.value;
+  get finalStep() {
+    return this.steps.then((steps) => steps[steps.length - 1]);
   }
-  get usage() {
-    return this.usagePromise.value;
+  get content() {
+    return this.finalStep.then((step) => step.content);
   }
-  get finishReason() {
-    return this.finishReasonPromise.value;
+  get warnings() {
+    return this.finalStep.then((step) => step.warnings);
   }
   get providerMetadata() {
-    return this.providerMetadataPromise.value;
+    return this.finalStep.then((step) => step.providerMetadata);
   }
   get text() {
-    return this.textPromise.value;
+    return this.finalStep.then((step) => step.text);
   }
   get reasoningText() {
-    return this.reasoningPromise.value;
+    return this.finalStep.then((step) => step.reasoningText);
   }
   get reasoning() {
-    return this.reasoningDetailsPromise.value;
+    return this.finalStep.then((step) => step.reasoning);
   }
   get sources() {
-    return this.sourcesPromise.value;
+    return this.finalStep.then((step) => step.sources);
   }
   get files() {
-    return this.filesPromise.value;
+    return this.finalStep.then((step) => step.files);
   }
   get toolCalls() {
-    return this.toolCallsPromise.value;
+    return this.finalStep.then((step) => step.toolCalls);
   }
   get toolResults() {
-    return this.toolResultsPromise.value;
+    return this.finalStep.then((step) => step.toolResults);
+  }
+  get usage() {
+    return this.finalStep.then((step) => step.usage);
   }
   get request() {
-    return this.requestPromise.value;
+    return this.finalStep.then((step) => step.request);
   }
   get response() {
-    return this.responsePromise.value;
+    return this.finalStep.then((step) => step.response);
   }
-  get steps() {
-    return this.stepsPromise.value;
+  get totalUsage() {
+    return this.totalUsagePromise.value;
+  }
+  get finishReason() {
+    return this.finishReasonPromise.value;
   }
   /**
   Split out a new stream from the original stream.
@@ -7113,26 +6697,33 @@ var DefaultStreamTextResult = class {
       )
     );
   }
-  toDataStream({
-    onError = () => "An error occurred.",
-    // mask error messages for safety by default
-    sendUsage = true,
+  toUIMessageStream({
+    newMessageId,
+    originalMessages = [],
+    onFinish,
+    messageMetadata,
     sendReasoning = false,
     sendSources = false,
-    experimental_sendFinish = true
+    experimental_sendStart = true,
+    experimental_sendFinish = true,
+    onError = () => "An error occurred."
+    // mask error messages for safety by default
   } = {}) {
-    return this.fullStream.pipeThrough(
+    const lastMessage = originalMessages[originalMessages.length - 1];
+    const isContinuation = (lastMessage == null ? void 0 : lastMessage.role) === "assistant";
+    const messageId = isContinuation ? lastMessage.id : newMessageId;
+    const baseStream = this.fullStream.pipeThrough(
       new TransformStream({
-        transform: async (chunk, controller) => {
-          const chunkType = chunk.type;
-          switch (chunkType) {
+        transform: async (part, controller) => {
+          const partType = part.type;
+          switch (partType) {
             case "text": {
-              controller.enqueue({ type: "text", value: chunk.text });
+              controller.enqueue({ type: "text", value: part.text });
               break;
             }
             case "reasoning": {
               if (sendReasoning) {
-                controller.enqueue({ type: "reasoning", value: chunk });
+                controller.enqueue({ type: "reasoning", value: part });
               }
               break;
             }
@@ -7149,15 +6740,15 @@ var DefaultStreamTextResult = class {
               controller.enqueue({
                 type: "file",
                 value: {
-                  mediaType: chunk.file.mediaType,
-                  url: `data:${chunk.file.mediaType};base64,${chunk.file.base64}`
+                  mediaType: part.file.mediaType,
+                  url: `data:${part.file.mediaType};base64,${part.file.base64}`
                 }
               });
               break;
             }
             case "source": {
               if (sendSources) {
-                controller.enqueue({ type: "source", value: chunk });
+                controller.enqueue({ type: "source", value: part });
               }
               break;
             }
@@ -7165,8 +6756,8 @@ var DefaultStreamTextResult = class {
               controller.enqueue({
                 type: "tool-call-streaming-start",
                 value: {
-                  toolCallId: chunk.toolCallId,
-                  toolName: chunk.toolName
+                  toolCallId: part.toolCallId,
+                  toolName: part.toolName
                 }
               });
               break;
@@ -7175,8 +6766,8 @@ var DefaultStreamTextResult = class {
               controller.enqueue({
                 type: "tool-call-delta",
                 value: {
-                  toolCallId: chunk.toolCallId,
-                  argsTextDelta: chunk.argsTextDelta
+                  toolCallId: part.toolCallId,
+                  argsTextDelta: part.argsTextDelta
                 }
               });
               break;
@@ -7185,9 +6776,9 @@ var DefaultStreamTextResult = class {
               controller.enqueue({
                 type: "tool-call",
                 value: {
-                  toolCallId: chunk.toolCallId,
-                  toolName: chunk.toolName,
-                  args: chunk.args
+                  toolCallId: part.toolCallId,
+                  toolName: part.toolName,
+                  args: part.args
                 }
               });
               break;
@@ -7196,8 +6787,8 @@ var DefaultStreamTextResult = class {
               controller.enqueue({
                 type: "tool-result",
                 value: {
-                  toolCallId: chunk.toolCallId,
-                  result: chunk.result
+                  toolCallId: part.toolCallId,
+                  result: part.result
                 }
               });
               break;
@@ -7205,69 +6796,100 @@ var DefaultStreamTextResult = class {
             case "error": {
               controller.enqueue({
                 type: "error",
-                value: onError(chunk.error)
+                value: onError(part.error)
               });
               break;
             }
-            case "step-start": {
+            case "start-step": {
               controller.enqueue({
                 type: "start-step",
                 value: {
-                  messageId: chunk.messageId
+                  metadata: messageMetadata == null ? void 0 : messageMetadata({ part })
                 }
               });
               break;
             }
-            case "step-finish": {
+            case "finish-step": {
               controller.enqueue({
                 type: "finish-step",
                 value: {
-                  finishReason: chunk.finishReason,
-                  usage: sendUsage ? chunk.usage : void 0,
-                  isContinued: chunk.isContinued
+                  metadata: messageMetadata == null ? void 0 : messageMetadata({ part })
                 }
               });
               break;
             }
+            case "start": {
+              if (experimental_sendStart) {
+                controller.enqueue({
+                  type: "start",
+                  value: {
+                    messageId,
+                    metadata: messageMetadata == null ? void 0 : messageMetadata({ part })
+                  }
+                });
+              }
+              break;
+            }
             case "finish": {
               if (experimental_sendFinish) {
                 controller.enqueue({
-                  type: "finish-message",
+                  type: "finish",
                   value: {
-                    finishReason: chunk.finishReason,
-                    usage: sendUsage ? chunk.usage : void 0
+                    metadata: messageMetadata == null ? void 0 : messageMetadata({ part })
                   }
                 });
               }
               break;
             }
             default: {
-              const exhaustiveCheck = chunkType;
+              const exhaustiveCheck = partType;
               throw new Error(`Unknown chunk type: ${exhaustiveCheck}`);
             }
           }
         }
       })
     );
+    return onFinish == null ? baseStream : processUIMessageStream({
+      stream: baseStream,
+      lastMessage,
+      newMessageId: messageId != null ? messageId : this.generateId(),
+      onFinish: ({ message }) => {
+        const isContinuation2 = message.id === (lastMessage == null ? void 0 : lastMessage.id);
+        onFinish({
+          isContinuation: isContinuation2,
+          responseMessage: message,
+          messages: [
+            ...isContinuation2 ? originalMessages.slice(0, -1) : originalMessages,
+            message
+          ]
+        });
+      }
+    });
   }
-  pipeDataStreamToResponse(response, {
-    onError,
-    sendUsage,
+  pipeUIMessageStreamToResponse(response, {
+    newMessageId,
+    originalMessages,
+    onFinish,
+    messageMetadata,
     sendReasoning,
     sendSources,
     experimental_sendFinish,
     experimental_sendStart,
+    onError,
     ...init
   } = {}) {
-    pipeDataStreamToResponse({
+    pipeUIMessageStreamToResponse({
       response,
-      dataStream: this.toDataStream({
-        onError,
-        sendUsage,
+      stream: this.toUIMessageStream({
+        newMessageId,
+        originalMessages,
+        onFinish,
+        messageMetadata,
         sendReasoning,
         sendSources,
         experimental_sendFinish,
-        experimental_sendStart
+        experimental_sendStart,
+        onError
       }),
       ...init
     });
@@ -7279,23 +6901,29 @@ var DefaultStreamTextResult = class {
       ...init
     });
   }
-  toDataStreamResponse({
-    onError,
-    sendUsage,
+  toUIMessageStreamResponse({
+    newMessageId,
+    originalMessages,
+    onFinish,
+    messageMetadata,
     sendReasoning,
     sendSources,
     experimental_sendFinish,
     experimental_sendStart,
+    onError,
     ...init
   } = {}) {
-    return createDataStreamResponse({
-      dataStream: this.toDataStream({
-        onError,
-        sendUsage,
+    return createUIMessageStreamResponse({
+      stream: this.toUIMessageStream({
+        newMessageId,
+        originalMessages,
+        onFinish,
+        messageMetadata,
         sendReasoning,
         sendSources,
         experimental_sendFinish,
-        experimental_sendStart
+        experimental_sendStart,
+        onError
       }),
       ...init
     });
@@ -7308,39 +6936,6 @@ var DefaultStreamTextResult = class {
   }
 };
 
-// src/util/merge-objects.ts
-function mergeObjects(target, source) {
-  if (target === void 0 && source === void 0) {
-    return void 0;
-  }
-  if (target === void 0) {
-    return source;
-  }
-  if (source === void 0) {
-    return target;
-  }
-  const result = { ...target };
-  for (const key in source) {
-    if (Object.prototype.hasOwnProperty.call(source, key)) {
-      const sourceValue = source[key];
-      if (sourceValue === void 0)
-        continue;
-      const targetValue = key in target ? target[key] : void 0;
-      const isSourceObject = sourceValue !== null && typeof sourceValue === "object" && !Array.isArray(sourceValue) && !(sourceValue instanceof Date) && !(sourceValue instanceof RegExp);
-      const isTargetObject = targetValue !== null && targetValue !== void 0 && typeof targetValue === "object" && !Array.isArray(targetValue) && !(targetValue instanceof Date) && !(targetValue instanceof RegExp);
-      if (isSourceObject && isTargetObject) {
-        result[key] = mergeObjects(
-          targetValue,
-          sourceValue
-        );
-      } else {
-        result[key] = sourceValue;
-      }
-    }
-  }
-  return result;
-}
-
 // core/middleware/default-settings-middleware.ts
 function defaultSettingsMiddleware({
   settings
@@ -7348,33 +6943,7 @@ function defaultSettingsMiddleware({
   return {
     middlewareVersion: "v2",
     transformParams: async ({ params }) => {
-      var _a17, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
-      return {
-        ...settings,
-        ...params,
-        // map all values that are null to undefined
-        maxOutputTokens: settings.maxOutputTokens !== null ? (_a17 = params.maxOutputTokens) != null ? _a17 : settings.maxOutputTokens : void 0,
-        temperature: settings.temperature !== null ? (
-          // temperature: special case 0 or null
-          params.temperature === 0 || params.temperature == null ? (_b = settings.temperature) != null ? _b : params.temperature : params.temperature
-        ) : void 0,
-        stopSequences: settings.stopSequences !== null ? (_c = params.stopSequences) != null ? _c : settings.stopSequences : void 0,
-        topP: settings.topP !== null ? (_d = params.topP) != null ? _d : settings.topP : void 0,
-        topK: settings.topK !== null ? (_e = params.topK) != null ? _e : settings.topK : void 0,
-        presencePenalty: settings.presencePenalty !== null ? (_f = params.presencePenalty) != null ? _f : settings.presencePenalty : void 0,
-        frequencyPenalty: settings.frequencyPenalty !== null ? (_g = params.frequencyPenalty) != null ? _g : settings.frequencyPenalty : void 0,
-        responseFormat: settings.responseFormat !== null ? (_h = params.responseFormat) != null ? _h : settings.responseFormat : void 0,
-        seed: settings.seed !== null ? (_i = params.seed) != null ? _i : settings.seed : void 0,
-        tools: settings.tools !== null ? (_j = params.tools) != null ? _j : settings.tools : void 0,
-        toolChoice: settings.toolChoice !== null ? (_k = params.toolChoice) != null ? _k : settings.toolChoice : void 0,
-        // headers: deep merge
-        headers: mergeObjects(settings.headers, params.headers),
-        // provider options: deep merge
-        providerOptions: mergeObjects(
-          settings.providerOptions,
-          params.providerOptions
-        )
-      };
+      return mergeObjects(settings, params);
     }
   };
 }
@@ -7636,7 +7205,7 @@ function customProvider({
 var experimental_customProvider = customProvider;
 
 // core/registry/no-such-provider-error.ts
-import { AISDKError as AISDKError20, NoSuchModelError as NoSuchModelError3 } from "@ai-sdk/provider";
+import { AISDKError as AISDKError19, NoSuchModelError as NoSuchModelError3 } from "@ai-sdk/provider";
 var name16 = "AI_NoSuchProviderError";
 var marker16 = `vercel.ai.error.${name16}`;
 var symbol16 = Symbol.for(marker16);
@@ -7655,7 +7224,7 @@ var NoSuchProviderError = class extends NoSuchModelError3 {
     this.availableProviders = availableProviders;
   }
   static isInstance(error) {
-    return AISDKError20.hasMarker(error, marker16);
+    return AISDKError19.hasMarker(error, marker16);
   }
 };
 _a16 = symbol16;
@@ -7751,7 +7320,7 @@ function tool(tool2) {
 }
 
 // core/tool/mcp/mcp-sse-transport.ts
-import { createEventSourceParserStream as createEventSourceParserStream2 } from "@ai-sdk/provider-utils";
+import { createEventSourceParserStream } from "@ai-sdk/provider-utils";
 
 // core/tool/mcp/json-rpc-message.ts
 import { z as z10 } from "zod";
@@ -7922,7 +7491,7 @@ var SseMCPTransport = class {
             (_b = this.onerror) == null ? void 0 : _b.call(this, error);
             return reject(error);
           }
-          const stream = response.body.pipeThrough(new TextDecoderStream()).pipeThrough(createEventSourceParserStream2());
+          const stream = response.body.pipeThrough(new TextDecoderStream()).pipeThrough(createEventSourceParserStream());
           const reader = stream.getReader();
           const processEvents = async () => {
             var _a18, _b2, _c2;
@@ -8310,8 +7879,8 @@ var MCPClient = class {
 };
 
 // src/error/no-transcript-generated-error.ts
-import { AISDKError as AISDKError21 } from "@ai-sdk/provider";
-var NoTranscriptGeneratedError = class extends AISDKError21 {
+import { AISDKError as AISDKError20 } from "@ai-sdk/provider";
+var NoTranscriptGeneratedError = class extends AISDKError20 {
   constructor(options) {
     super({
       name: "AI_NoTranscriptGeneratedError",
@@ -8403,7 +7972,6 @@ export {
   TypeValidationError,
   UnsupportedFunctionalityError,
   appendClientMessage,
-  appendResponseMessages,
   asSchema5 as asSchema,
   assistantModelMessageSchema,
   callChatApi,
@@ -8417,11 +7985,11 @@ export {
   coreToolMessageSchema,
   coreUserMessageSchema,
   cosineSimilarity,
-  createDataStream,
-  createDataStreamResponse,
   createIdGenerator5 as createIdGenerator,
   createProviderRegistry,
   createTextStreamResponse,
+  createUIMessageStream,
+  createUIMessageStreamResponse,
   customProvider,
   defaultSettingsMiddleware,
   embed,
@@ -8444,9 +8012,8 @@ export {
   jsonSchema2 as jsonSchema,
   modelMessageSchema,
   parsePartialJson,
-  pipeDataStreamToResponse,
   pipeTextStreamToResponse,
-  processDataStream,
+  pipeUIMessageStreamToResponse,
   processTextStream,
   shouldResubmitMessages,
   simulateReadableStream,